diff --git a/README.md b/README.md index d6ca111..08e4f76 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@ # mathfunctionize [![PyPI Downloads](https://static.pepy.tech/personalized-badge/mathfunctionize?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/mathfunctionize) -An extensive Python library for math functions in advanced fields of math. Visit [upcoming.md](upcoming.md) for future functions to be added. +An extensive Python library for math functions in advanced fields of math. Visit [upcoming.md](upcoming.md) for the research roadmap and [professional_function_catalog.md](professional_function_catalog.md) for the professional API backlog. [Website](https://mathfunctionize.web.app/) ## Getting Started --- diff --git a/mathfunctionize/__init__.py b/mathfunctionize/__init__.py index 357c4ad..66f2907 100644 --- a/mathfunctionize/__init__.py +++ b/mathfunctionize/__init__.py @@ -1 +1,12 @@ -from .mathfunctionize import * \ No newline at end of file +from .mathfunctionize import * +from .upcoming import ( + UPCOMING_FUNCTION_ENTRIES, + UPCOMING_FUNCTIONS, + UPCOMING_TOPICS, + UpcomingFunction, + UpcomingFunctionNotImplemented, + get_upcoming_function_metadata, + is_upcoming_function, + list_upcoming_functions, + list_upcoming_topics, +) \ No newline at end of file diff --git a/mathfunctionize/mathfunctionize.py b/mathfunctionize/mathfunctionize.py index 590099e..d4a8ccb 100644 --- a/mathfunctionize/mathfunctionize.py +++ b/mathfunctionize/mathfunctionize.py @@ -108,64 +108,146 @@ def normalCDF(x, mean, stdDev): prob = 1 - prob return prob def gammaPDF(x, a, b): - return (1/gamma(a))*power([b*x, a/x])*power([e, -b*x]) + if x < 0 or a <= 0 or b <= 0: + raise Exception("Invalid input") + return ((b ** a) / gamma(a)) * (x ** (a - 1)) * (e ** (-b * x)) +def bernoulliPMF(x, p): + if p < 0 or p > 1 or (x != 0 and x != 1): + raise Exception("Invalid input") + return (p ** x) * ((1 - p) ** (1 - x)) +def binomialPMF(k, n, p): + if k < 0 or n < 0 or k > n or p < 0 or p > 1: + raise Exception("Invalid input") + return combinations(n, k) * (p ** k) * ((1 - p) ** (n - k)) +def binomialCDF(k, n, p): + if k < 0: + return 0 + if k >= n: + return 1 + total = 0 + for i in range(int(k) + 1): + total += binomialPMF(i, n, p) + return total +def poissonPMF(k, lam): + if k < 0 or lam <= 0: + raise Exception("Invalid input") + return ((lam ** k) * (e ** (-lam))) / factorial(k) +def poissonCDF(k, lam): + if k < 0: + return 0 + total = 0 + for i in range(int(k) + 1): + total += poissonPMF(i, lam) + return total +def exponentialPDF(x, lam): + if lam <= 0: + raise Exception("Invalid input") + if x < 0: + return 0 + return lam * (e ** (-lam * x)) +def exponentialCDF(x, lam): + if lam <= 0: + raise Exception("Invalid input") + if x < 0: + return 0 + return 1 - (e ** (-lam * x)) +def expectedValue(values, probabilities): + if len(values) != len(probabilities) or len(values) == 0: + raise Exception("Invalid input") + if absolute(addition(probabilities) - 1) > 1e-9: + raise Exception("Invalid input") + total = 0 + for i in range(len(values)): + if probabilities[i] < 0: + raise Exception("Invalid input") + total += values[i] * probabilities[i] + return total +def conditionalProbability(pAB, pB): + if pAB < 0 or pB <= 0 or pAB > pB: + raise Exception("Invalid input") + return pAB / pB +def independent(pA, pB, pAB, tolerance=1e-9): + return absolute((pA * pB) - pAB) <= tolerance # complex numbers +def parseComplex(z): + if isinstance(z, (int, float)): + return [float(z), 0.0] + if not isinstance(z, str): + raise Exception("Invalid input") + value = z.replace(" ", "") + if len(value) == 0: + raise Exception("Invalid input") + if value.endswith("i"): + without_i = value[:-1] + split_at = -1 + for i in range(1, len(without_i)): + if without_i[i] == "+" or without_i[i] == "-": + split_at = i + if split_at != -1: + real = float(without_i[:split_at]) + imaginary_part = without_i[split_at:] + else: + real = 0.0 + imaginary_part = without_i + if imaginary_part == "" or imaginary_part == "+": + imag = 1.0 + elif imaginary_part == "-": + imag = -1.0 + else: + imag = float(imaginary_part) + return [real, imag] + return [float(value), 0.0] +def _formatComplexNumberPart(x): + if absolute(x - int(x)) < 1e-10: + return str(int(x)) + return str(x) +def formatComplex(real, imaginary): + if absolute(real) < 1e-10: + real = 0.0 + if absolute(imaginary) < 1e-10: + imaginary = 0.0 + real_text = _formatComplexNumberPart(real) + imag_text = _formatComplexNumberPart(absolute(imaginary)) + if imaginary < 0: + return real_text + "-" + imag_text + "i" + return real_text + "+" + imag_text + "i" def complex_addition(a, b): - if a.find("+") != -1: - a1 = float(a[0:a.find("+")]) - a2 = float(a[a.find("+")+1:a.find("i")]) - elif a.find("-", 1) != -1: - a1 = float(a[0:a.find("-", 1)]) - a2 = float(a[a.find("-", 1):a.find("i")]) - elif a.find("i") != -1: - a1 = 0 - a2 = float(a[0:a.find("i")]) - elif a.find("i") == -1: - a1 = float(a) - a2 = 0 - if b.find("+") != -1: - b1 = float(b[0:b.find("+")]) - b2 = float(b[b.find("+")+1:b.find("i")]) - elif b.find("-", 1) != -1: - b1 = float(b[0:b.find("-", 1)]) - b2 = float(b[b.find("-", 1):b.find("i")]) - elif b.find("i") != -1: - b1 = 0 - b2 = float(b[0:b.find("i")]) - elif b.find("i") == -1: - b1 = float(b) - b2 = 0 - if a2 + b2 >= 0: - return str(a1 + b1) + "+" + str(a2 + b2)+"i" - return str(a1 + b1) + str(a2 + b2)+"i" + a1, a2 = parseComplex(a) + b1, b2 = parseComplex(b) + return formatComplex(a1 + b1, a2 + b2) def complex_subtraction(a, b): - if a.find("+") != -1: - a1 = float(a[0:a.find("+")]) - a2 = float(a[a.find("+")+1:a.find("i")]) - elif a.find("-", 1) != -1: - a1 = float(a[0:a.find("-", 1)]) - a2 = float(a[a.find("-", 1):a.find("i")]) - elif a.find("i") != -1: - a1 = 0 - a2 = float(a[0:a.find("i")]) - elif a.find("i") == -1: - a1 = float(a) - a2 = 0 - if b.find("+") != -1: - b1 = float(b[0:b.find("+")]) - b2 = float(b[b.find("+")+1:b.find("i")]) - elif b.find("-", 1) != -1: - b1 = float(b[0:b.find("-", 1)]) - b2 = float(b[b.find("-", 1):b.find("i")]) - elif b.find("i") != -1: - b1 = 0 - b2 = float(b[0:b.find("i")]) - elif b.find("i") == -1: - b1 = float(b) - b2 = 0 - if a2 - b2 >= 0: - return str(a1 - b1) + "+" + str(a2 - b2)+"i" - return str(a1 - b1) + str(a2 - b2)+"i" + a1, a2 = parseComplex(a) + b1, b2 = parseComplex(b) + return formatComplex(a1 - b1, a2 - b2) +def complex_multiplication(a, b): + a1, a2 = parseComplex(a) + b1, b2 = parseComplex(b) + return formatComplex((a1 * b1) - (a2 * b2), (a1 * b2) + (a2 * b1)) +def complex_division(a, b): + a1, a2 = parseComplex(a) + b1, b2 = parseComplex(b) + denominator = (b1 ** 2) + (b2 ** 2) + if denominator == 0: + raise Exception("Invalid input") + real = ((a1 * b1) + (a2 * b2)) / denominator + imaginary = ((a2 * b1) - (a1 * b2)) / denominator + return formatComplex(real, imaginary) +def complex_modulus(z): + real, imaginary = parseComplex(z) + return ((real ** 2) + (imaginary ** 2)) ** 0.5 +def complex_argument(z): + import math + real, imaginary = parseComplex(z) + if real == 0 and imaginary == 0: + raise Exception("Invalid input") + return math.atan2(imaginary, real) +def rectangularToPolar(z): + return [complex_modulus(z), complex_argument(z)] +def polarToRectangular(r, theta): + import math + if r < 0: + raise Exception("Invalid input") + return formatComplex(r * math.cos(theta), r * math.sin(theta)) # quantitative analysis def localMinimum(arr): num = 0 @@ -237,23 +319,27 @@ def globalMaximum(arr): return [num, pos] # statistics def mean(arr): + if len(arr) == 0: + raise Exception("Invalid input") total = 0 for i in arr: total += i return total / len(arr) def median(arr): - arr.sort() if len(arr) == 0: - return - if len(arr)%2 == 0: - return (arr[int((len(arr)/2) - 1)] + arr[int(len(arr)/2)]) / 2 - return arr[int(len(arr)/2)] + raise Exception("Invalid input") + sorted_arr = sorted(arr) + if len(sorted_arr)%2 == 0: + return (sorted_arr[int((len(sorted_arr)/2) - 1)] + sorted_arr[int(len(sorted_arr)/2)]) / 2 + return sorted_arr[int(len(sorted_arr)/2)] def standardDevation(arr): m = mean(arr) total = 0 for i in arr: total += ((i - m)**2) return (total / len(arr))**0.5 +def standardDeviation(arr): + return standardDevation(arr) def mode(arr): if len(arr) == 0: raise Exception("Invalid input") @@ -269,22 +355,67 @@ def variance(arr): total = 0 for i in arr: total += ((i-m)**2) - return total / len(arr) -# def quartiles(arr): -# arr.sort() -# if len(arr) == 0: -# raise Exception("Invalid input") -# Q2 = median(arr) -# if len(arr) % 2 == 0: -# Q1 = median(arr[0:int(len(arr)/2)]) -# Q3 = median(arr[int(len(arr)/2):len(arr)]) -# else: -# Q1 = median(arr[0:int(len(arr)/2)]) -# Q3 = median(arr[int(len(arr)/2)+1:len(arr)]) -# return [Q1, Q2, Q3] -# def interquartileRange(arr): -# Q1, Q2, Q3 = quartiles(arr) -# return Q3 - Q1 + return total / len(arr) +def sampleVariance(arr): + if len(arr) < 2: + raise Exception("Invalid input") + m = mean(arr) + total = 0 + for i in arr: + total += ((i-m)**2) + return total / (len(arr) - 1) +def sampleStandardDeviation(arr): + return sampleVariance(arr)**0.5 +def quartiles(arr): + if len(arr) == 0: + raise Exception("Invalid input") + sorted_arr = sorted(arr) + Q2 = median(sorted_arr) + midpoint = int(len(sorted_arr)/2) + if len(sorted_arr) % 2 == 0: + lower = sorted_arr[0:midpoint] + upper = sorted_arr[midpoint:len(sorted_arr)] + else: + lower = sorted_arr[0:midpoint] + upper = sorted_arr[midpoint+1:len(sorted_arr)] + Q1 = median(lower) if len(lower) > 0 else sorted_arr[0] + Q3 = median(upper) if len(upper) > 0 else sorted_arr[-1] + return [Q1, Q2, Q3] +def interquartileRange(arr): + Q1, Q2, Q3 = quartiles(arr) + return Q3 - Q1 +def percentile(arr, p): + if len(arr) == 0 or p < 0 or p > 100: + raise Exception("Invalid input") + sorted_arr = sorted(arr) + if len(sorted_arr) == 1: + return sorted_arr[0] + position = (p / 100) * (len(sorted_arr) - 1) + lower = int(position) + upper = lower + 1 + if upper >= len(sorted_arr): + return sorted_arr[lower] + weight = position - lower + return sorted_arr[lower] * (1 - weight) + sorted_arr[upper] * weight +def zScore(x, meanValue, stdDev): + if stdDev == 0: + raise Exception("Invalid input") + return (x - meanValue) / stdDev +def covariance(xValues, yValues): + if len(xValues) != len(yValues) or len(xValues) == 0: + raise Exception("Invalid input") + xMean = mean(xValues) + yMean = mean(yValues) + total = 0 + for i in range(len(xValues)): + total += (xValues[i] - xMean) * (yValues[i] - yMean) + return total / len(xValues) +def correlation(xValues, yValues): + xStdDev = standardDevation(xValues) + yStdDev = standardDevation(yValues) + if xStdDev == 0 or yStdDev == 0: + raise Exception("Invalid input") + return covariance(xValues, yValues) / (xStdDev * yStdDev) # naive set theory def set(arr): result = [] @@ -524,6 +655,103 @@ def transpose(arr): for j in range(len(arr)): temp[i].append(arr[j][i]) return temp +def identityMatrix(n): + if n < 1: + raise Exception("Invalid input") + result = [] + for i in range(n): + row = [] + for j in range(n): + row.append(1 if i == j else 0) + result.append(row) + return result +def trace(matrix): + if len(matrix) == 0 or len(matrix) != len(matrix[0]): + raise Exception("Invalid input") + total = 0 + for i in range(len(matrix)): + total += matrix[i][i] + return total +def matrixMinor(matrix, row, col): + if len(matrix) == 0 or len(matrix) != len(matrix[0]): + raise Exception("Invalid input") + return [matrix[i][0:col] + matrix[i][col+1:len(matrix[i])] for i in range(len(matrix)) if i != row] +def cofactorMatrix(matrix): + if len(matrix) == 0 or len(matrix) != len(matrix[0]): + raise Exception("Invalid input") + if len(matrix) == 1: + return [[1]] + result = [] + for i in range(len(matrix)): + result.append([]) + for j in range(len(matrix)): + sign = 1 if (i + j) % 2 == 0 else -1 + result[i].append(sign * determinant(matrixMinor(matrix, i, j))) + return result +def inverseMatrix(matrix): + det = determinant(matrix) + if det == 0: + raise Exception("Invalid input") + if len(matrix) == 1: + return [[1 / det]] + cofactors = cofactorMatrix(matrix) + adjugate = transpose(cofactors) + result = [] + for i in range(len(adjugate)): + result.append([]) + for j in range(len(adjugate[i])): + result[i].append(adjugate[i][j] / det) + return result +def rowEchelon(matrix): + if len(matrix) == 0: + raise Exception("Invalid input") + result = [row[:] for row in matrix] + lead = 0 + rowCount = len(result) + columnCount = len(result[0]) + for r in range(rowCount): + if lead >= columnCount: + return result + i = r + while result[i][lead] == 0: + i += 1 + if i == rowCount: + i = r + lead += 1 + if lead == columnCount: + return result + result[i], result[r] = result[r], result[i] + pivot = result[r][lead] + result[r] = [value / pivot for value in result[r]] + for i in range(r + 1, rowCount): + factor = result[i][lead] + result[i] = [result[i][j] - factor * result[r][j] for j in range(columnCount)] + lead += 1 + return result +def rank(matrix): + echelon = rowEchelon(matrix) + count = 0 + for row in echelon: + if any(absolute(value) > 1e-10 for value in row): + count += 1 + return count +def dotProduct(v, w): + if len(v) != len(w): + raise Exception("Invalid input") + total = 0 + for i in range(len(v)): + total += v[i] * w[i] + return total +def crossProduct(v, w): + if len(v) != 3 or len(w) != 3: + raise Exception("Invalid input") + return [ + v[1] * w[2] - v[2] * w[1], + v[2] * w[0] - v[0] * w[2], + v[0] * w[1] - v[1] * w[0], + ] +def vectorNorm(v): + return (dotProduct(v, v)) ** 0.5 # metric spaces def dist(x, y, metric="euclidean"): if len(x) != len(y): @@ -649,6 +877,112 @@ def isPrime(x): return False i += 2 return True +def gcd(a, b): + a = int(a) + b = int(b) + while b != 0: + a, b = b, a % b + return absolute(a) +def lcm(a, b): + if a == 0 or b == 0: + return 0 + return absolute(int(a * b)) // gcd(a, b) +def extendedGcd(a, b): + old_r = int(a) + r = int(b) + old_s = 1 + s = 0 + old_t = 0 + t = 1 + while r != 0: + quotient = old_r // r + old_r, r = r, old_r - quotient * r + old_s, s = s, old_s - quotient * s + old_t, t = t, old_t - quotient * t + if old_r < 0: + return [-old_r, -old_s, -old_t] + return [old_r, old_s, old_t] +def modularExponent(base, exponent, modulus): + if modulus == 0 or exponent < 0: + raise Exception("Invalid input") + result = 1 + base = base % modulus + exponent = int(exponent) + while exponent > 0: + if exponent % 2 == 1: + result = (result * base) % modulus + exponent //= 2 + base = (base * base) % modulus + return result +def modInverse(a, modulus): + if modulus == 0: + raise Exception("Invalid input") + g, x, y = extendedGcd(a, modulus) + if g != 1: + raise Exception("Invalid input") + return x % modulus +def primeFactors(n): + n = int(n) + if n < 2: + return [] + factors = [] + while n % 2 == 0: + factors.append(2) + n //= 2 + candidate = 3 + while candidate * candidate <= n: + while n % candidate == 0: + factors.append(candidate) + n //= candidate + candidate += 2 + if n > 1: + factors.append(n) + return factors +def sieve(limit): + if limit < 2: + return [] + primes = [True] * (limit + 1) + primes[0] = False + primes[1] = False + p = 2 + while p * p <= limit: + if primes[p]: + multiple = p * p + while multiple <= limit: + primes[multiple] = False + multiple += p + p += 1 + return [i for i in range(limit + 1) if primes[i]] +def eulerTotient(n): + n = int(n) + if n < 1: + raise Exception("Invalid input") + result = n + for p in set(primeFactors(n)): + result -= result // p + return result +def isCoprime(a, b): + return gcd(a, b) == 1 +def divisors(n): + n = int(n) + if n == 0: + raise Exception("Invalid input") + n = absolute(n) + result = [] + i = 1 + while i * i <= n: + if n % i == 0: + result.append(i) + if i != n // i: + result.append(n // i) + i += 1 + return sorted(result) +def isPerfectNumber(n): + if n < 2: + return False + properDivisors = divisors(n) + properDivisors.remove(n) + return addition(properDivisors) == n # topology def smooth(f, x): for n in range(1, 12): @@ -725,4 +1059,9 @@ def factor(coefficients): result.append([[1, -r], count]) if len(remaining) > 1 or (len(remaining) == 1 and absolute(remaining[0] - 1) > 1e-10): result.append([remaining, 1]) - return result \ No newline at end of file + return result + +from .upcoming import install_upcoming_functions as _install_upcoming_functions + +_UPCOMING_FUNCTION_NAMES = _install_upcoming_functions(globals(), overwrite=False) +del _install_upcoming_functions \ No newline at end of file diff --git a/mathfunctionize/upcoming.py b/mathfunctionize/upcoming.py new file mode 100644 index 0000000..9b1d66c --- /dev/null +++ b/mathfunctionize/upcoming.py @@ -0,0 +1,9443 @@ +"""Executable registry for planned mathfunctionize APIs. + +This module moves the roadmap from documentation into code. Planned +functions are real callables so users can discover the intended API surface, +but they raise NotImplementedError until each mathematical implementation is +completed and tested. +""" + +from dataclasses import dataclass + + +@dataclass(frozen=True) +class UpcomingFunction: + """Metadata for a planned mathfunctionize function.""" + + name: str + topic: str + signature: str + description: str + source: str + + +_RAW_FUNCTIONS = ( + ('abstractAlgebraApproximateField', 'Abstract Algebra', '(value, tolerance=1e-9)', 'Approximate a field with explicit tolerance controls.', 'professional_function_catalog.md'), + ('abstractAlgebraApproximateGroup', 'Abstract Algebra', '(value, tolerance=1e-9)', 'Approximate a group with explicit tolerance controls.', 'professional_function_catalog.md'), + ('abstractAlgebraApproximateHomomorphism', 'Abstract Algebra', '(value, tolerance=1e-9)', 'Approximate a homomorphism with explicit tolerance controls.', 'professional_function_catalog.md'), + ('abstractAlgebraApproximateModule', 'Abstract Algebra', '(value, tolerance=1e-9)', 'Approximate a module with explicit tolerance controls.', 'professional_function_catalog.md'), + ('abstractAlgebraApproximateRing', 'Abstract Algebra', '(value, tolerance=1e-9)', 'Approximate a ring with explicit tolerance controls.', 'professional_function_catalog.md'), + ('abstractAlgebraCanonicalizeField', 'Abstract Algebra', '(value)', 'Canonicalize a field so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('abstractAlgebraCanonicalizeGroup', 'Abstract Algebra', '(value)', 'Canonicalize a group so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('abstractAlgebraCanonicalizeHomomorphism', 'Abstract Algebra', '(value)', 'Canonicalize a homomorphism so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('abstractAlgebraCanonicalizeModule', 'Abstract Algebra', '(value)', 'Canonicalize a module so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('abstractAlgebraCanonicalizeRing', 'Abstract Algebra', '(value)', 'Canonicalize a ring so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('abstractAlgebraClassifyField', 'Abstract Algebra', '(value)', 'Classify a field by its standard Abstract Algebra invariants.', 'professional_function_catalog.md'), + ('abstractAlgebraClassifyGroup', 'Abstract Algebra', '(value)', 'Classify a group by its standard Abstract Algebra invariants.', 'professional_function_catalog.md'), + ('abstractAlgebraClassifyHomomorphism', 'Abstract Algebra', '(value)', 'Classify a homomorphism by its standard Abstract Algebra invariants.', 'professional_function_catalog.md'), + ('abstractAlgebraClassifyModule', 'Abstract Algebra', '(value)', 'Classify a module by its standard Abstract Algebra invariants.', 'professional_function_catalog.md'), + ('abstractAlgebraClassifyRing', 'Abstract Algebra', '(value)', 'Classify a ring by its standard Abstract Algebra invariants.', 'professional_function_catalog.md'), + ('abstractAlgebraCombineField', 'Abstract Algebra', '(left, right)', 'Combine two field values with the natural operation for Abstract Algebra.', 'professional_function_catalog.md'), + ('abstractAlgebraCombineGroup', 'Abstract Algebra', '(left, right)', 'Combine two group values with the natural operation for Abstract Algebra.', 'professional_function_catalog.md'), + ('abstractAlgebraCombineHomomorphism', 'Abstract Algebra', '(left, right)', 'Combine two homomorphism values with the natural operation for Abstract Algebra.', 'professional_function_catalog.md'), + ('abstractAlgebraCombineModule', 'Abstract Algebra', '(left, right)', 'Combine two module values with the natural operation for Abstract Algebra.', 'professional_function_catalog.md'), + ('abstractAlgebraCombineRing', 'Abstract Algebra', '(left, right)', 'Combine two ring values with the natural operation for Abstract Algebra.', 'professional_function_catalog.md'), + ('abstractAlgebraCompareField', 'Abstract Algebra', '(left, right)', 'Compare two field values under the conventions of Abstract Algebra.', 'professional_function_catalog.md'), + ('abstractAlgebraCompareGroup', 'Abstract Algebra', '(left, right)', 'Compare two group values under the conventions of Abstract Algebra.', 'professional_function_catalog.md'), + ('abstractAlgebraCompareHomomorphism', 'Abstract Algebra', '(left, right)', 'Compare two homomorphism values under the conventions of Abstract Algebra.', 'professional_function_catalog.md'), + ('abstractAlgebraCompareModule', 'Abstract Algebra', '(left, right)', 'Compare two module values under the conventions of Abstract Algebra.', 'professional_function_catalog.md'), + ('abstractAlgebraCompareRing', 'Abstract Algebra', '(left, right)', 'Compare two ring values under the conventions of Abstract Algebra.', 'professional_function_catalog.md'), + ('abstractAlgebraComputeField', 'Abstract Algebra', '(value)', 'Compute the central numerical or symbolic data of a field.', 'professional_function_catalog.md'), + ('abstractAlgebraComputeGroup', 'Abstract Algebra', '(value)', 'Compute the central numerical or symbolic data of a group.', 'professional_function_catalog.md'), + ('abstractAlgebraComputeHomomorphism', 'Abstract Algebra', '(value)', 'Compute the central numerical or symbolic data of a homomorphism.', 'professional_function_catalog.md'), + ('abstractAlgebraComputeModule', 'Abstract Algebra', '(value)', 'Compute the central numerical or symbolic data of a module.', 'professional_function_catalog.md'), + ('abstractAlgebraComputeRing', 'Abstract Algebra', '(value)', 'Compute the central numerical or symbolic data of a ring.', 'professional_function_catalog.md'), + ('abstractAlgebraConstructField', 'Abstract Algebra', '(*args)', 'Construct a field from explicit inputs for Abstract Algebra.', 'professional_function_catalog.md'), + ('abstractAlgebraConstructGroup', 'Abstract Algebra', '(*args)', 'Construct a group from explicit inputs for Abstract Algebra.', 'professional_function_catalog.md'), + ('abstractAlgebraConstructHomomorphism', 'Abstract Algebra', '(*args)', 'Construct a homomorphism from explicit inputs for Abstract Algebra.', 'professional_function_catalog.md'), + ('abstractAlgebraConstructModule', 'Abstract Algebra', '(*args)', 'Construct a module from explicit inputs for Abstract Algebra.', 'professional_function_catalog.md'), + ('abstractAlgebraConstructRing', 'Abstract Algebra', '(*args)', 'Construct a ring from explicit inputs for Abstract Algebra.', 'professional_function_catalog.md'), + ('abstractAlgebraDecomposeField', 'Abstract Algebra', '(value)', 'Decompose a field into simpler or canonical components.', 'professional_function_catalog.md'), + ('abstractAlgebraDecomposeGroup', 'Abstract Algebra', '(value)', 'Decompose a group into simpler or canonical components.', 'professional_function_catalog.md'), + ('abstractAlgebraDecomposeHomomorphism', 'Abstract Algebra', '(value)', 'Decompose a homomorphism into simpler or canonical components.', 'professional_function_catalog.md'), + ('abstractAlgebraDecomposeModule', 'Abstract Algebra', '(value)', 'Decompose a module into simpler or canonical components.', 'professional_function_catalog.md'), + ('abstractAlgebraDecomposeRing', 'Abstract Algebra', '(value)', 'Decompose a ring into simpler or canonical components.', 'professional_function_catalog.md'), + ('abstractAlgebraDocumentField', 'Abstract Algebra', '(value)', 'Return a structured explanation of a field and related assumptions.', 'professional_function_catalog.md'), + ('abstractAlgebraDocumentGroup', 'Abstract Algebra', '(value)', 'Return a structured explanation of a group and related assumptions.', 'professional_function_catalog.md'), + ('abstractAlgebraDocumentHomomorphism', 'Abstract Algebra', '(value)', 'Return a structured explanation of a homomorphism and related assumptions.', 'professional_function_catalog.md'), + ('abstractAlgebraDocumentModule', 'Abstract Algebra', '(value)', 'Return a structured explanation of a module and related assumptions.', 'professional_function_catalog.md'), + ('abstractAlgebraDocumentRing', 'Abstract Algebra', '(value)', 'Return a structured explanation of a ring and related assumptions.', 'professional_function_catalog.md'), + ('abstractAlgebraEnumerateField', 'Abstract Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a field.', 'professional_function_catalog.md'), + ('abstractAlgebraEnumerateGroup', 'Abstract Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a group.', 'professional_function_catalog.md'), + ('abstractAlgebraEnumerateHomomorphism', 'Abstract Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a homomorphism.', 'professional_function_catalog.md'), + ('abstractAlgebraEnumerateModule', 'Abstract Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a module.', 'professional_function_catalog.md'), + ('abstractAlgebraEnumerateRing', 'Abstract Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a ring.', 'professional_function_catalog.md'), + ('abstractAlgebraEstimateField', 'Abstract Algebra', '(value, samples=None)', 'Estimate a field property from finite samples or approximations.', 'professional_function_catalog.md'), + ('abstractAlgebraEstimateGroup', 'Abstract Algebra', '(value, samples=None)', 'Estimate a group property from finite samples or approximations.', 'professional_function_catalog.md'), + ('abstractAlgebraEstimateHomomorphism', 'Abstract Algebra', '(value, samples=None)', 'Estimate a homomorphism property from finite samples or approximations.', 'professional_function_catalog.md'), + ('abstractAlgebraEstimateModule', 'Abstract Algebra', '(value, samples=None)', 'Estimate a module property from finite samples or approximations.', 'professional_function_catalog.md'), + ('abstractAlgebraEstimateRing', 'Abstract Algebra', '(value, samples=None)', 'Estimate a ring property from finite samples or approximations.', 'professional_function_catalog.md'), + ('abstractAlgebraEvaluateField', 'Abstract Algebra', '(value, point=None)', 'Evaluate a field at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('abstractAlgebraEvaluateGroup', 'Abstract Algebra', '(value, point=None)', 'Evaluate a group at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('abstractAlgebraEvaluateHomomorphism', 'Abstract Algebra', '(value, point=None)', 'Evaluate a homomorphism at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('abstractAlgebraEvaluateModule', 'Abstract Algebra', '(value, point=None)', 'Evaluate a module at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('abstractAlgebraEvaluateRing', 'Abstract Algebra', '(value, point=None)', 'Evaluate a ring at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('abstractAlgebraFormatField', 'Abstract Algebra', '(value)', 'Format a field for deterministic user-facing output.', 'professional_function_catalog.md'), + ('abstractAlgebraFormatGroup', 'Abstract Algebra', '(value)', 'Format a group for deterministic user-facing output.', 'professional_function_catalog.md'), + ('abstractAlgebraFormatHomomorphism', 'Abstract Algebra', '(value)', 'Format a homomorphism for deterministic user-facing output.', 'professional_function_catalog.md'), + ('abstractAlgebraFormatModule', 'Abstract Algebra', '(value)', 'Format a module for deterministic user-facing output.', 'professional_function_catalog.md'), + ('abstractAlgebraFormatRing', 'Abstract Algebra', '(value)', 'Format a ring for deterministic user-facing output.', 'professional_function_catalog.md'), + ('abstractAlgebraGenerateExampleField', 'Abstract Algebra', '(size=3)', 'Generate a small documented example of a field.', 'professional_function_catalog.md'), + ('abstractAlgebraGenerateExampleGroup', 'Abstract Algebra', '(size=3)', 'Generate a small documented example of a group.', 'professional_function_catalog.md'), + ('abstractAlgebraGenerateExampleHomomorphism', 'Abstract Algebra', '(size=3)', 'Generate a small documented example of a homomorphism.', 'professional_function_catalog.md'), + ('abstractAlgebraGenerateExampleModule', 'Abstract Algebra', '(size=3)', 'Generate a small documented example of a module.', 'professional_function_catalog.md'), + ('abstractAlgebraGenerateExampleRing', 'Abstract Algebra', '(size=3)', 'Generate a small documented example of a ring.', 'professional_function_catalog.md'), + ('abstractAlgebraNormalizeField', 'Abstract Algebra', '(value)', 'Normalize a field into the standard Abstract Algebra representation.', 'professional_function_catalog.md'), + ('abstractAlgebraNormalizeGroup', 'Abstract Algebra', '(value)', 'Normalize a group into the standard Abstract Algebra representation.', 'professional_function_catalog.md'), + ('abstractAlgebraNormalizeHomomorphism', 'Abstract Algebra', '(value)', 'Normalize a homomorphism into the standard Abstract Algebra representation.', 'professional_function_catalog.md'), + ('abstractAlgebraNormalizeModule', 'Abstract Algebra', '(value)', 'Normalize a module into the standard Abstract Algebra representation.', 'professional_function_catalog.md'), + ('abstractAlgebraNormalizeRing', 'Abstract Algebra', '(value)', 'Normalize a ring into the standard Abstract Algebra representation.', 'professional_function_catalog.md'), + ('abstractAlgebraParseField', 'Abstract Algebra', '(text)', 'Parse a text or structured value into a field.', 'professional_function_catalog.md'), + ('abstractAlgebraParseGroup', 'Abstract Algebra', '(text)', 'Parse a text or structured value into a group.', 'professional_function_catalog.md'), + ('abstractAlgebraParseHomomorphism', 'Abstract Algebra', '(text)', 'Parse a text or structured value into a homomorphism.', 'professional_function_catalog.md'), + ('abstractAlgebraParseModule', 'Abstract Algebra', '(text)', 'Parse a text or structured value into a module.', 'professional_function_catalog.md'), + ('abstractAlgebraParseRing', 'Abstract Algebra', '(text)', 'Parse a text or structured value into a ring.', 'professional_function_catalog.md'), + ('abstractAlgebraSimplifyField', 'Abstract Algebra', '(value)', 'Simplify a field without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('abstractAlgebraSimplifyGroup', 'Abstract Algebra', '(value)', 'Simplify a group without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('abstractAlgebraSimplifyHomomorphism', 'Abstract Algebra', '(value)', 'Simplify a homomorphism without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('abstractAlgebraSimplifyModule', 'Abstract Algebra', '(value)', 'Simplify a module without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('abstractAlgebraSimplifyRing', 'Abstract Algebra', '(value)', 'Simplify a ring without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('abstractAlgebraTestEquivalenceField', 'Abstract Algebra', '(left, right)', 'Test whether two field values are equivalent in Abstract Algebra.', 'professional_function_catalog.md'), + ('abstractAlgebraTestEquivalenceGroup', 'Abstract Algebra', '(left, right)', 'Test whether two group values are equivalent in Abstract Algebra.', 'professional_function_catalog.md'), + ('abstractAlgebraTestEquivalenceHomomorphism', 'Abstract Algebra', '(left, right)', 'Test whether two homomorphism values are equivalent in Abstract Algebra.', 'professional_function_catalog.md'), + ('abstractAlgebraTestEquivalenceModule', 'Abstract Algebra', '(left, right)', 'Test whether two module values are equivalent in Abstract Algebra.', 'professional_function_catalog.md'), + ('abstractAlgebraTestEquivalenceRing', 'Abstract Algebra', '(left, right)', 'Test whether two ring values are equivalent in Abstract Algebra.', 'professional_function_catalog.md'), + ('abstractAlgebraTransformField', 'Abstract Algebra', '(value, mapping)', 'Transform a field through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('abstractAlgebraTransformGroup', 'Abstract Algebra', '(value, mapping)', 'Transform a group through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('abstractAlgebraTransformHomomorphism', 'Abstract Algebra', '(value, mapping)', 'Transform a homomorphism through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('abstractAlgebraTransformModule', 'Abstract Algebra', '(value, mapping)', 'Transform a module through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('abstractAlgebraTransformRing', 'Abstract Algebra', '(value, mapping)', 'Transform a ring through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('abstractAlgebraValidateField', 'Abstract Algebra', '(value)', 'Validate the field representation and domain rules for Abstract Algebra.', 'professional_function_catalog.md'), + ('abstractAlgebraValidateGroup', 'Abstract Algebra', '(value)', 'Validate the group representation and domain rules for Abstract Algebra.', 'professional_function_catalog.md'), + ('abstractAlgebraValidateHomomorphism', 'Abstract Algebra', '(value)', 'Validate the homomorphism representation and domain rules for Abstract Algebra.', 'professional_function_catalog.md'), + ('abstractAlgebraValidateModule', 'Abstract Algebra', '(value)', 'Validate the module representation and domain rules for Abstract Algebra.', 'professional_function_catalog.md'), + ('abstractAlgebraValidateRing', 'Abstract Algebra', '(value)', 'Validate the ring representation and domain rules for Abstract Algebra.', 'professional_function_catalog.md'), + ('cyclicGroup', 'Abstract Algebra', '(n)', 'Planned roadmap function for Abstract Algebra from upcoming.md.', 'upcoming.md'), + ('elementOrder', 'Abstract Algebra', '(element, elements, operation)', 'Planned roadmap function for Abstract Algebra from upcoming.md.', 'upcoming.md'), + ('identityElement', 'Abstract Algebra', '(elements, operation)', 'Planned roadmap function for Abstract Algebra from upcoming.md.', 'upcoming.md'), + ('inverseElement', 'Abstract Algebra', '(element, elements, operation)', 'Planned roadmap function for Abstract Algebra from upcoming.md.', 'upcoming.md'), + ('isAbelianGroup', 'Abstract Algebra', '(elements, operation)', 'Planned roadmap function for Abstract Algebra from upcoming.md.', 'upcoming.md'), + ('isField', 'Abstract Algebra', '(elements, additionOperation, multiplicationOperation)', 'Planned roadmap function for Abstract Algebra from upcoming.md.', 'upcoming.md'), + ('isGroup', 'Abstract Algebra', '(elements, operation)', 'Planned roadmap function for Abstract Algebra from upcoming.md.', 'upcoming.md'), + ('isRing', 'Abstract Algebra', '(elements, additionOperation, multiplicationOperation)', 'Planned roadmap function for Abstract Algebra from upcoming.md.', 'upcoming.md'), + ('isSubgroup', 'Abstract Algebra', '(subset, group, operation)', 'Planned roadmap function for Abstract Algebra from upcoming.md.', 'upcoming.md'), + ('permutationCompose', 'Abstract Algebra', '(p, q)', 'Planned roadmap function for Abstract Algebra from upcoming.md.', 'upcoming.md'), + ('permutationInverse', 'Abstract Algebra', '(p)', 'Planned roadmap function for Abstract Algebra from upcoming.md.', 'upcoming.md'), + ('algebraApproximateAlgebraicExpression', 'Algebra', '(value, tolerance=1e-9)', 'Approximate a algebraic expression with explicit tolerance controls.', 'professional_function_catalog.md'), + ('algebraApproximateEquation', 'Algebra', '(value, tolerance=1e-9)', 'Approximate a equation with explicit tolerance controls.', 'professional_function_catalog.md'), + ('algebraApproximateExponentialForm', 'Algebra', '(value, tolerance=1e-9)', 'Approximate a exponential form with explicit tolerance controls.', 'professional_function_catalog.md'), + ('algebraApproximateFactorialExpression', 'Algebra', '(value, tolerance=1e-9)', 'Approximate a factorial expression with explicit tolerance controls.', 'professional_function_catalog.md'), + ('algebraApproximateRootExpression', 'Algebra', '(value, tolerance=1e-9)', 'Approximate a root expression with explicit tolerance controls.', 'professional_function_catalog.md'), + ('algebraCanonicalizeAlgebraicExpression', 'Algebra', '(value)', 'Canonicalize a algebraic expression so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('algebraCanonicalizeEquation', 'Algebra', '(value)', 'Canonicalize a equation so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('algebraCanonicalizeExponentialForm', 'Algebra', '(value)', 'Canonicalize a exponential form so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('algebraCanonicalizeFactorialExpression', 'Algebra', '(value)', 'Canonicalize a factorial expression so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('algebraCanonicalizeRootExpression', 'Algebra', '(value)', 'Canonicalize a root expression so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('algebraClassifyAlgebraicExpression', 'Algebra', '(value)', 'Classify a algebraic expression by its standard Algebra invariants.', 'professional_function_catalog.md'), + ('algebraClassifyEquation', 'Algebra', '(value)', 'Classify a equation by its standard Algebra invariants.', 'professional_function_catalog.md'), + ('algebraClassifyExponentialForm', 'Algebra', '(value)', 'Classify a exponential form by its standard Algebra invariants.', 'professional_function_catalog.md'), + ('algebraClassifyFactorialExpression', 'Algebra', '(value)', 'Classify a factorial expression by its standard Algebra invariants.', 'professional_function_catalog.md'), + ('algebraClassifyRootExpression', 'Algebra', '(value)', 'Classify a root expression by its standard Algebra invariants.', 'professional_function_catalog.md'), + ('algebraCombineAlgebraicExpression', 'Algebra', '(left, right)', 'Combine two algebraic expression values with the natural operation for Algebra.', 'professional_function_catalog.md'), + ('algebraCombineEquation', 'Algebra', '(left, right)', 'Combine two equation values with the natural operation for Algebra.', 'professional_function_catalog.md'), + ('algebraCombineExponentialForm', 'Algebra', '(left, right)', 'Combine two exponential form values with the natural operation for Algebra.', 'professional_function_catalog.md'), + ('algebraCombineFactorialExpression', 'Algebra', '(left, right)', 'Combine two factorial expression values with the natural operation for Algebra.', 'professional_function_catalog.md'), + ('algebraCombineRootExpression', 'Algebra', '(left, right)', 'Combine two root expression values with the natural operation for Algebra.', 'professional_function_catalog.md'), + ('algebraCompareAlgebraicExpression', 'Algebra', '(left, right)', 'Compare two algebraic expression values under the conventions of Algebra.', 'professional_function_catalog.md'), + ('algebraCompareEquation', 'Algebra', '(left, right)', 'Compare two equation values under the conventions of Algebra.', 'professional_function_catalog.md'), + ('algebraCompareExponentialForm', 'Algebra', '(left, right)', 'Compare two exponential form values under the conventions of Algebra.', 'professional_function_catalog.md'), + ('algebraCompareFactorialExpression', 'Algebra', '(left, right)', 'Compare two factorial expression values under the conventions of Algebra.', 'professional_function_catalog.md'), + ('algebraCompareRootExpression', 'Algebra', '(left, right)', 'Compare two root expression values under the conventions of Algebra.', 'professional_function_catalog.md'), + ('algebraComputeAlgebraicExpression', 'Algebra', '(value)', 'Compute the central numerical or symbolic data of a algebraic expression.', 'professional_function_catalog.md'), + ('algebraComputeEquation', 'Algebra', '(value)', 'Compute the central numerical or symbolic data of a equation.', 'professional_function_catalog.md'), + ('algebraComputeExponentialForm', 'Algebra', '(value)', 'Compute the central numerical or symbolic data of a exponential form.', 'professional_function_catalog.md'), + ('algebraComputeFactorialExpression', 'Algebra', '(value)', 'Compute the central numerical or symbolic data of a factorial expression.', 'professional_function_catalog.md'), + ('algebraComputeRootExpression', 'Algebra', '(value)', 'Compute the central numerical or symbolic data of a root expression.', 'professional_function_catalog.md'), + ('algebraConstructAlgebraicExpression', 'Algebra', '(*args)', 'Construct a algebraic expression from explicit inputs for Algebra.', 'professional_function_catalog.md'), + ('algebraConstructEquation', 'Algebra', '(*args)', 'Construct a equation from explicit inputs for Algebra.', 'professional_function_catalog.md'), + ('algebraConstructExponentialForm', 'Algebra', '(*args)', 'Construct a exponential form from explicit inputs for Algebra.', 'professional_function_catalog.md'), + ('algebraConstructFactorialExpression', 'Algebra', '(*args)', 'Construct a factorial expression from explicit inputs for Algebra.', 'professional_function_catalog.md'), + ('algebraConstructRootExpression', 'Algebra', '(*args)', 'Construct a root expression from explicit inputs for Algebra.', 'professional_function_catalog.md'), + ('algebraDecomposeAlgebraicExpression', 'Algebra', '(value)', 'Decompose a algebraic expression into simpler or canonical components.', 'professional_function_catalog.md'), + ('algebraDecomposeEquation', 'Algebra', '(value)', 'Decompose a equation into simpler or canonical components.', 'professional_function_catalog.md'), + ('algebraDecomposeExponentialForm', 'Algebra', '(value)', 'Decompose a exponential form into simpler or canonical components.', 'professional_function_catalog.md'), + ('algebraDecomposeFactorialExpression', 'Algebra', '(value)', 'Decompose a factorial expression into simpler or canonical components.', 'professional_function_catalog.md'), + ('algebraDecomposeRootExpression', 'Algebra', '(value)', 'Decompose a root expression into simpler or canonical components.', 'professional_function_catalog.md'), + ('algebraDocumentAlgebraicExpression', 'Algebra', '(value)', 'Return a structured explanation of a algebraic expression and related assumptions.', 'professional_function_catalog.md'), + ('algebraDocumentEquation', 'Algebra', '(value)', 'Return a structured explanation of a equation and related assumptions.', 'professional_function_catalog.md'), + ('algebraDocumentExponentialForm', 'Algebra', '(value)', 'Return a structured explanation of a exponential form and related assumptions.', 'professional_function_catalog.md'), + ('algebraDocumentFactorialExpression', 'Algebra', '(value)', 'Return a structured explanation of a factorial expression and related assumptions.', 'professional_function_catalog.md'), + ('algebraDocumentRootExpression', 'Algebra', '(value)', 'Return a structured explanation of a root expression and related assumptions.', 'professional_function_catalog.md'), + ('algebraEnumerateAlgebraicExpression', 'Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a algebraic expression.', 'professional_function_catalog.md'), + ('algebraEnumerateEquation', 'Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a equation.', 'professional_function_catalog.md'), + ('algebraEnumerateExponentialForm', 'Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a exponential form.', 'professional_function_catalog.md'), + ('algebraEnumerateFactorialExpression', 'Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a factorial expression.', 'professional_function_catalog.md'), + ('algebraEnumerateRootExpression', 'Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a root expression.', 'professional_function_catalog.md'), + ('algebraEstimateAlgebraicExpression', 'Algebra', '(value, samples=None)', 'Estimate a algebraic expression property from finite samples or approximations.', 'professional_function_catalog.md'), + ('algebraEstimateEquation', 'Algebra', '(value, samples=None)', 'Estimate a equation property from finite samples or approximations.', 'professional_function_catalog.md'), + ('algebraEstimateExponentialForm', 'Algebra', '(value, samples=None)', 'Estimate a exponential form property from finite samples or approximations.', 'professional_function_catalog.md'), + ('algebraEstimateFactorialExpression', 'Algebra', '(value, samples=None)', 'Estimate a factorial expression property from finite samples or approximations.', 'professional_function_catalog.md'), + ('algebraEstimateRootExpression', 'Algebra', '(value, samples=None)', 'Estimate a root expression property from finite samples or approximations.', 'professional_function_catalog.md'), + ('algebraEvaluateAlgebraicExpression', 'Algebra', '(value, point=None)', 'Evaluate a algebraic expression at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('algebraEvaluateEquation', 'Algebra', '(value, point=None)', 'Evaluate a equation at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('algebraEvaluateExponentialForm', 'Algebra', '(value, point=None)', 'Evaluate a exponential form at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('algebraEvaluateFactorialExpression', 'Algebra', '(value, point=None)', 'Evaluate a factorial expression at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('algebraEvaluateRootExpression', 'Algebra', '(value, point=None)', 'Evaluate a root expression at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('algebraFormatAlgebraicExpression', 'Algebra', '(value)', 'Format a algebraic expression for deterministic user-facing output.', 'professional_function_catalog.md'), + ('algebraFormatEquation', 'Algebra', '(value)', 'Format a equation for deterministic user-facing output.', 'professional_function_catalog.md'), + ('algebraFormatExponentialForm', 'Algebra', '(value)', 'Format a exponential form for deterministic user-facing output.', 'professional_function_catalog.md'), + ('algebraFormatFactorialExpression', 'Algebra', '(value)', 'Format a factorial expression for deterministic user-facing output.', 'professional_function_catalog.md'), + ('algebraFormatRootExpression', 'Algebra', '(value)', 'Format a root expression for deterministic user-facing output.', 'professional_function_catalog.md'), + ('algebraGenerateExampleAlgebraicExpression', 'Algebra', '(size=3)', 'Generate a small documented example of a algebraic expression.', 'professional_function_catalog.md'), + ('algebraGenerateExampleEquation', 'Algebra', '(size=3)', 'Generate a small documented example of a equation.', 'professional_function_catalog.md'), + ('algebraGenerateExampleExponentialForm', 'Algebra', '(size=3)', 'Generate a small documented example of a exponential form.', 'professional_function_catalog.md'), + ('algebraGenerateExampleFactorialExpression', 'Algebra', '(size=3)', 'Generate a small documented example of a factorial expression.', 'professional_function_catalog.md'), + ('algebraGenerateExampleRootExpression', 'Algebra', '(size=3)', 'Generate a small documented example of a root expression.', 'professional_function_catalog.md'), + ('algebraNormalizeAlgebraicExpression', 'Algebra', '(value)', 'Normalize a algebraic expression into the standard Algebra representation.', 'professional_function_catalog.md'), + ('algebraNormalizeEquation', 'Algebra', '(value)', 'Normalize a equation into the standard Algebra representation.', 'professional_function_catalog.md'), + ('algebraNormalizeExponentialForm', 'Algebra', '(value)', 'Normalize a exponential form into the standard Algebra representation.', 'professional_function_catalog.md'), + ('algebraNormalizeFactorialExpression', 'Algebra', '(value)', 'Normalize a factorial expression into the standard Algebra representation.', 'professional_function_catalog.md'), + ('algebraNormalizeRootExpression', 'Algebra', '(value)', 'Normalize a root expression into the standard Algebra representation.', 'professional_function_catalog.md'), + ('algebraParseAlgebraicExpression', 'Algebra', '(text)', 'Parse a text or structured value into a algebraic expression.', 'professional_function_catalog.md'), + ('algebraParseEquation', 'Algebra', '(text)', 'Parse a text or structured value into a equation.', 'professional_function_catalog.md'), + ('algebraParseExponentialForm', 'Algebra', '(text)', 'Parse a text or structured value into a exponential form.', 'professional_function_catalog.md'), + ('algebraParseFactorialExpression', 'Algebra', '(text)', 'Parse a text or structured value into a factorial expression.', 'professional_function_catalog.md'), + ('algebraParseRootExpression', 'Algebra', '(text)', 'Parse a text or structured value into a root expression.', 'professional_function_catalog.md'), + ('algebraSimplifyAlgebraicExpression', 'Algebra', '(value)', 'Simplify a algebraic expression without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('algebraSimplifyEquation', 'Algebra', '(value)', 'Simplify a equation without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('algebraSimplifyExponentialForm', 'Algebra', '(value)', 'Simplify a exponential form without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('algebraSimplifyFactorialExpression', 'Algebra', '(value)', 'Simplify a factorial expression without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('algebraSimplifyRootExpression', 'Algebra', '(value)', 'Simplify a root expression without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('algebraTestEquivalenceAlgebraicExpression', 'Algebra', '(left, right)', 'Test whether two algebraic expression values are equivalent in Algebra.', 'professional_function_catalog.md'), + ('algebraTestEquivalenceEquation', 'Algebra', '(left, right)', 'Test whether two equation values are equivalent in Algebra.', 'professional_function_catalog.md'), + ('algebraTestEquivalenceExponentialForm', 'Algebra', '(left, right)', 'Test whether two exponential form values are equivalent in Algebra.', 'professional_function_catalog.md'), + ('algebraTestEquivalenceFactorialExpression', 'Algebra', '(left, right)', 'Test whether two factorial expression values are equivalent in Algebra.', 'professional_function_catalog.md'), + ('algebraTestEquivalenceRootExpression', 'Algebra', '(left, right)', 'Test whether two root expression values are equivalent in Algebra.', 'professional_function_catalog.md'), + ('algebraTransformAlgebraicExpression', 'Algebra', '(value, mapping)', 'Transform a algebraic expression through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('algebraTransformEquation', 'Algebra', '(value, mapping)', 'Transform a equation through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('algebraTransformExponentialForm', 'Algebra', '(value, mapping)', 'Transform a exponential form through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('algebraTransformFactorialExpression', 'Algebra', '(value, mapping)', 'Transform a factorial expression through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('algebraTransformRootExpression', 'Algebra', '(value, mapping)', 'Transform a root expression through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('algebraValidateAlgebraicExpression', 'Algebra', '(value)', 'Validate the algebraic expression representation and domain rules for Algebra.', 'professional_function_catalog.md'), + ('algebraValidateEquation', 'Algebra', '(value)', 'Validate the equation representation and domain rules for Algebra.', 'professional_function_catalog.md'), + ('algebraValidateExponentialForm', 'Algebra', '(value)', 'Validate the exponential form representation and domain rules for Algebra.', 'professional_function_catalog.md'), + ('algebraValidateFactorialExpression', 'Algebra', '(value)', 'Validate the factorial expression representation and domain rules for Algebra.', 'professional_function_catalog.md'), + ('algebraValidateRootExpression', 'Algebra', '(value)', 'Validate the root expression representation and domain rules for Algebra.', 'professional_function_catalog.md'), + ('exp', 'Algebra', '(x)', 'Planned roadmap function for Algebra from upcoming.md.', 'upcoming.md'), + ('fallingFactorial', 'Algebra', '(x, n)', 'Planned roadmap function for Algebra from upcoming.md.', 'upcoming.md'), + ('isPerfectSquare', 'Algebra', '(n)', 'Planned roadmap function for Algebra from upcoming.md.', 'upcoming.md'), + ('linearEquation', 'Algebra', '(a, b)', 'Planned roadmap function for Algebra from upcoming.md.', 'upcoming.md'), + ('ln', 'Algebra', '(x)', 'Planned roadmap function for Algebra from upcoming.md.', 'upcoming.md'), + ('log', 'Algebra', '(x, base=e)', 'Planned roadmap function for Algebra from upcoming.md.', 'upcoming.md'), + ('quadraticFormula', 'Algebra', '(a, b, c)', 'Planned roadmap function for Algebra from upcoming.md.', 'upcoming.md'), + ('risingFactorial', 'Algebra', '(x, n)', 'Planned roadmap function for Algebra from upcoming.md.', 'upcoming.md'), + ('simplifyRadical', 'Algebra', '(n)', 'Planned roadmap function for Algebra from upcoming.md.', 'upcoming.md'), + ('affineVarietyDimensionEstimate', 'Algebraic Geometry', '(points)', 'Planned roadmap function for Algebraic Geometry from upcoming.md.', 'upcoming.md'), + ('algebraicGeometryApproximateAffineVariety', 'Algebraic Geometry', '(value, tolerance=1e-9)', 'Approximate a affine variety with explicit tolerance controls.', 'professional_function_catalog.md'), + ('algebraicGeometryApproximateCoordinateRing', 'Algebraic Geometry', '(value, tolerance=1e-9)', 'Approximate a coordinate ring with explicit tolerance controls.', 'professional_function_catalog.md'), + ('algebraicGeometryApproximateIdeal', 'Algebraic Geometry', '(value, tolerance=1e-9)', 'Approximate a ideal with explicit tolerance controls.', 'professional_function_catalog.md'), + ('algebraicGeometryApproximateMonomialOrder', 'Algebraic Geometry', '(value, tolerance=1e-9)', 'Approximate a monomial order with explicit tolerance controls.', 'professional_function_catalog.md'), + ('algebraicGeometryApproximatePolynomialSystem', 'Algebraic Geometry', '(value, tolerance=1e-9)', 'Approximate a polynomial system with explicit tolerance controls.', 'professional_function_catalog.md'), + ('algebraicGeometryCanonicalizeAffineVariety', 'Algebraic Geometry', '(value)', 'Canonicalize a affine variety so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('algebraicGeometryCanonicalizeCoordinateRing', 'Algebraic Geometry', '(value)', 'Canonicalize a coordinate ring so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('algebraicGeometryCanonicalizeIdeal', 'Algebraic Geometry', '(value)', 'Canonicalize a ideal so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('algebraicGeometryCanonicalizeMonomialOrder', 'Algebraic Geometry', '(value)', 'Canonicalize a monomial order so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('algebraicGeometryCanonicalizePolynomialSystem', 'Algebraic Geometry', '(value)', 'Canonicalize a polynomial system so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('algebraicGeometryClassifyAffineVariety', 'Algebraic Geometry', '(value)', 'Classify a affine variety by its standard Algebraic Geometry invariants.', 'professional_function_catalog.md'), + ('algebraicGeometryClassifyCoordinateRing', 'Algebraic Geometry', '(value)', 'Classify a coordinate ring by its standard Algebraic Geometry invariants.', 'professional_function_catalog.md'), + ('algebraicGeometryClassifyIdeal', 'Algebraic Geometry', '(value)', 'Classify a ideal by its standard Algebraic Geometry invariants.', 'professional_function_catalog.md'), + ('algebraicGeometryClassifyMonomialOrder', 'Algebraic Geometry', '(value)', 'Classify a monomial order by its standard Algebraic Geometry invariants.', 'professional_function_catalog.md'), + ('algebraicGeometryClassifyPolynomialSystem', 'Algebraic Geometry', '(value)', 'Classify a polynomial system by its standard Algebraic Geometry invariants.', 'professional_function_catalog.md'), + ('algebraicGeometryCombineAffineVariety', 'Algebraic Geometry', '(left, right)', 'Combine two affine variety values with the natural operation for Algebraic Geometry.', 'professional_function_catalog.md'), + ('algebraicGeometryCombineCoordinateRing', 'Algebraic Geometry', '(left, right)', 'Combine two coordinate ring values with the natural operation for Algebraic Geometry.', 'professional_function_catalog.md'), + ('algebraicGeometryCombineIdeal', 'Algebraic Geometry', '(left, right)', 'Combine two ideal values with the natural operation for Algebraic Geometry.', 'professional_function_catalog.md'), + ('algebraicGeometryCombineMonomialOrder', 'Algebraic Geometry', '(left, right)', 'Combine two monomial order values with the natural operation for Algebraic Geometry.', 'professional_function_catalog.md'), + ('algebraicGeometryCombinePolynomialSystem', 'Algebraic Geometry', '(left, right)', 'Combine two polynomial system values with the natural operation for Algebraic Geometry.', 'professional_function_catalog.md'), + ('algebraicGeometryCompareAffineVariety', 'Algebraic Geometry', '(left, right)', 'Compare two affine variety values under the conventions of Algebraic Geometry.', 'professional_function_catalog.md'), + ('algebraicGeometryCompareCoordinateRing', 'Algebraic Geometry', '(left, right)', 'Compare two coordinate ring values under the conventions of Algebraic Geometry.', 'professional_function_catalog.md'), + ('algebraicGeometryCompareIdeal', 'Algebraic Geometry', '(left, right)', 'Compare two ideal values under the conventions of Algebraic Geometry.', 'professional_function_catalog.md'), + ('algebraicGeometryCompareMonomialOrder', 'Algebraic Geometry', '(left, right)', 'Compare two monomial order values under the conventions of Algebraic Geometry.', 'professional_function_catalog.md'), + ('algebraicGeometryComparePolynomialSystem', 'Algebraic Geometry', '(left, right)', 'Compare two polynomial system values under the conventions of Algebraic Geometry.', 'professional_function_catalog.md'), + ('algebraicGeometryComputeAffineVariety', 'Algebraic Geometry', '(value)', 'Compute the central numerical or symbolic data of a affine variety.', 'professional_function_catalog.md'), + ('algebraicGeometryComputeCoordinateRing', 'Algebraic Geometry', '(value)', 'Compute the central numerical or symbolic data of a coordinate ring.', 'professional_function_catalog.md'), + ('algebraicGeometryComputeIdeal', 'Algebraic Geometry', '(value)', 'Compute the central numerical or symbolic data of a ideal.', 'professional_function_catalog.md'), + ('algebraicGeometryComputeMonomialOrder', 'Algebraic Geometry', '(value)', 'Compute the central numerical or symbolic data of a monomial order.', 'professional_function_catalog.md'), + ('algebraicGeometryComputePolynomialSystem', 'Algebraic Geometry', '(value)', 'Compute the central numerical or symbolic data of a polynomial system.', 'professional_function_catalog.md'), + ('algebraicGeometryConstructAffineVariety', 'Algebraic Geometry', '(*args)', 'Construct a affine variety from explicit inputs for Algebraic Geometry.', 'professional_function_catalog.md'), + ('algebraicGeometryConstructCoordinateRing', 'Algebraic Geometry', '(*args)', 'Construct a coordinate ring from explicit inputs for Algebraic Geometry.', 'professional_function_catalog.md'), + ('algebraicGeometryConstructIdeal', 'Algebraic Geometry', '(*args)', 'Construct a ideal from explicit inputs for Algebraic Geometry.', 'professional_function_catalog.md'), + ('algebraicGeometryConstructMonomialOrder', 'Algebraic Geometry', '(*args)', 'Construct a monomial order from explicit inputs for Algebraic Geometry.', 'professional_function_catalog.md'), + ('algebraicGeometryConstructPolynomialSystem', 'Algebraic Geometry', '(*args)', 'Construct a polynomial system from explicit inputs for Algebraic Geometry.', 'professional_function_catalog.md'), + ('algebraicGeometryDecomposeAffineVariety', 'Algebraic Geometry', '(value)', 'Decompose a affine variety into simpler or canonical components.', 'professional_function_catalog.md'), + ('algebraicGeometryDecomposeCoordinateRing', 'Algebraic Geometry', '(value)', 'Decompose a coordinate ring into simpler or canonical components.', 'professional_function_catalog.md'), + ('algebraicGeometryDecomposeIdeal', 'Algebraic Geometry', '(value)', 'Decompose a ideal into simpler or canonical components.', 'professional_function_catalog.md'), + ('algebraicGeometryDecomposeMonomialOrder', 'Algebraic Geometry', '(value)', 'Decompose a monomial order into simpler or canonical components.', 'professional_function_catalog.md'), + ('algebraicGeometryDecomposePolynomialSystem', 'Algebraic Geometry', '(value)', 'Decompose a polynomial system into simpler or canonical components.', 'professional_function_catalog.md'), + ('algebraicGeometryDocumentAffineVariety', 'Algebraic Geometry', '(value)', 'Return a structured explanation of a affine variety and related assumptions.', 'professional_function_catalog.md'), + ('algebraicGeometryDocumentCoordinateRing', 'Algebraic Geometry', '(value)', 'Return a structured explanation of a coordinate ring and related assumptions.', 'professional_function_catalog.md'), + ('algebraicGeometryDocumentIdeal', 'Algebraic Geometry', '(value)', 'Return a structured explanation of a ideal and related assumptions.', 'professional_function_catalog.md'), + ('algebraicGeometryDocumentMonomialOrder', 'Algebraic Geometry', '(value)', 'Return a structured explanation of a monomial order and related assumptions.', 'professional_function_catalog.md'), + ('algebraicGeometryDocumentPolynomialSystem', 'Algebraic Geometry', '(value)', 'Return a structured explanation of a polynomial system and related assumptions.', 'professional_function_catalog.md'), + ('algebraicGeometryEnumerateAffineVariety', 'Algebraic Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a affine variety.', 'professional_function_catalog.md'), + ('algebraicGeometryEnumerateCoordinateRing', 'Algebraic Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a coordinate ring.', 'professional_function_catalog.md'), + ('algebraicGeometryEnumerateIdeal', 'Algebraic Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a ideal.', 'professional_function_catalog.md'), + ('algebraicGeometryEnumerateMonomialOrder', 'Algebraic Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a monomial order.', 'professional_function_catalog.md'), + ('algebraicGeometryEnumeratePolynomialSystem', 'Algebraic Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a polynomial system.', 'professional_function_catalog.md'), + ('algebraicGeometryEstimateAffineVariety', 'Algebraic Geometry', '(value, samples=None)', 'Estimate a affine variety property from finite samples or approximations.', 'professional_function_catalog.md'), + ('algebraicGeometryEstimateCoordinateRing', 'Algebraic Geometry', '(value, samples=None)', 'Estimate a coordinate ring property from finite samples or approximations.', 'professional_function_catalog.md'), + ('algebraicGeometryEstimateIdeal', 'Algebraic Geometry', '(value, samples=None)', 'Estimate a ideal property from finite samples or approximations.', 'professional_function_catalog.md'), + ('algebraicGeometryEstimateMonomialOrder', 'Algebraic Geometry', '(value, samples=None)', 'Estimate a monomial order property from finite samples or approximations.', 'professional_function_catalog.md'), + ('algebraicGeometryEstimatePolynomialSystem', 'Algebraic Geometry', '(value, samples=None)', 'Estimate a polynomial system property from finite samples or approximations.', 'professional_function_catalog.md'), + ('algebraicGeometryEvaluateAffineVariety', 'Algebraic Geometry', '(value, point=None)', 'Evaluate a affine variety at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('algebraicGeometryEvaluateCoordinateRing', 'Algebraic Geometry', '(value, point=None)', 'Evaluate a coordinate ring at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('algebraicGeometryEvaluateIdeal', 'Algebraic Geometry', '(value, point=None)', 'Evaluate a ideal at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('algebraicGeometryEvaluateMonomialOrder', 'Algebraic Geometry', '(value, point=None)', 'Evaluate a monomial order at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('algebraicGeometryEvaluatePolynomialSystem', 'Algebraic Geometry', '(value, point=None)', 'Evaluate a polynomial system at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('algebraicGeometryFormatAffineVariety', 'Algebraic Geometry', '(value)', 'Format a affine variety for deterministic user-facing output.', 'professional_function_catalog.md'), + ('algebraicGeometryFormatCoordinateRing', 'Algebraic Geometry', '(value)', 'Format a coordinate ring for deterministic user-facing output.', 'professional_function_catalog.md'), + ('algebraicGeometryFormatIdeal', 'Algebraic Geometry', '(value)', 'Format a ideal for deterministic user-facing output.', 'professional_function_catalog.md'), + ('algebraicGeometryFormatMonomialOrder', 'Algebraic Geometry', '(value)', 'Format a monomial order for deterministic user-facing output.', 'professional_function_catalog.md'), + ('algebraicGeometryFormatPolynomialSystem', 'Algebraic Geometry', '(value)', 'Format a polynomial system for deterministic user-facing output.', 'professional_function_catalog.md'), + ('algebraicGeometryGenerateExampleAffineVariety', 'Algebraic Geometry', '(size=3)', 'Generate a small documented example of a affine variety.', 'professional_function_catalog.md'), + ('algebraicGeometryGenerateExampleCoordinateRing', 'Algebraic Geometry', '(size=3)', 'Generate a small documented example of a coordinate ring.', 'professional_function_catalog.md'), + ('algebraicGeometryGenerateExampleIdeal', 'Algebraic Geometry', '(size=3)', 'Generate a small documented example of a ideal.', 'professional_function_catalog.md'), + ('algebraicGeometryGenerateExampleMonomialOrder', 'Algebraic Geometry', '(size=3)', 'Generate a small documented example of a monomial order.', 'professional_function_catalog.md'), + ('algebraicGeometryGenerateExamplePolynomialSystem', 'Algebraic Geometry', '(size=3)', 'Generate a small documented example of a polynomial system.', 'professional_function_catalog.md'), + ('algebraicGeometryNormalizeAffineVariety', 'Algebraic Geometry', '(value)', 'Normalize a affine variety into the standard Algebraic Geometry representation.', 'professional_function_catalog.md'), + ('algebraicGeometryNormalizeCoordinateRing', 'Algebraic Geometry', '(value)', 'Normalize a coordinate ring into the standard Algebraic Geometry representation.', 'professional_function_catalog.md'), + ('algebraicGeometryNormalizeIdeal', 'Algebraic Geometry', '(value)', 'Normalize a ideal into the standard Algebraic Geometry representation.', 'professional_function_catalog.md'), + ('algebraicGeometryNormalizeMonomialOrder', 'Algebraic Geometry', '(value)', 'Normalize a monomial order into the standard Algebraic Geometry representation.', 'professional_function_catalog.md'), + ('algebraicGeometryNormalizePolynomialSystem', 'Algebraic Geometry', '(value)', 'Normalize a polynomial system into the standard Algebraic Geometry representation.', 'professional_function_catalog.md'), + ('algebraicGeometryParseAffineVariety', 'Algebraic Geometry', '(text)', 'Parse a text or structured value into a affine variety.', 'professional_function_catalog.md'), + ('algebraicGeometryParseCoordinateRing', 'Algebraic Geometry', '(text)', 'Parse a text or structured value into a coordinate ring.', 'professional_function_catalog.md'), + ('algebraicGeometryParseIdeal', 'Algebraic Geometry', '(text)', 'Parse a text or structured value into a ideal.', 'professional_function_catalog.md'), + ('algebraicGeometryParseMonomialOrder', 'Algebraic Geometry', '(text)', 'Parse a text or structured value into a monomial order.', 'professional_function_catalog.md'), + ('algebraicGeometryParsePolynomialSystem', 'Algebraic Geometry', '(text)', 'Parse a text or structured value into a polynomial system.', 'professional_function_catalog.md'), + ('algebraicGeometrySimplifyAffineVariety', 'Algebraic Geometry', '(value)', 'Simplify a affine variety without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('algebraicGeometrySimplifyCoordinateRing', 'Algebraic Geometry', '(value)', 'Simplify a coordinate ring without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('algebraicGeometrySimplifyIdeal', 'Algebraic Geometry', '(value)', 'Simplify a ideal without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('algebraicGeometrySimplifyMonomialOrder', 'Algebraic Geometry', '(value)', 'Simplify a monomial order without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('algebraicGeometrySimplifyPolynomialSystem', 'Algebraic Geometry', '(value)', 'Simplify a polynomial system without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('algebraicGeometryTestEquivalenceAffineVariety', 'Algebraic Geometry', '(left, right)', 'Test whether two affine variety values are equivalent in Algebraic Geometry.', 'professional_function_catalog.md'), + ('algebraicGeometryTestEquivalenceCoordinateRing', 'Algebraic Geometry', '(left, right)', 'Test whether two coordinate ring values are equivalent in Algebraic Geometry.', 'professional_function_catalog.md'), + ('algebraicGeometryTestEquivalenceIdeal', 'Algebraic Geometry', '(left, right)', 'Test whether two ideal values are equivalent in Algebraic Geometry.', 'professional_function_catalog.md'), + ('algebraicGeometryTestEquivalenceMonomialOrder', 'Algebraic Geometry', '(left, right)', 'Test whether two monomial order values are equivalent in Algebraic Geometry.', 'professional_function_catalog.md'), + ('algebraicGeometryTestEquivalencePolynomialSystem', 'Algebraic Geometry', '(left, right)', 'Test whether two polynomial system values are equivalent in Algebraic Geometry.', 'professional_function_catalog.md'), + ('algebraicGeometryTransformAffineVariety', 'Algebraic Geometry', '(value, mapping)', 'Transform a affine variety through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('algebraicGeometryTransformCoordinateRing', 'Algebraic Geometry', '(value, mapping)', 'Transform a coordinate ring through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('algebraicGeometryTransformIdeal', 'Algebraic Geometry', '(value, mapping)', 'Transform a ideal through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('algebraicGeometryTransformMonomialOrder', 'Algebraic Geometry', '(value, mapping)', 'Transform a monomial order through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('algebraicGeometryTransformPolynomialSystem', 'Algebraic Geometry', '(value, mapping)', 'Transform a polynomial system through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('algebraicGeometryValidateAffineVariety', 'Algebraic Geometry', '(value)', 'Validate the affine variety representation and domain rules for Algebraic Geometry.', 'professional_function_catalog.md'), + ('algebraicGeometryValidateCoordinateRing', 'Algebraic Geometry', '(value)', 'Validate the coordinate ring representation and domain rules for Algebraic Geometry.', 'professional_function_catalog.md'), + ('algebraicGeometryValidateIdeal', 'Algebraic Geometry', '(value)', 'Validate the ideal representation and domain rules for Algebraic Geometry.', 'professional_function_catalog.md'), + ('algebraicGeometryValidateMonomialOrder', 'Algebraic Geometry', '(value)', 'Validate the monomial order representation and domain rules for Algebraic Geometry.', 'professional_function_catalog.md'), + ('algebraicGeometryValidatePolynomialSystem', 'Algebraic Geometry', '(value)', 'Validate the polynomial system representation and domain rules for Algebraic Geometry.', 'professional_function_catalog.md'), + ('buchbergerStep', 'Algebraic Geometry', '(generators)', 'Planned roadmap function for Algebraic Geometry from upcoming.md.', 'upcoming.md'), + ('evaluatePolynomialMultivariate', 'Algebraic Geometry', '(terms, point)', 'Planned roadmap function for Algebraic Geometry from upcoming.md.', 'upcoming.md'), + ('isPolynomialInIdeal', 'Algebraic Geometry', '(polynomial, generators, candidates)', 'Planned roadmap function for Algebraic Geometry from upcoming.md.', 'upcoming.md'), + ('leadingTerm', 'Algebraic Geometry', '(polynomial, order="lex")', 'Planned roadmap function for Algebraic Geometry from upcoming.md.', 'upcoming.md'), + ('monomialOrder', 'Algebraic Geometry', '(monomials, order="lex")', 'Planned roadmap function for Algebraic Geometry from upcoming.md.', 'upcoming.md'), + ('sPolynomial', 'Algebraic Geometry', '(f, g)', 'Planned roadmap function for Algebraic Geometry from upcoming.md.', 'upcoming.md'), + ('zeroSet', 'Algebraic Geometry', '(polynomials, candidatePoints)', 'Planned roadmap function for Algebraic Geometry from upcoming.md.', 'upcoming.md'), + ('algebraicNumberTheoryApproximateAlgebraicInteger', 'Algebraic Number Theory', '(value, tolerance=1e-9)', 'Approximate a algebraic integer with explicit tolerance controls.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryApproximateIdealClass', 'Algebraic Number Theory', '(value, tolerance=1e-9)', 'Approximate a ideal class with explicit tolerance controls.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryApproximateNormMap', 'Algebraic Number Theory', '(value, tolerance=1e-9)', 'Approximate a norm map with explicit tolerance controls.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryApproximateNumberFieldElement', 'Algebraic Number Theory', '(value, tolerance=1e-9)', 'Approximate a number field element with explicit tolerance controls.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryApproximateTraceMap', 'Algebraic Number Theory', '(value, tolerance=1e-9)', 'Approximate a trace map with explicit tolerance controls.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryCanonicalizeAlgebraicInteger', 'Algebraic Number Theory', '(value)', 'Canonicalize a algebraic integer so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryCanonicalizeIdealClass', 'Algebraic Number Theory', '(value)', 'Canonicalize a ideal class so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryCanonicalizeNormMap', 'Algebraic Number Theory', '(value)', 'Canonicalize a norm map so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryCanonicalizeNumberFieldElement', 'Algebraic Number Theory', '(value)', 'Canonicalize a number field element so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryCanonicalizeTraceMap', 'Algebraic Number Theory', '(value)', 'Canonicalize a trace map so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryClassifyAlgebraicInteger', 'Algebraic Number Theory', '(value)', 'Classify a algebraic integer by its standard Algebraic Number Theory invariants.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryClassifyIdealClass', 'Algebraic Number Theory', '(value)', 'Classify a ideal class by its standard Algebraic Number Theory invariants.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryClassifyNormMap', 'Algebraic Number Theory', '(value)', 'Classify a norm map by its standard Algebraic Number Theory invariants.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryClassifyNumberFieldElement', 'Algebraic Number Theory', '(value)', 'Classify a number field element by its standard Algebraic Number Theory invariants.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryClassifyTraceMap', 'Algebraic Number Theory', '(value)', 'Classify a trace map by its standard Algebraic Number Theory invariants.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryCombineAlgebraicInteger', 'Algebraic Number Theory', '(left, right)', 'Combine two algebraic integer values with the natural operation for Algebraic Number Theory.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryCombineIdealClass', 'Algebraic Number Theory', '(left, right)', 'Combine two ideal class values with the natural operation for Algebraic Number Theory.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryCombineNormMap', 'Algebraic Number Theory', '(left, right)', 'Combine two norm map values with the natural operation for Algebraic Number Theory.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryCombineNumberFieldElement', 'Algebraic Number Theory', '(left, right)', 'Combine two number field element values with the natural operation for Algebraic Number Theory.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryCombineTraceMap', 'Algebraic Number Theory', '(left, right)', 'Combine two trace map values with the natural operation for Algebraic Number Theory.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryCompareAlgebraicInteger', 'Algebraic Number Theory', '(left, right)', 'Compare two algebraic integer values under the conventions of Algebraic Number Theory.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryCompareIdealClass', 'Algebraic Number Theory', '(left, right)', 'Compare two ideal class values under the conventions of Algebraic Number Theory.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryCompareNormMap', 'Algebraic Number Theory', '(left, right)', 'Compare two norm map values under the conventions of Algebraic Number Theory.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryCompareNumberFieldElement', 'Algebraic Number Theory', '(left, right)', 'Compare two number field element values under the conventions of Algebraic Number Theory.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryCompareTraceMap', 'Algebraic Number Theory', '(left, right)', 'Compare two trace map values under the conventions of Algebraic Number Theory.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryComputeAlgebraicInteger', 'Algebraic Number Theory', '(value)', 'Compute the central numerical or symbolic data of a algebraic integer.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryComputeIdealClass', 'Algebraic Number Theory', '(value)', 'Compute the central numerical or symbolic data of a ideal class.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryComputeNormMap', 'Algebraic Number Theory', '(value)', 'Compute the central numerical or symbolic data of a norm map.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryComputeNumberFieldElement', 'Algebraic Number Theory', '(value)', 'Compute the central numerical or symbolic data of a number field element.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryComputeTraceMap', 'Algebraic Number Theory', '(value)', 'Compute the central numerical or symbolic data of a trace map.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryConstructAlgebraicInteger', 'Algebraic Number Theory', '(*args)', 'Construct a algebraic integer from explicit inputs for Algebraic Number Theory.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryConstructIdealClass', 'Algebraic Number Theory', '(*args)', 'Construct a ideal class from explicit inputs for Algebraic Number Theory.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryConstructNormMap', 'Algebraic Number Theory', '(*args)', 'Construct a norm map from explicit inputs for Algebraic Number Theory.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryConstructNumberFieldElement', 'Algebraic Number Theory', '(*args)', 'Construct a number field element from explicit inputs for Algebraic Number Theory.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryConstructTraceMap', 'Algebraic Number Theory', '(*args)', 'Construct a trace map from explicit inputs for Algebraic Number Theory.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryDecomposeAlgebraicInteger', 'Algebraic Number Theory', '(value)', 'Decompose a algebraic integer into simpler or canonical components.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryDecomposeIdealClass', 'Algebraic Number Theory', '(value)', 'Decompose a ideal class into simpler or canonical components.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryDecomposeNormMap', 'Algebraic Number Theory', '(value)', 'Decompose a norm map into simpler or canonical components.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryDecomposeNumberFieldElement', 'Algebraic Number Theory', '(value)', 'Decompose a number field element into simpler or canonical components.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryDecomposeTraceMap', 'Algebraic Number Theory', '(value)', 'Decompose a trace map into simpler or canonical components.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryDocumentAlgebraicInteger', 'Algebraic Number Theory', '(value)', 'Return a structured explanation of a algebraic integer and related assumptions.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryDocumentIdealClass', 'Algebraic Number Theory', '(value)', 'Return a structured explanation of a ideal class and related assumptions.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryDocumentNormMap', 'Algebraic Number Theory', '(value)', 'Return a structured explanation of a norm map and related assumptions.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryDocumentNumberFieldElement', 'Algebraic Number Theory', '(value)', 'Return a structured explanation of a number field element and related assumptions.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryDocumentTraceMap', 'Algebraic Number Theory', '(value)', 'Return a structured explanation of a trace map and related assumptions.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryEnumerateAlgebraicInteger', 'Algebraic Number Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a algebraic integer.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryEnumerateIdealClass', 'Algebraic Number Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a ideal class.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryEnumerateNormMap', 'Algebraic Number Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a norm map.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryEnumerateNumberFieldElement', 'Algebraic Number Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a number field element.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryEnumerateTraceMap', 'Algebraic Number Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a trace map.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryEstimateAlgebraicInteger', 'Algebraic Number Theory', '(value, samples=None)', 'Estimate a algebraic integer property from finite samples or approximations.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryEstimateIdealClass', 'Algebraic Number Theory', '(value, samples=None)', 'Estimate a ideal class property from finite samples or approximations.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryEstimateNormMap', 'Algebraic Number Theory', '(value, samples=None)', 'Estimate a norm map property from finite samples or approximations.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryEstimateNumberFieldElement', 'Algebraic Number Theory', '(value, samples=None)', 'Estimate a number field element property from finite samples or approximations.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryEstimateTraceMap', 'Algebraic Number Theory', '(value, samples=None)', 'Estimate a trace map property from finite samples or approximations.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryEvaluateAlgebraicInteger', 'Algebraic Number Theory', '(value, point=None)', 'Evaluate a algebraic integer at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryEvaluateIdealClass', 'Algebraic Number Theory', '(value, point=None)', 'Evaluate a ideal class at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryEvaluateNormMap', 'Algebraic Number Theory', '(value, point=None)', 'Evaluate a norm map at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryEvaluateNumberFieldElement', 'Algebraic Number Theory', '(value, point=None)', 'Evaluate a number field element at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryEvaluateTraceMap', 'Algebraic Number Theory', '(value, point=None)', 'Evaluate a trace map at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryFormatAlgebraicInteger', 'Algebraic Number Theory', '(value)', 'Format a algebraic integer for deterministic user-facing output.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryFormatIdealClass', 'Algebraic Number Theory', '(value)', 'Format a ideal class for deterministic user-facing output.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryFormatNormMap', 'Algebraic Number Theory', '(value)', 'Format a norm map for deterministic user-facing output.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryFormatNumberFieldElement', 'Algebraic Number Theory', '(value)', 'Format a number field element for deterministic user-facing output.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryFormatTraceMap', 'Algebraic Number Theory', '(value)', 'Format a trace map for deterministic user-facing output.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryGenerateExampleAlgebraicInteger', 'Algebraic Number Theory', '(size=3)', 'Generate a small documented example of a algebraic integer.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryGenerateExampleIdealClass', 'Algebraic Number Theory', '(size=3)', 'Generate a small documented example of a ideal class.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryGenerateExampleNormMap', 'Algebraic Number Theory', '(size=3)', 'Generate a small documented example of a norm map.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryGenerateExampleNumberFieldElement', 'Algebraic Number Theory', '(size=3)', 'Generate a small documented example of a number field element.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryGenerateExampleTraceMap', 'Algebraic Number Theory', '(size=3)', 'Generate a small documented example of a trace map.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryNormalizeAlgebraicInteger', 'Algebraic Number Theory', '(value)', 'Normalize a algebraic integer into the standard Algebraic Number Theory representation.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryNormalizeIdealClass', 'Algebraic Number Theory', '(value)', 'Normalize a ideal class into the standard Algebraic Number Theory representation.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryNormalizeNormMap', 'Algebraic Number Theory', '(value)', 'Normalize a norm map into the standard Algebraic Number Theory representation.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryNormalizeNumberFieldElement', 'Algebraic Number Theory', '(value)', 'Normalize a number field element into the standard Algebraic Number Theory representation.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryNormalizeTraceMap', 'Algebraic Number Theory', '(value)', 'Normalize a trace map into the standard Algebraic Number Theory representation.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryParseAlgebraicInteger', 'Algebraic Number Theory', '(text)', 'Parse a text or structured value into a algebraic integer.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryParseIdealClass', 'Algebraic Number Theory', '(text)', 'Parse a text or structured value into a ideal class.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryParseNormMap', 'Algebraic Number Theory', '(text)', 'Parse a text or structured value into a norm map.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryParseNumberFieldElement', 'Algebraic Number Theory', '(text)', 'Parse a text or structured value into a number field element.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryParseTraceMap', 'Algebraic Number Theory', '(text)', 'Parse a text or structured value into a trace map.', 'professional_function_catalog.md'), + ('algebraicNumberTheorySimplifyAlgebraicInteger', 'Algebraic Number Theory', '(value)', 'Simplify a algebraic integer without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('algebraicNumberTheorySimplifyIdealClass', 'Algebraic Number Theory', '(value)', 'Simplify a ideal class without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('algebraicNumberTheorySimplifyNormMap', 'Algebraic Number Theory', '(value)', 'Simplify a norm map without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('algebraicNumberTheorySimplifyNumberFieldElement', 'Algebraic Number Theory', '(value)', 'Simplify a number field element without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('algebraicNumberTheorySimplifyTraceMap', 'Algebraic Number Theory', '(value)', 'Simplify a trace map without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryTestEquivalenceAlgebraicInteger', 'Algebraic Number Theory', '(left, right)', 'Test whether two algebraic integer values are equivalent in Algebraic Number Theory.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryTestEquivalenceIdealClass', 'Algebraic Number Theory', '(left, right)', 'Test whether two ideal class values are equivalent in Algebraic Number Theory.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryTestEquivalenceNormMap', 'Algebraic Number Theory', '(left, right)', 'Test whether two norm map values are equivalent in Algebraic Number Theory.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryTestEquivalenceNumberFieldElement', 'Algebraic Number Theory', '(left, right)', 'Test whether two number field element values are equivalent in Algebraic Number Theory.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryTestEquivalenceTraceMap', 'Algebraic Number Theory', '(left, right)', 'Test whether two trace map values are equivalent in Algebraic Number Theory.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryTransformAlgebraicInteger', 'Algebraic Number Theory', '(value, mapping)', 'Transform a algebraic integer through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryTransformIdealClass', 'Algebraic Number Theory', '(value, mapping)', 'Transform a ideal class through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryTransformNormMap', 'Algebraic Number Theory', '(value, mapping)', 'Transform a norm map through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryTransformNumberFieldElement', 'Algebraic Number Theory', '(value, mapping)', 'Transform a number field element through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryTransformTraceMap', 'Algebraic Number Theory', '(value, mapping)', 'Transform a trace map through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryValidateAlgebraicInteger', 'Algebraic Number Theory', '(value)', 'Validate the algebraic integer representation and domain rules for Algebraic Number Theory.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryValidateIdealClass', 'Algebraic Number Theory', '(value)', 'Validate the ideal class representation and domain rules for Algebraic Number Theory.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryValidateNormMap', 'Algebraic Number Theory', '(value)', 'Validate the norm map representation and domain rules for Algebraic Number Theory.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryValidateNumberFieldElement', 'Algebraic Number Theory', '(value)', 'Validate the number field element representation and domain rules for Algebraic Number Theory.', 'professional_function_catalog.md'), + ('algebraicNumberTheoryValidateTraceMap', 'Algebraic Number Theory', '(value)', 'Validate the trace map representation and domain rules for Algebraic Number Theory.', 'professional_function_catalog.md'), + ('classNumberEstimateQuadratic', 'Algebraic Number Theory', '(d)', 'Planned roadmap function for Algebraic Number Theory from upcoming.md.', 'upcoming.md'), + ('isAlgebraicIntegerQuadratic', 'Algebraic Number Theory', '(x, d)', 'Planned roadmap function for Algebraic Number Theory from upcoming.md.', 'upcoming.md'), + ('quadraticFieldAdd', 'Algebraic Number Theory', '(x, y, d)', 'Planned roadmap function for Algebraic Number Theory from upcoming.md.', 'upcoming.md'), + ('quadraticFieldConjugate', 'Algebraic Number Theory', '(x, d)', 'Planned roadmap function for Algebraic Number Theory from upcoming.md.', 'upcoming.md'), + ('quadraticFieldElement', 'Algebraic Number Theory', '(a, b, d)', 'Planned roadmap function for Algebraic Number Theory from upcoming.md.', 'upcoming.md'), + ('quadraticFieldMultiply', 'Algebraic Number Theory', '(x, y, d)', 'Planned roadmap function for Algebraic Number Theory from upcoming.md.', 'upcoming.md'), + ('quadraticFieldNorm', 'Algebraic Number Theory', '(x, d)', 'Planned roadmap function for Algebraic Number Theory from upcoming.md.', 'upcoming.md'), + ('quadraticFieldTrace', 'Algebraic Number Theory', '(x, d)', 'Planned roadmap function for Algebraic Number Theory from upcoming.md.', 'upcoming.md'), + ('algebraicTopologyApproximateBettiProfile', 'Algebraic Topology', '(value, tolerance=1e-9)', 'Approximate a betti profile with explicit tolerance controls.', 'professional_function_catalog.md'), + ('algebraicTopologyApproximateBoundaryMap', 'Algebraic Topology', '(value, tolerance=1e-9)', 'Approximate a boundary map with explicit tolerance controls.', 'professional_function_catalog.md'), + ('algebraicTopologyApproximateChainComplex', 'Algebraic Topology', '(value, tolerance=1e-9)', 'Approximate a chain complex with explicit tolerance controls.', 'professional_function_catalog.md'), + ('algebraicTopologyApproximateHomologyGroup', 'Algebraic Topology', '(value, tolerance=1e-9)', 'Approximate a homology group with explicit tolerance controls.', 'professional_function_catalog.md'), + ('algebraicTopologyApproximateSimplex', 'Algebraic Topology', '(value, tolerance=1e-9)', 'Approximate a simplex with explicit tolerance controls.', 'professional_function_catalog.md'), + ('algebraicTopologyCanonicalizeBettiProfile', 'Algebraic Topology', '(value)', 'Canonicalize a betti profile so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('algebraicTopologyCanonicalizeBoundaryMap', 'Algebraic Topology', '(value)', 'Canonicalize a boundary map so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('algebraicTopologyCanonicalizeChainComplex', 'Algebraic Topology', '(value)', 'Canonicalize a chain complex so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('algebraicTopologyCanonicalizeHomologyGroup', 'Algebraic Topology', '(value)', 'Canonicalize a homology group so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('algebraicTopologyCanonicalizeSimplex', 'Algebraic Topology', '(value)', 'Canonicalize a simplex so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('algebraicTopologyClassifyBettiProfile', 'Algebraic Topology', '(value)', 'Classify a betti profile by its standard Algebraic Topology invariants.', 'professional_function_catalog.md'), + ('algebraicTopologyClassifyBoundaryMap', 'Algebraic Topology', '(value)', 'Classify a boundary map by its standard Algebraic Topology invariants.', 'professional_function_catalog.md'), + ('algebraicTopologyClassifyChainComplex', 'Algebraic Topology', '(value)', 'Classify a chain complex by its standard Algebraic Topology invariants.', 'professional_function_catalog.md'), + ('algebraicTopologyClassifyHomologyGroup', 'Algebraic Topology', '(value)', 'Classify a homology group by its standard Algebraic Topology invariants.', 'professional_function_catalog.md'), + ('algebraicTopologyClassifySimplex', 'Algebraic Topology', '(value)', 'Classify a simplex by its standard Algebraic Topology invariants.', 'professional_function_catalog.md'), + ('algebraicTopologyCombineBettiProfile', 'Algebraic Topology', '(left, right)', 'Combine two betti profile values with the natural operation for Algebraic Topology.', 'professional_function_catalog.md'), + ('algebraicTopologyCombineBoundaryMap', 'Algebraic Topology', '(left, right)', 'Combine two boundary map values with the natural operation for Algebraic Topology.', 'professional_function_catalog.md'), + ('algebraicTopologyCombineChainComplex', 'Algebraic Topology', '(left, right)', 'Combine two chain complex values with the natural operation for Algebraic Topology.', 'professional_function_catalog.md'), + ('algebraicTopologyCombineHomologyGroup', 'Algebraic Topology', '(left, right)', 'Combine two homology group values with the natural operation for Algebraic Topology.', 'professional_function_catalog.md'), + ('algebraicTopologyCombineSimplex', 'Algebraic Topology', '(left, right)', 'Combine two simplex values with the natural operation for Algebraic Topology.', 'professional_function_catalog.md'), + ('algebraicTopologyCompareBettiProfile', 'Algebraic Topology', '(left, right)', 'Compare two betti profile values under the conventions of Algebraic Topology.', 'professional_function_catalog.md'), + ('algebraicTopologyCompareBoundaryMap', 'Algebraic Topology', '(left, right)', 'Compare two boundary map values under the conventions of Algebraic Topology.', 'professional_function_catalog.md'), + ('algebraicTopologyCompareChainComplex', 'Algebraic Topology', '(left, right)', 'Compare two chain complex values under the conventions of Algebraic Topology.', 'professional_function_catalog.md'), + ('algebraicTopologyCompareHomologyGroup', 'Algebraic Topology', '(left, right)', 'Compare two homology group values under the conventions of Algebraic Topology.', 'professional_function_catalog.md'), + ('algebraicTopologyCompareSimplex', 'Algebraic Topology', '(left, right)', 'Compare two simplex values under the conventions of Algebraic Topology.', 'professional_function_catalog.md'), + ('algebraicTopologyComputeBettiProfile', 'Algebraic Topology', '(value)', 'Compute the central numerical or symbolic data of a betti profile.', 'professional_function_catalog.md'), + ('algebraicTopologyComputeBoundaryMap', 'Algebraic Topology', '(value)', 'Compute the central numerical or symbolic data of a boundary map.', 'professional_function_catalog.md'), + ('algebraicTopologyComputeChainComplex', 'Algebraic Topology', '(value)', 'Compute the central numerical or symbolic data of a chain complex.', 'professional_function_catalog.md'), + ('algebraicTopologyComputeHomologyGroup', 'Algebraic Topology', '(value)', 'Compute the central numerical or symbolic data of a homology group.', 'professional_function_catalog.md'), + ('algebraicTopologyComputeSimplex', 'Algebraic Topology', '(value)', 'Compute the central numerical or symbolic data of a simplex.', 'professional_function_catalog.md'), + ('algebraicTopologyConstructBettiProfile', 'Algebraic Topology', '(*args)', 'Construct a betti profile from explicit inputs for Algebraic Topology.', 'professional_function_catalog.md'), + ('algebraicTopologyConstructBoundaryMap', 'Algebraic Topology', '(*args)', 'Construct a boundary map from explicit inputs for Algebraic Topology.', 'professional_function_catalog.md'), + ('algebraicTopologyConstructChainComplex', 'Algebraic Topology', '(*args)', 'Construct a chain complex from explicit inputs for Algebraic Topology.', 'professional_function_catalog.md'), + ('algebraicTopologyConstructHomologyGroup', 'Algebraic Topology', '(*args)', 'Construct a homology group from explicit inputs for Algebraic Topology.', 'professional_function_catalog.md'), + ('algebraicTopologyConstructSimplex', 'Algebraic Topology', '(*args)', 'Construct a simplex from explicit inputs for Algebraic Topology.', 'professional_function_catalog.md'), + ('algebraicTopologyDecomposeBettiProfile', 'Algebraic Topology', '(value)', 'Decompose a betti profile into simpler or canonical components.', 'professional_function_catalog.md'), + ('algebraicTopologyDecomposeBoundaryMap', 'Algebraic Topology', '(value)', 'Decompose a boundary map into simpler or canonical components.', 'professional_function_catalog.md'), + ('algebraicTopologyDecomposeChainComplex', 'Algebraic Topology', '(value)', 'Decompose a chain complex into simpler or canonical components.', 'professional_function_catalog.md'), + ('algebraicTopologyDecomposeHomologyGroup', 'Algebraic Topology', '(value)', 'Decompose a homology group into simpler or canonical components.', 'professional_function_catalog.md'), + ('algebraicTopologyDecomposeSimplex', 'Algebraic Topology', '(value)', 'Decompose a simplex into simpler or canonical components.', 'professional_function_catalog.md'), + ('algebraicTopologyDocumentBettiProfile', 'Algebraic Topology', '(value)', 'Return a structured explanation of a betti profile and related assumptions.', 'professional_function_catalog.md'), + ('algebraicTopologyDocumentBoundaryMap', 'Algebraic Topology', '(value)', 'Return a structured explanation of a boundary map and related assumptions.', 'professional_function_catalog.md'), + ('algebraicTopologyDocumentChainComplex', 'Algebraic Topology', '(value)', 'Return a structured explanation of a chain complex and related assumptions.', 'professional_function_catalog.md'), + ('algebraicTopologyDocumentHomologyGroup', 'Algebraic Topology', '(value)', 'Return a structured explanation of a homology group and related assumptions.', 'professional_function_catalog.md'), + ('algebraicTopologyDocumentSimplex', 'Algebraic Topology', '(value)', 'Return a structured explanation of a simplex and related assumptions.', 'professional_function_catalog.md'), + ('algebraicTopologyEnumerateBettiProfile', 'Algebraic Topology', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a betti profile.', 'professional_function_catalog.md'), + ('algebraicTopologyEnumerateBoundaryMap', 'Algebraic Topology', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a boundary map.', 'professional_function_catalog.md'), + ('algebraicTopologyEnumerateChainComplex', 'Algebraic Topology', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a chain complex.', 'professional_function_catalog.md'), + ('algebraicTopologyEnumerateHomologyGroup', 'Algebraic Topology', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a homology group.', 'professional_function_catalog.md'), + ('algebraicTopologyEnumerateSimplex', 'Algebraic Topology', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a simplex.', 'professional_function_catalog.md'), + ('algebraicTopologyEstimateBettiProfile', 'Algebraic Topology', '(value, samples=None)', 'Estimate a betti profile property from finite samples or approximations.', 'professional_function_catalog.md'), + ('algebraicTopologyEstimateBoundaryMap', 'Algebraic Topology', '(value, samples=None)', 'Estimate a boundary map property from finite samples or approximations.', 'professional_function_catalog.md'), + ('algebraicTopologyEstimateChainComplex', 'Algebraic Topology', '(value, samples=None)', 'Estimate a chain complex property from finite samples or approximations.', 'professional_function_catalog.md'), + ('algebraicTopologyEstimateHomologyGroup', 'Algebraic Topology', '(value, samples=None)', 'Estimate a homology group property from finite samples or approximations.', 'professional_function_catalog.md'), + ('algebraicTopologyEstimateSimplex', 'Algebraic Topology', '(value, samples=None)', 'Estimate a simplex property from finite samples or approximations.', 'professional_function_catalog.md'), + ('algebraicTopologyEvaluateBettiProfile', 'Algebraic Topology', '(value, point=None)', 'Evaluate a betti profile at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('algebraicTopologyEvaluateBoundaryMap', 'Algebraic Topology', '(value, point=None)', 'Evaluate a boundary map at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('algebraicTopologyEvaluateChainComplex', 'Algebraic Topology', '(value, point=None)', 'Evaluate a chain complex at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('algebraicTopologyEvaluateHomologyGroup', 'Algebraic Topology', '(value, point=None)', 'Evaluate a homology group at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('algebraicTopologyEvaluateSimplex', 'Algebraic Topology', '(value, point=None)', 'Evaluate a simplex at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('algebraicTopologyFormatBettiProfile', 'Algebraic Topology', '(value)', 'Format a betti profile for deterministic user-facing output.', 'professional_function_catalog.md'), + ('algebraicTopologyFormatBoundaryMap', 'Algebraic Topology', '(value)', 'Format a boundary map for deterministic user-facing output.', 'professional_function_catalog.md'), + ('algebraicTopologyFormatChainComplex', 'Algebraic Topology', '(value)', 'Format a chain complex for deterministic user-facing output.', 'professional_function_catalog.md'), + ('algebraicTopologyFormatHomologyGroup', 'Algebraic Topology', '(value)', 'Format a homology group for deterministic user-facing output.', 'professional_function_catalog.md'), + ('algebraicTopologyFormatSimplex', 'Algebraic Topology', '(value)', 'Format a simplex for deterministic user-facing output.', 'professional_function_catalog.md'), + ('algebraicTopologyGenerateExampleBettiProfile', 'Algebraic Topology', '(size=3)', 'Generate a small documented example of a betti profile.', 'professional_function_catalog.md'), + ('algebraicTopologyGenerateExampleBoundaryMap', 'Algebraic Topology', '(size=3)', 'Generate a small documented example of a boundary map.', 'professional_function_catalog.md'), + ('algebraicTopologyGenerateExampleChainComplex', 'Algebraic Topology', '(size=3)', 'Generate a small documented example of a chain complex.', 'professional_function_catalog.md'), + ('algebraicTopologyGenerateExampleHomologyGroup', 'Algebraic Topology', '(size=3)', 'Generate a small documented example of a homology group.', 'professional_function_catalog.md'), + ('algebraicTopologyGenerateExampleSimplex', 'Algebraic Topology', '(size=3)', 'Generate a small documented example of a simplex.', 'professional_function_catalog.md'), + ('algebraicTopologyNormalizeBettiProfile', 'Algebraic Topology', '(value)', 'Normalize a betti profile into the standard Algebraic Topology representation.', 'professional_function_catalog.md'), + ('algebraicTopologyNormalizeBoundaryMap', 'Algebraic Topology', '(value)', 'Normalize a boundary map into the standard Algebraic Topology representation.', 'professional_function_catalog.md'), + ('algebraicTopologyNormalizeChainComplex', 'Algebraic Topology', '(value)', 'Normalize a chain complex into the standard Algebraic Topology representation.', 'professional_function_catalog.md'), + ('algebraicTopologyNormalizeHomologyGroup', 'Algebraic Topology', '(value)', 'Normalize a homology group into the standard Algebraic Topology representation.', 'professional_function_catalog.md'), + ('algebraicTopologyNormalizeSimplex', 'Algebraic Topology', '(value)', 'Normalize a simplex into the standard Algebraic Topology representation.', 'professional_function_catalog.md'), + ('algebraicTopologyParseBettiProfile', 'Algebraic Topology', '(text)', 'Parse a text or structured value into a betti profile.', 'professional_function_catalog.md'), + ('algebraicTopologyParseBoundaryMap', 'Algebraic Topology', '(text)', 'Parse a text or structured value into a boundary map.', 'professional_function_catalog.md'), + ('algebraicTopologyParseChainComplex', 'Algebraic Topology', '(text)', 'Parse a text or structured value into a chain complex.', 'professional_function_catalog.md'), + ('algebraicTopologyParseHomologyGroup', 'Algebraic Topology', '(text)', 'Parse a text or structured value into a homology group.', 'professional_function_catalog.md'), + ('algebraicTopologyParseSimplex', 'Algebraic Topology', '(text)', 'Parse a text or structured value into a simplex.', 'professional_function_catalog.md'), + ('algebraicTopologySimplifyBettiProfile', 'Algebraic Topology', '(value)', 'Simplify a betti profile without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('algebraicTopologySimplifyBoundaryMap', 'Algebraic Topology', '(value)', 'Simplify a boundary map without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('algebraicTopologySimplifyChainComplex', 'Algebraic Topology', '(value)', 'Simplify a chain complex without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('algebraicTopologySimplifyHomologyGroup', 'Algebraic Topology', '(value)', 'Simplify a homology group without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('algebraicTopologySimplifySimplex', 'Algebraic Topology', '(value)', 'Simplify a simplex without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('algebraicTopologyTestEquivalenceBettiProfile', 'Algebraic Topology', '(left, right)', 'Test whether two betti profile values are equivalent in Algebraic Topology.', 'professional_function_catalog.md'), + ('algebraicTopologyTestEquivalenceBoundaryMap', 'Algebraic Topology', '(left, right)', 'Test whether two boundary map values are equivalent in Algebraic Topology.', 'professional_function_catalog.md'), + ('algebraicTopologyTestEquivalenceChainComplex', 'Algebraic Topology', '(left, right)', 'Test whether two chain complex values are equivalent in Algebraic Topology.', 'professional_function_catalog.md'), + ('algebraicTopologyTestEquivalenceHomologyGroup', 'Algebraic Topology', '(left, right)', 'Test whether two homology group values are equivalent in Algebraic Topology.', 'professional_function_catalog.md'), + ('algebraicTopologyTestEquivalenceSimplex', 'Algebraic Topology', '(left, right)', 'Test whether two simplex values are equivalent in Algebraic Topology.', 'professional_function_catalog.md'), + ('algebraicTopologyTransformBettiProfile', 'Algebraic Topology', '(value, mapping)', 'Transform a betti profile through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('algebraicTopologyTransformBoundaryMap', 'Algebraic Topology', '(value, mapping)', 'Transform a boundary map through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('algebraicTopologyTransformChainComplex', 'Algebraic Topology', '(value, mapping)', 'Transform a chain complex through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('algebraicTopologyTransformHomologyGroup', 'Algebraic Topology', '(value, mapping)', 'Transform a homology group through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('algebraicTopologyTransformSimplex', 'Algebraic Topology', '(value, mapping)', 'Transform a simplex through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('algebraicTopologyValidateBettiProfile', 'Algebraic Topology', '(value)', 'Validate the betti profile representation and domain rules for Algebraic Topology.', 'professional_function_catalog.md'), + ('algebraicTopologyValidateBoundaryMap', 'Algebraic Topology', '(value)', 'Validate the boundary map representation and domain rules for Algebraic Topology.', 'professional_function_catalog.md'), + ('algebraicTopologyValidateChainComplex', 'Algebraic Topology', '(value)', 'Validate the chain complex representation and domain rules for Algebraic Topology.', 'professional_function_catalog.md'), + ('algebraicTopologyValidateHomologyGroup', 'Algebraic Topology', '(value)', 'Validate the homology group representation and domain rules for Algebraic Topology.', 'professional_function_catalog.md'), + ('algebraicTopologyValidateSimplex', 'Algebraic Topology', '(value)', 'Validate the simplex representation and domain rules for Algebraic Topology.', 'professional_function_catalog.md'), + ('bettiNumber', 'Algebraic Topology', '(complex, dimension)', 'Planned roadmap function for Algebraic Topology from upcoming.md.', 'upcoming.md'), + ('boundaryMatrix', 'Algebraic Topology', '(complex, dimension)', 'Planned roadmap function for Algebraic Topology from upcoming.md.', 'upcoming.md'), + ('boundaryOfSimplex', 'Algebraic Topology', '(simplex)', 'Planned roadmap function for Algebraic Topology from upcoming.md.', 'upcoming.md'), + ('chainGroupRank', 'Algebraic Topology', '(complex, dimension)', 'Planned roadmap function for Algebraic Topology from upcoming.md.', 'upcoming.md'), + ('eulerCharacteristicFromBetti', 'Algebraic Topology', '(bettiNumbers)', 'Planned roadmap function for Algebraic Topology from upcoming.md.', 'upcoming.md'), + ('facesOfComplex', 'Algebraic Topology', '(complex)', 'Planned roadmap function for Algebraic Topology from upcoming.md.', 'upcoming.md'), + ('isCycle', 'Algebraic Topology', '(chain, boundaryMatrix)', 'Planned roadmap function for Algebraic Topology from upcoming.md.', 'upcoming.md'), + ('simplicialHomologyRanks', 'Algebraic Topology', '(complex)', 'Planned roadmap function for Algebraic Topology from upcoming.md.', 'upcoming.md'), + ('analyticNumberTheoryApproximateArithmeticSum', 'Analytic Number Theory', '(value, tolerance=1e-9)', 'Approximate a arithmetic sum with explicit tolerance controls.', 'professional_function_catalog.md'), + ('analyticNumberTheoryApproximateChebyshevFunction', 'Analytic Number Theory', '(value, tolerance=1e-9)', 'Approximate a Chebyshev function with explicit tolerance controls.', 'professional_function_catalog.md'), + ('analyticNumberTheoryApproximateDirichletSeries', 'Analytic Number Theory', '(value, tolerance=1e-9)', 'Approximate a Dirichlet series with explicit tolerance controls.', 'professional_function_catalog.md'), + ('analyticNumberTheoryApproximatePrimeCountingModel', 'Analytic Number Theory', '(value, tolerance=1e-9)', 'Approximate a prime counting model with explicit tolerance controls.', 'professional_function_catalog.md'), + ('analyticNumberTheoryApproximateZetaApproximation', 'Analytic Number Theory', '(value, tolerance=1e-9)', 'Approximate a zeta approximation with explicit tolerance controls.', 'professional_function_catalog.md'), + ('analyticNumberTheoryCanonicalizeArithmeticSum', 'Analytic Number Theory', '(value)', 'Canonicalize a arithmetic sum so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('analyticNumberTheoryCanonicalizeChebyshevFunction', 'Analytic Number Theory', '(value)', 'Canonicalize a Chebyshev function so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('analyticNumberTheoryCanonicalizeDirichletSeries', 'Analytic Number Theory', '(value)', 'Canonicalize a Dirichlet series so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('analyticNumberTheoryCanonicalizePrimeCountingModel', 'Analytic Number Theory', '(value)', 'Canonicalize a prime counting model so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('analyticNumberTheoryCanonicalizeZetaApproximation', 'Analytic Number Theory', '(value)', 'Canonicalize a zeta approximation so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('analyticNumberTheoryClassifyArithmeticSum', 'Analytic Number Theory', '(value)', 'Classify a arithmetic sum by its standard Analytic Number Theory invariants.', 'professional_function_catalog.md'), + ('analyticNumberTheoryClassifyChebyshevFunction', 'Analytic Number Theory', '(value)', 'Classify a Chebyshev function by its standard Analytic Number Theory invariants.', 'professional_function_catalog.md'), + ('analyticNumberTheoryClassifyDirichletSeries', 'Analytic Number Theory', '(value)', 'Classify a Dirichlet series by its standard Analytic Number Theory invariants.', 'professional_function_catalog.md'), + ('analyticNumberTheoryClassifyPrimeCountingModel', 'Analytic Number Theory', '(value)', 'Classify a prime counting model by its standard Analytic Number Theory invariants.', 'professional_function_catalog.md'), + ('analyticNumberTheoryClassifyZetaApproximation', 'Analytic Number Theory', '(value)', 'Classify a zeta approximation by its standard Analytic Number Theory invariants.', 'professional_function_catalog.md'), + ('analyticNumberTheoryCombineArithmeticSum', 'Analytic Number Theory', '(left, right)', 'Combine two arithmetic sum values with the natural operation for Analytic Number Theory.', 'professional_function_catalog.md'), + ('analyticNumberTheoryCombineChebyshevFunction', 'Analytic Number Theory', '(left, right)', 'Combine two Chebyshev function values with the natural operation for Analytic Number Theory.', 'professional_function_catalog.md'), + ('analyticNumberTheoryCombineDirichletSeries', 'Analytic Number Theory', '(left, right)', 'Combine two Dirichlet series values with the natural operation for Analytic Number Theory.', 'professional_function_catalog.md'), + ('analyticNumberTheoryCombinePrimeCountingModel', 'Analytic Number Theory', '(left, right)', 'Combine two prime counting model values with the natural operation for Analytic Number Theory.', 'professional_function_catalog.md'), + ('analyticNumberTheoryCombineZetaApproximation', 'Analytic Number Theory', '(left, right)', 'Combine two zeta approximation values with the natural operation for Analytic Number Theory.', 'professional_function_catalog.md'), + ('analyticNumberTheoryCompareArithmeticSum', 'Analytic Number Theory', '(left, right)', 'Compare two arithmetic sum values under the conventions of Analytic Number Theory.', 'professional_function_catalog.md'), + ('analyticNumberTheoryCompareChebyshevFunction', 'Analytic Number Theory', '(left, right)', 'Compare two Chebyshev function values under the conventions of Analytic Number Theory.', 'professional_function_catalog.md'), + ('analyticNumberTheoryCompareDirichletSeries', 'Analytic Number Theory', '(left, right)', 'Compare two Dirichlet series values under the conventions of Analytic Number Theory.', 'professional_function_catalog.md'), + ('analyticNumberTheoryComparePrimeCountingModel', 'Analytic Number Theory', '(left, right)', 'Compare two prime counting model values under the conventions of Analytic Number Theory.', 'professional_function_catalog.md'), + ('analyticNumberTheoryCompareZetaApproximation', 'Analytic Number Theory', '(left, right)', 'Compare two zeta approximation values under the conventions of Analytic Number Theory.', 'professional_function_catalog.md'), + ('analyticNumberTheoryComputeArithmeticSum', 'Analytic Number Theory', '(value)', 'Compute the central numerical or symbolic data of a arithmetic sum.', 'professional_function_catalog.md'), + ('analyticNumberTheoryComputeChebyshevFunction', 'Analytic Number Theory', '(value)', 'Compute the central numerical or symbolic data of a Chebyshev function.', 'professional_function_catalog.md'), + ('analyticNumberTheoryComputeDirichletSeries', 'Analytic Number Theory', '(value)', 'Compute the central numerical or symbolic data of a Dirichlet series.', 'professional_function_catalog.md'), + ('analyticNumberTheoryComputePrimeCountingModel', 'Analytic Number Theory', '(value)', 'Compute the central numerical or symbolic data of a prime counting model.', 'professional_function_catalog.md'), + ('analyticNumberTheoryComputeZetaApproximation', 'Analytic Number Theory', '(value)', 'Compute the central numerical or symbolic data of a zeta approximation.', 'professional_function_catalog.md'), + ('analyticNumberTheoryConstructArithmeticSum', 'Analytic Number Theory', '(*args)', 'Construct a arithmetic sum from explicit inputs for Analytic Number Theory.', 'professional_function_catalog.md'), + ('analyticNumberTheoryConstructChebyshevFunction', 'Analytic Number Theory', '(*args)', 'Construct a Chebyshev function from explicit inputs for Analytic Number Theory.', 'professional_function_catalog.md'), + ('analyticNumberTheoryConstructDirichletSeries', 'Analytic Number Theory', '(*args)', 'Construct a Dirichlet series from explicit inputs for Analytic Number Theory.', 'professional_function_catalog.md'), + ('analyticNumberTheoryConstructPrimeCountingModel', 'Analytic Number Theory', '(*args)', 'Construct a prime counting model from explicit inputs for Analytic Number Theory.', 'professional_function_catalog.md'), + ('analyticNumberTheoryConstructZetaApproximation', 'Analytic Number Theory', '(*args)', 'Construct a zeta approximation from explicit inputs for Analytic Number Theory.', 'professional_function_catalog.md'), + ('analyticNumberTheoryDecomposeArithmeticSum', 'Analytic Number Theory', '(value)', 'Decompose a arithmetic sum into simpler or canonical components.', 'professional_function_catalog.md'), + ('analyticNumberTheoryDecomposeChebyshevFunction', 'Analytic Number Theory', '(value)', 'Decompose a Chebyshev function into simpler or canonical components.', 'professional_function_catalog.md'), + ('analyticNumberTheoryDecomposeDirichletSeries', 'Analytic Number Theory', '(value)', 'Decompose a Dirichlet series into simpler or canonical components.', 'professional_function_catalog.md'), + ('analyticNumberTheoryDecomposePrimeCountingModel', 'Analytic Number Theory', '(value)', 'Decompose a prime counting model into simpler or canonical components.', 'professional_function_catalog.md'), + ('analyticNumberTheoryDecomposeZetaApproximation', 'Analytic Number Theory', '(value)', 'Decompose a zeta approximation into simpler or canonical components.', 'professional_function_catalog.md'), + ('analyticNumberTheoryDocumentArithmeticSum', 'Analytic Number Theory', '(value)', 'Return a structured explanation of a arithmetic sum and related assumptions.', 'professional_function_catalog.md'), + ('analyticNumberTheoryDocumentChebyshevFunction', 'Analytic Number Theory', '(value)', 'Return a structured explanation of a Chebyshev function and related assumptions.', 'professional_function_catalog.md'), + ('analyticNumberTheoryDocumentDirichletSeries', 'Analytic Number Theory', '(value)', 'Return a structured explanation of a Dirichlet series and related assumptions.', 'professional_function_catalog.md'), + ('analyticNumberTheoryDocumentPrimeCountingModel', 'Analytic Number Theory', '(value)', 'Return a structured explanation of a prime counting model and related assumptions.', 'professional_function_catalog.md'), + ('analyticNumberTheoryDocumentZetaApproximation', 'Analytic Number Theory', '(value)', 'Return a structured explanation of a zeta approximation and related assumptions.', 'professional_function_catalog.md'), + ('analyticNumberTheoryEnumerateArithmeticSum', 'Analytic Number Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a arithmetic sum.', 'professional_function_catalog.md'), + ('analyticNumberTheoryEnumerateChebyshevFunction', 'Analytic Number Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a Chebyshev function.', 'professional_function_catalog.md'), + ('analyticNumberTheoryEnumerateDirichletSeries', 'Analytic Number Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a Dirichlet series.', 'professional_function_catalog.md'), + ('analyticNumberTheoryEnumeratePrimeCountingModel', 'Analytic Number Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a prime counting model.', 'professional_function_catalog.md'), + ('analyticNumberTheoryEnumerateZetaApproximation', 'Analytic Number Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a zeta approximation.', 'professional_function_catalog.md'), + ('analyticNumberTheoryEstimateArithmeticSum', 'Analytic Number Theory', '(value, samples=None)', 'Estimate a arithmetic sum property from finite samples or approximations.', 'professional_function_catalog.md'), + ('analyticNumberTheoryEstimateChebyshevFunction', 'Analytic Number Theory', '(value, samples=None)', 'Estimate a Chebyshev function property from finite samples or approximations.', 'professional_function_catalog.md'), + ('analyticNumberTheoryEstimateDirichletSeries', 'Analytic Number Theory', '(value, samples=None)', 'Estimate a Dirichlet series property from finite samples or approximations.', 'professional_function_catalog.md'), + ('analyticNumberTheoryEstimatePrimeCountingModel', 'Analytic Number Theory', '(value, samples=None)', 'Estimate a prime counting model property from finite samples or approximations.', 'professional_function_catalog.md'), + ('analyticNumberTheoryEstimateZetaApproximation', 'Analytic Number Theory', '(value, samples=None)', 'Estimate a zeta approximation property from finite samples or approximations.', 'professional_function_catalog.md'), + ('analyticNumberTheoryEvaluateArithmeticSum', 'Analytic Number Theory', '(value, point=None)', 'Evaluate a arithmetic sum at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('analyticNumberTheoryEvaluateChebyshevFunction', 'Analytic Number Theory', '(value, point=None)', 'Evaluate a Chebyshev function at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('analyticNumberTheoryEvaluateDirichletSeries', 'Analytic Number Theory', '(value, point=None)', 'Evaluate a Dirichlet series at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('analyticNumberTheoryEvaluatePrimeCountingModel', 'Analytic Number Theory', '(value, point=None)', 'Evaluate a prime counting model at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('analyticNumberTheoryEvaluateZetaApproximation', 'Analytic Number Theory', '(value, point=None)', 'Evaluate a zeta approximation at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('analyticNumberTheoryFormatArithmeticSum', 'Analytic Number Theory', '(value)', 'Format a arithmetic sum for deterministic user-facing output.', 'professional_function_catalog.md'), + ('analyticNumberTheoryFormatChebyshevFunction', 'Analytic Number Theory', '(value)', 'Format a Chebyshev function for deterministic user-facing output.', 'professional_function_catalog.md'), + ('analyticNumberTheoryFormatDirichletSeries', 'Analytic Number Theory', '(value)', 'Format a Dirichlet series for deterministic user-facing output.', 'professional_function_catalog.md'), + ('analyticNumberTheoryFormatPrimeCountingModel', 'Analytic Number Theory', '(value)', 'Format a prime counting model for deterministic user-facing output.', 'professional_function_catalog.md'), + ('analyticNumberTheoryFormatZetaApproximation', 'Analytic Number Theory', '(value)', 'Format a zeta approximation for deterministic user-facing output.', 'professional_function_catalog.md'), + ('analyticNumberTheoryGenerateExampleArithmeticSum', 'Analytic Number Theory', '(size=3)', 'Generate a small documented example of a arithmetic sum.', 'professional_function_catalog.md'), + ('analyticNumberTheoryGenerateExampleChebyshevFunction', 'Analytic Number Theory', '(size=3)', 'Generate a small documented example of a Chebyshev function.', 'professional_function_catalog.md'), + ('analyticNumberTheoryGenerateExampleDirichletSeries', 'Analytic Number Theory', '(size=3)', 'Generate a small documented example of a Dirichlet series.', 'professional_function_catalog.md'), + ('analyticNumberTheoryGenerateExamplePrimeCountingModel', 'Analytic Number Theory', '(size=3)', 'Generate a small documented example of a prime counting model.', 'professional_function_catalog.md'), + ('analyticNumberTheoryGenerateExampleZetaApproximation', 'Analytic Number Theory', '(size=3)', 'Generate a small documented example of a zeta approximation.', 'professional_function_catalog.md'), + ('analyticNumberTheoryNormalizeArithmeticSum', 'Analytic Number Theory', '(value)', 'Normalize a arithmetic sum into the standard Analytic Number Theory representation.', 'professional_function_catalog.md'), + ('analyticNumberTheoryNormalizeChebyshevFunction', 'Analytic Number Theory', '(value)', 'Normalize a Chebyshev function into the standard Analytic Number Theory representation.', 'professional_function_catalog.md'), + ('analyticNumberTheoryNormalizeDirichletSeries', 'Analytic Number Theory', '(value)', 'Normalize a Dirichlet series into the standard Analytic Number Theory representation.', 'professional_function_catalog.md'), + ('analyticNumberTheoryNormalizePrimeCountingModel', 'Analytic Number Theory', '(value)', 'Normalize a prime counting model into the standard Analytic Number Theory representation.', 'professional_function_catalog.md'), + ('analyticNumberTheoryNormalizeZetaApproximation', 'Analytic Number Theory', '(value)', 'Normalize a zeta approximation into the standard Analytic Number Theory representation.', 'professional_function_catalog.md'), + ('analyticNumberTheoryParseArithmeticSum', 'Analytic Number Theory', '(text)', 'Parse a text or structured value into a arithmetic sum.', 'professional_function_catalog.md'), + ('analyticNumberTheoryParseChebyshevFunction', 'Analytic Number Theory', '(text)', 'Parse a text or structured value into a Chebyshev function.', 'professional_function_catalog.md'), + ('analyticNumberTheoryParseDirichletSeries', 'Analytic Number Theory', '(text)', 'Parse a text or structured value into a Dirichlet series.', 'professional_function_catalog.md'), + ('analyticNumberTheoryParsePrimeCountingModel', 'Analytic Number Theory', '(text)', 'Parse a text or structured value into a prime counting model.', 'professional_function_catalog.md'), + ('analyticNumberTheoryParseZetaApproximation', 'Analytic Number Theory', '(text)', 'Parse a text or structured value into a zeta approximation.', 'professional_function_catalog.md'), + ('analyticNumberTheorySimplifyArithmeticSum', 'Analytic Number Theory', '(value)', 'Simplify a arithmetic sum without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('analyticNumberTheorySimplifyChebyshevFunction', 'Analytic Number Theory', '(value)', 'Simplify a Chebyshev function without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('analyticNumberTheorySimplifyDirichletSeries', 'Analytic Number Theory', '(value)', 'Simplify a Dirichlet series without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('analyticNumberTheorySimplifyPrimeCountingModel', 'Analytic Number Theory', '(value)', 'Simplify a prime counting model without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('analyticNumberTheorySimplifyZetaApproximation', 'Analytic Number Theory', '(value)', 'Simplify a zeta approximation without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('analyticNumberTheoryTestEquivalenceArithmeticSum', 'Analytic Number Theory', '(left, right)', 'Test whether two arithmetic sum values are equivalent in Analytic Number Theory.', 'professional_function_catalog.md'), + ('analyticNumberTheoryTestEquivalenceChebyshevFunction', 'Analytic Number Theory', '(left, right)', 'Test whether two Chebyshev function values are equivalent in Analytic Number Theory.', 'professional_function_catalog.md'), + ('analyticNumberTheoryTestEquivalenceDirichletSeries', 'Analytic Number Theory', '(left, right)', 'Test whether two Dirichlet series values are equivalent in Analytic Number Theory.', 'professional_function_catalog.md'), + ('analyticNumberTheoryTestEquivalencePrimeCountingModel', 'Analytic Number Theory', '(left, right)', 'Test whether two prime counting model values are equivalent in Analytic Number Theory.', 'professional_function_catalog.md'), + ('analyticNumberTheoryTestEquivalenceZetaApproximation', 'Analytic Number Theory', '(left, right)', 'Test whether two zeta approximation values are equivalent in Analytic Number Theory.', 'professional_function_catalog.md'), + ('analyticNumberTheoryTransformArithmeticSum', 'Analytic Number Theory', '(value, mapping)', 'Transform a arithmetic sum through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('analyticNumberTheoryTransformChebyshevFunction', 'Analytic Number Theory', '(value, mapping)', 'Transform a Chebyshev function through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('analyticNumberTheoryTransformDirichletSeries', 'Analytic Number Theory', '(value, mapping)', 'Transform a Dirichlet series through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('analyticNumberTheoryTransformPrimeCountingModel', 'Analytic Number Theory', '(value, mapping)', 'Transform a prime counting model through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('analyticNumberTheoryTransformZetaApproximation', 'Analytic Number Theory', '(value, mapping)', 'Transform a zeta approximation through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('analyticNumberTheoryValidateArithmeticSum', 'Analytic Number Theory', '(value)', 'Validate the arithmetic sum representation and domain rules for Analytic Number Theory.', 'professional_function_catalog.md'), + ('analyticNumberTheoryValidateChebyshevFunction', 'Analytic Number Theory', '(value)', 'Validate the Chebyshev function representation and domain rules for Analytic Number Theory.', 'professional_function_catalog.md'), + ('analyticNumberTheoryValidateDirichletSeries', 'Analytic Number Theory', '(value)', 'Validate the Dirichlet series representation and domain rules for Analytic Number Theory.', 'professional_function_catalog.md'), + ('analyticNumberTheoryValidatePrimeCountingModel', 'Analytic Number Theory', '(value)', 'Validate the prime counting model representation and domain rules for Analytic Number Theory.', 'professional_function_catalog.md'), + ('analyticNumberTheoryValidateZetaApproximation', 'Analytic Number Theory', '(value)', 'Validate the zeta approximation representation and domain rules for Analytic Number Theory.', 'professional_function_catalog.md'), + ('chebyshevPsi', 'Analytic Number Theory', '(n)', 'Planned roadmap function for Analytic Number Theory from upcoming.md.', 'upcoming.md'), + ('chebyshevTheta', 'Analytic Number Theory', '(n)', 'Planned roadmap function for Analytic Number Theory from upcoming.md.', 'upcoming.md'), + ('divisorSummatory', 'Analytic Number Theory', '(n)', 'Planned roadmap function for Analytic Number Theory from upcoming.md.', 'upcoming.md'), + ('logIntegralApprox', 'Analytic Number Theory', '(x)', 'Planned roadmap function for Analytic Number Theory from upcoming.md.', 'upcoming.md'), + ('mertensFunction', 'Analytic Number Theory', '(n)', 'Planned roadmap function for Analytic Number Theory from upcoming.md.', 'upcoming.md'), + ('mobiusSummatory', 'Analytic Number Theory', '(n)', 'Planned roadmap function for Analytic Number Theory from upcoming.md.', 'upcoming.md'), + ('primeCountingFunction', 'Analytic Number Theory', '(n)', 'Planned roadmap function for Analytic Number Theory from upcoming.md.', 'upcoming.md'), + ('riemannZetaPartial', 'Analytic Number Theory', '(s, terms)', 'Planned roadmap function for Analytic Number Theory from upcoming.md.', 'upcoming.md'), + ('approximationErrorSamples', 'Approximation Theory', '(f, g, points)', 'Planned roadmap function for Approximation Theory from upcoming.md.', 'upcoming.md'), + ('approximationTheoryApproximateApproximant', 'Approximation Theory', '(value, tolerance=1e-9)', 'Approximate a approximant with explicit tolerance controls.', 'professional_function_catalog.md'), + ('approximationTheoryApproximateApproximationError', 'Approximation Theory', '(value, tolerance=1e-9)', 'Approximate a approximation error with explicit tolerance controls.', 'professional_function_catalog.md'), + ('approximationTheoryApproximateBasisCoefficient', 'Approximation Theory', '(value, tolerance=1e-9)', 'Approximate a basis coefficient with explicit tolerance controls.', 'professional_function_catalog.md'), + ('approximationTheoryApproximateInterpolationNode', 'Approximation Theory', '(value, tolerance=1e-9)', 'Approximate a interpolation node with explicit tolerance controls.', 'professional_function_catalog.md'), + ('approximationTheoryApproximateOrthogonalPolynomial', 'Approximation Theory', '(value, tolerance=1e-9)', 'Approximate a orthogonal polynomial with explicit tolerance controls.', 'professional_function_catalog.md'), + ('approximationTheoryCanonicalizeApproximant', 'Approximation Theory', '(value)', 'Canonicalize a approximant so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('approximationTheoryCanonicalizeApproximationError', 'Approximation Theory', '(value)', 'Canonicalize a approximation error so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('approximationTheoryCanonicalizeBasisCoefficient', 'Approximation Theory', '(value)', 'Canonicalize a basis coefficient so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('approximationTheoryCanonicalizeInterpolationNode', 'Approximation Theory', '(value)', 'Canonicalize a interpolation node so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('approximationTheoryCanonicalizeOrthogonalPolynomial', 'Approximation Theory', '(value)', 'Canonicalize a orthogonal polynomial so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('approximationTheoryClassifyApproximant', 'Approximation Theory', '(value)', 'Classify a approximant by its standard Approximation Theory invariants.', 'professional_function_catalog.md'), + ('approximationTheoryClassifyApproximationError', 'Approximation Theory', '(value)', 'Classify a approximation error by its standard Approximation Theory invariants.', 'professional_function_catalog.md'), + ('approximationTheoryClassifyBasisCoefficient', 'Approximation Theory', '(value)', 'Classify a basis coefficient by its standard Approximation Theory invariants.', 'professional_function_catalog.md'), + ('approximationTheoryClassifyInterpolationNode', 'Approximation Theory', '(value)', 'Classify a interpolation node by its standard Approximation Theory invariants.', 'professional_function_catalog.md'), + ('approximationTheoryClassifyOrthogonalPolynomial', 'Approximation Theory', '(value)', 'Classify a orthogonal polynomial by its standard Approximation Theory invariants.', 'professional_function_catalog.md'), + ('approximationTheoryCombineApproximant', 'Approximation Theory', '(left, right)', 'Combine two approximant values with the natural operation for Approximation Theory.', 'professional_function_catalog.md'), + ('approximationTheoryCombineApproximationError', 'Approximation Theory', '(left, right)', 'Combine two approximation error values with the natural operation for Approximation Theory.', 'professional_function_catalog.md'), + ('approximationTheoryCombineBasisCoefficient', 'Approximation Theory', '(left, right)', 'Combine two basis coefficient values with the natural operation for Approximation Theory.', 'professional_function_catalog.md'), + ('approximationTheoryCombineInterpolationNode', 'Approximation Theory', '(left, right)', 'Combine two interpolation node values with the natural operation for Approximation Theory.', 'professional_function_catalog.md'), + ('approximationTheoryCombineOrthogonalPolynomial', 'Approximation Theory', '(left, right)', 'Combine two orthogonal polynomial values with the natural operation for Approximation Theory.', 'professional_function_catalog.md'), + ('approximationTheoryCompareApproximant', 'Approximation Theory', '(left, right)', 'Compare two approximant values under the conventions of Approximation Theory.', 'professional_function_catalog.md'), + ('approximationTheoryCompareApproximationError', 'Approximation Theory', '(left, right)', 'Compare two approximation error values under the conventions of Approximation Theory.', 'professional_function_catalog.md'), + ('approximationTheoryCompareBasisCoefficient', 'Approximation Theory', '(left, right)', 'Compare two basis coefficient values under the conventions of Approximation Theory.', 'professional_function_catalog.md'), + ('approximationTheoryCompareInterpolationNode', 'Approximation Theory', '(left, right)', 'Compare two interpolation node values under the conventions of Approximation Theory.', 'professional_function_catalog.md'), + ('approximationTheoryCompareOrthogonalPolynomial', 'Approximation Theory', '(left, right)', 'Compare two orthogonal polynomial values under the conventions of Approximation Theory.', 'professional_function_catalog.md'), + ('approximationTheoryComputeApproximant', 'Approximation Theory', '(value)', 'Compute the central numerical or symbolic data of a approximant.', 'professional_function_catalog.md'), + ('approximationTheoryComputeApproximationError', 'Approximation Theory', '(value)', 'Compute the central numerical or symbolic data of a approximation error.', 'professional_function_catalog.md'), + ('approximationTheoryComputeBasisCoefficient', 'Approximation Theory', '(value)', 'Compute the central numerical or symbolic data of a basis coefficient.', 'professional_function_catalog.md'), + ('approximationTheoryComputeInterpolationNode', 'Approximation Theory', '(value)', 'Compute the central numerical or symbolic data of a interpolation node.', 'professional_function_catalog.md'), + ('approximationTheoryComputeOrthogonalPolynomial', 'Approximation Theory', '(value)', 'Compute the central numerical or symbolic data of a orthogonal polynomial.', 'professional_function_catalog.md'), + ('approximationTheoryConstructApproximant', 'Approximation Theory', '(*args)', 'Construct a approximant from explicit inputs for Approximation Theory.', 'professional_function_catalog.md'), + ('approximationTheoryConstructApproximationError', 'Approximation Theory', '(*args)', 'Construct a approximation error from explicit inputs for Approximation Theory.', 'professional_function_catalog.md'), + ('approximationTheoryConstructBasisCoefficient', 'Approximation Theory', '(*args)', 'Construct a basis coefficient from explicit inputs for Approximation Theory.', 'professional_function_catalog.md'), + ('approximationTheoryConstructInterpolationNode', 'Approximation Theory', '(*args)', 'Construct a interpolation node from explicit inputs for Approximation Theory.', 'professional_function_catalog.md'), + ('approximationTheoryConstructOrthogonalPolynomial', 'Approximation Theory', '(*args)', 'Construct a orthogonal polynomial from explicit inputs for Approximation Theory.', 'professional_function_catalog.md'), + ('approximationTheoryDecomposeApproximant', 'Approximation Theory', '(value)', 'Decompose a approximant into simpler or canonical components.', 'professional_function_catalog.md'), + ('approximationTheoryDecomposeApproximationError', 'Approximation Theory', '(value)', 'Decompose a approximation error into simpler or canonical components.', 'professional_function_catalog.md'), + ('approximationTheoryDecomposeBasisCoefficient', 'Approximation Theory', '(value)', 'Decompose a basis coefficient into simpler or canonical components.', 'professional_function_catalog.md'), + ('approximationTheoryDecomposeInterpolationNode', 'Approximation Theory', '(value)', 'Decompose a interpolation node into simpler or canonical components.', 'professional_function_catalog.md'), + ('approximationTheoryDecomposeOrthogonalPolynomial', 'Approximation Theory', '(value)', 'Decompose a orthogonal polynomial into simpler or canonical components.', 'professional_function_catalog.md'), + ('approximationTheoryDocumentApproximant', 'Approximation Theory', '(value)', 'Return a structured explanation of a approximant and related assumptions.', 'professional_function_catalog.md'), + ('approximationTheoryDocumentApproximationError', 'Approximation Theory', '(value)', 'Return a structured explanation of a approximation error and related assumptions.', 'professional_function_catalog.md'), + ('approximationTheoryDocumentBasisCoefficient', 'Approximation Theory', '(value)', 'Return a structured explanation of a basis coefficient and related assumptions.', 'professional_function_catalog.md'), + ('approximationTheoryDocumentInterpolationNode', 'Approximation Theory', '(value)', 'Return a structured explanation of a interpolation node and related assumptions.', 'professional_function_catalog.md'), + ('approximationTheoryDocumentOrthogonalPolynomial', 'Approximation Theory', '(value)', 'Return a structured explanation of a orthogonal polynomial and related assumptions.', 'professional_function_catalog.md'), + ('approximationTheoryEnumerateApproximant', 'Approximation Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a approximant.', 'professional_function_catalog.md'), + ('approximationTheoryEnumerateApproximationError', 'Approximation Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a approximation error.', 'professional_function_catalog.md'), + ('approximationTheoryEnumerateBasisCoefficient', 'Approximation Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a basis coefficient.', 'professional_function_catalog.md'), + ('approximationTheoryEnumerateInterpolationNode', 'Approximation Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a interpolation node.', 'professional_function_catalog.md'), + ('approximationTheoryEnumerateOrthogonalPolynomial', 'Approximation Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a orthogonal polynomial.', 'professional_function_catalog.md'), + ('approximationTheoryEstimateApproximant', 'Approximation Theory', '(value, samples=None)', 'Estimate a approximant property from finite samples or approximations.', 'professional_function_catalog.md'), + ('approximationTheoryEstimateApproximationError', 'Approximation Theory', '(value, samples=None)', 'Estimate a approximation error property from finite samples or approximations.', 'professional_function_catalog.md'), + ('approximationTheoryEstimateBasisCoefficient', 'Approximation Theory', '(value, samples=None)', 'Estimate a basis coefficient property from finite samples or approximations.', 'professional_function_catalog.md'), + ('approximationTheoryEstimateInterpolationNode', 'Approximation Theory', '(value, samples=None)', 'Estimate a interpolation node property from finite samples or approximations.', 'professional_function_catalog.md'), + ('approximationTheoryEstimateOrthogonalPolynomial', 'Approximation Theory', '(value, samples=None)', 'Estimate a orthogonal polynomial property from finite samples or approximations.', 'professional_function_catalog.md'), + ('approximationTheoryEvaluateApproximant', 'Approximation Theory', '(value, point=None)', 'Evaluate a approximant at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('approximationTheoryEvaluateApproximationError', 'Approximation Theory', '(value, point=None)', 'Evaluate a approximation error at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('approximationTheoryEvaluateBasisCoefficient', 'Approximation Theory', '(value, point=None)', 'Evaluate a basis coefficient at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('approximationTheoryEvaluateInterpolationNode', 'Approximation Theory', '(value, point=None)', 'Evaluate a interpolation node at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('approximationTheoryEvaluateOrthogonalPolynomial', 'Approximation Theory', '(value, point=None)', 'Evaluate a orthogonal polynomial at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('approximationTheoryFormatApproximant', 'Approximation Theory', '(value)', 'Format a approximant for deterministic user-facing output.', 'professional_function_catalog.md'), + ('approximationTheoryFormatApproximationError', 'Approximation Theory', '(value)', 'Format a approximation error for deterministic user-facing output.', 'professional_function_catalog.md'), + ('approximationTheoryFormatBasisCoefficient', 'Approximation Theory', '(value)', 'Format a basis coefficient for deterministic user-facing output.', 'professional_function_catalog.md'), + ('approximationTheoryFormatInterpolationNode', 'Approximation Theory', '(value)', 'Format a interpolation node for deterministic user-facing output.', 'professional_function_catalog.md'), + ('approximationTheoryFormatOrthogonalPolynomial', 'Approximation Theory', '(value)', 'Format a orthogonal polynomial for deterministic user-facing output.', 'professional_function_catalog.md'), + ('approximationTheoryGenerateExampleApproximant', 'Approximation Theory', '(size=3)', 'Generate a small documented example of a approximant.', 'professional_function_catalog.md'), + ('approximationTheoryGenerateExampleApproximationError', 'Approximation Theory', '(size=3)', 'Generate a small documented example of a approximation error.', 'professional_function_catalog.md'), + ('approximationTheoryGenerateExampleBasisCoefficient', 'Approximation Theory', '(size=3)', 'Generate a small documented example of a basis coefficient.', 'professional_function_catalog.md'), + ('approximationTheoryGenerateExampleInterpolationNode', 'Approximation Theory', '(size=3)', 'Generate a small documented example of a interpolation node.', 'professional_function_catalog.md'), + ('approximationTheoryGenerateExampleOrthogonalPolynomial', 'Approximation Theory', '(size=3)', 'Generate a small documented example of a orthogonal polynomial.', 'professional_function_catalog.md'), + ('approximationTheoryNormalizeApproximant', 'Approximation Theory', '(value)', 'Normalize a approximant into the standard Approximation Theory representation.', 'professional_function_catalog.md'), + ('approximationTheoryNormalizeApproximationError', 'Approximation Theory', '(value)', 'Normalize a approximation error into the standard Approximation Theory representation.', 'professional_function_catalog.md'), + ('approximationTheoryNormalizeBasisCoefficient', 'Approximation Theory', '(value)', 'Normalize a basis coefficient into the standard Approximation Theory representation.', 'professional_function_catalog.md'), + ('approximationTheoryNormalizeInterpolationNode', 'Approximation Theory', '(value)', 'Normalize a interpolation node into the standard Approximation Theory representation.', 'professional_function_catalog.md'), + ('approximationTheoryNormalizeOrthogonalPolynomial', 'Approximation Theory', '(value)', 'Normalize a orthogonal polynomial into the standard Approximation Theory representation.', 'professional_function_catalog.md'), + ('approximationTheoryParseApproximant', 'Approximation Theory', '(text)', 'Parse a text or structured value into a approximant.', 'professional_function_catalog.md'), + ('approximationTheoryParseApproximationError', 'Approximation Theory', '(text)', 'Parse a text or structured value into a approximation error.', 'professional_function_catalog.md'), + ('approximationTheoryParseBasisCoefficient', 'Approximation Theory', '(text)', 'Parse a text or structured value into a basis coefficient.', 'professional_function_catalog.md'), + ('approximationTheoryParseInterpolationNode', 'Approximation Theory', '(text)', 'Parse a text or structured value into a interpolation node.', 'professional_function_catalog.md'), + ('approximationTheoryParseOrthogonalPolynomial', 'Approximation Theory', '(text)', 'Parse a text or structured value into a orthogonal polynomial.', 'professional_function_catalog.md'), + ('approximationTheorySimplifyApproximant', 'Approximation Theory', '(value)', 'Simplify a approximant without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('approximationTheorySimplifyApproximationError', 'Approximation Theory', '(value)', 'Simplify a approximation error without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('approximationTheorySimplifyBasisCoefficient', 'Approximation Theory', '(value)', 'Simplify a basis coefficient without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('approximationTheorySimplifyInterpolationNode', 'Approximation Theory', '(value)', 'Simplify a interpolation node without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('approximationTheorySimplifyOrthogonalPolynomial', 'Approximation Theory', '(value)', 'Simplify a orthogonal polynomial without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('approximationTheoryTestEquivalenceApproximant', 'Approximation Theory', '(left, right)', 'Test whether two approximant values are equivalent in Approximation Theory.', 'professional_function_catalog.md'), + ('approximationTheoryTestEquivalenceApproximationError', 'Approximation Theory', '(left, right)', 'Test whether two approximation error values are equivalent in Approximation Theory.', 'professional_function_catalog.md'), + ('approximationTheoryTestEquivalenceBasisCoefficient', 'Approximation Theory', '(left, right)', 'Test whether two basis coefficient values are equivalent in Approximation Theory.', 'professional_function_catalog.md'), + ('approximationTheoryTestEquivalenceInterpolationNode', 'Approximation Theory', '(left, right)', 'Test whether two interpolation node values are equivalent in Approximation Theory.', 'professional_function_catalog.md'), + ('approximationTheoryTestEquivalenceOrthogonalPolynomial', 'Approximation Theory', '(left, right)', 'Test whether two orthogonal polynomial values are equivalent in Approximation Theory.', 'professional_function_catalog.md'), + ('approximationTheoryTransformApproximant', 'Approximation Theory', '(value, mapping)', 'Transform a approximant through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('approximationTheoryTransformApproximationError', 'Approximation Theory', '(value, mapping)', 'Transform a approximation error through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('approximationTheoryTransformBasisCoefficient', 'Approximation Theory', '(value, mapping)', 'Transform a basis coefficient through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('approximationTheoryTransformInterpolationNode', 'Approximation Theory', '(value, mapping)', 'Transform a interpolation node through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('approximationTheoryTransformOrthogonalPolynomial', 'Approximation Theory', '(value, mapping)', 'Transform a orthogonal polynomial through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('approximationTheoryValidateApproximant', 'Approximation Theory', '(value)', 'Validate the approximant representation and domain rules for Approximation Theory.', 'professional_function_catalog.md'), + ('approximationTheoryValidateApproximationError', 'Approximation Theory', '(value)', 'Validate the approximation error representation and domain rules for Approximation Theory.', 'professional_function_catalog.md'), + ('approximationTheoryValidateBasisCoefficient', 'Approximation Theory', '(value)', 'Validate the basis coefficient representation and domain rules for Approximation Theory.', 'professional_function_catalog.md'), + ('approximationTheoryValidateInterpolationNode', 'Approximation Theory', '(value)', 'Validate the interpolation node representation and domain rules for Approximation Theory.', 'professional_function_catalog.md'), + ('approximationTheoryValidateOrthogonalPolynomial', 'Approximation Theory', '(value)', 'Validate the orthogonal polynomial representation and domain rules for Approximation Theory.', 'professional_function_catalog.md'), + ('bernsteinPolynomial', 'Approximation Theory', '(fValues, n, x)', 'Planned roadmap function for Approximation Theory from upcoming.md.', 'upcoming.md'), + ('chebyshevNodes', 'Approximation Theory', '(a, b, n)', 'Planned roadmap function for Approximation Theory from upcoming.md.', 'upcoming.md'), + ('chebyshevPolynomial', 'Approximation Theory', '(n, x)', 'Planned roadmap function for Approximation Theory from upcoming.md.', 'upcoming.md'), + ('leastSquaresPolynomial', 'Approximation Theory', '(points, degree)', 'Planned roadmap function for Approximation Theory from upcoming.md.', 'upcoming.md'), + ('legendrePolynomial', 'Approximation Theory', '(n, x)', 'Planned roadmap function for Approximation Theory from upcoming.md.', 'upcoming.md'), + ('minimaxApproximationStep', 'Approximation Theory', '(f, degree, points)', 'Planned roadmap function for Approximation Theory from upcoming.md.', 'upcoming.md'), + ('piecewiseLinearApproximation', 'Approximation Theory', '(points, x)', 'Planned roadmap function for Approximation Theory from upcoming.md.', 'upcoming.md'), + ('arithmeticApproximateBinaryOperation', 'Arithmetic', '(value, tolerance=1e-9)', 'Approximate a binary operation with explicit tolerance controls.', 'professional_function_catalog.md'), + ('arithmeticApproximateBoundedInterval', 'Arithmetic', '(value, tolerance=1e-9)', 'Approximate a bounded interval with explicit tolerance controls.', 'professional_function_catalog.md'), + ('arithmeticApproximateNumericSequence', 'Arithmetic', '(value, tolerance=1e-9)', 'Approximate a numeric sequence with explicit tolerance controls.', 'professional_function_catalog.md'), + ('arithmeticApproximateRatioExpression', 'Arithmetic', '(value, tolerance=1e-9)', 'Approximate a ratio expression with explicit tolerance controls.', 'professional_function_catalog.md'), + ('arithmeticApproximateRoundingRule', 'Arithmetic', '(value, tolerance=1e-9)', 'Approximate a rounding rule with explicit tolerance controls.', 'professional_function_catalog.md'), + ('arithmeticCanonicalizeBinaryOperation', 'Arithmetic', '(value)', 'Canonicalize a binary operation so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('arithmeticCanonicalizeBoundedInterval', 'Arithmetic', '(value)', 'Canonicalize a bounded interval so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('arithmeticCanonicalizeNumericSequence', 'Arithmetic', '(value)', 'Canonicalize a numeric sequence so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('arithmeticCanonicalizeRatioExpression', 'Arithmetic', '(value)', 'Canonicalize a ratio expression so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('arithmeticCanonicalizeRoundingRule', 'Arithmetic', '(value)', 'Canonicalize a rounding rule so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('arithmeticClassifyBinaryOperation', 'Arithmetic', '(value)', 'Classify a binary operation by its standard Arithmetic invariants.', 'professional_function_catalog.md'), + ('arithmeticClassifyBoundedInterval', 'Arithmetic', '(value)', 'Classify a bounded interval by its standard Arithmetic invariants.', 'professional_function_catalog.md'), + ('arithmeticClassifyNumericSequence', 'Arithmetic', '(value)', 'Classify a numeric sequence by its standard Arithmetic invariants.', 'professional_function_catalog.md'), + ('arithmeticClassifyRatioExpression', 'Arithmetic', '(value)', 'Classify a ratio expression by its standard Arithmetic invariants.', 'professional_function_catalog.md'), + ('arithmeticClassifyRoundingRule', 'Arithmetic', '(value)', 'Classify a rounding rule by its standard Arithmetic invariants.', 'professional_function_catalog.md'), + ('arithmeticCombineBinaryOperation', 'Arithmetic', '(left, right)', 'Combine two binary operation values with the natural operation for Arithmetic.', 'professional_function_catalog.md'), + ('arithmeticCombineBoundedInterval', 'Arithmetic', '(left, right)', 'Combine two bounded interval values with the natural operation for Arithmetic.', 'professional_function_catalog.md'), + ('arithmeticCombineNumericSequence', 'Arithmetic', '(left, right)', 'Combine two numeric sequence values with the natural operation for Arithmetic.', 'professional_function_catalog.md'), + ('arithmeticCombineRatioExpression', 'Arithmetic', '(left, right)', 'Combine two ratio expression values with the natural operation for Arithmetic.', 'professional_function_catalog.md'), + ('arithmeticCombineRoundingRule', 'Arithmetic', '(left, right)', 'Combine two rounding rule values with the natural operation for Arithmetic.', 'professional_function_catalog.md'), + ('arithmeticCompareBinaryOperation', 'Arithmetic', '(left, right)', 'Compare two binary operation values under the conventions of Arithmetic.', 'professional_function_catalog.md'), + ('arithmeticCompareBoundedInterval', 'Arithmetic', '(left, right)', 'Compare two bounded interval values under the conventions of Arithmetic.', 'professional_function_catalog.md'), + ('arithmeticCompareNumericSequence', 'Arithmetic', '(left, right)', 'Compare two numeric sequence values under the conventions of Arithmetic.', 'professional_function_catalog.md'), + ('arithmeticCompareRatioExpression', 'Arithmetic', '(left, right)', 'Compare two ratio expression values under the conventions of Arithmetic.', 'professional_function_catalog.md'), + ('arithmeticCompareRoundingRule', 'Arithmetic', '(left, right)', 'Compare two rounding rule values under the conventions of Arithmetic.', 'professional_function_catalog.md'), + ('arithmeticComputeBinaryOperation', 'Arithmetic', '(value)', 'Compute the central numerical or symbolic data of a binary operation.', 'professional_function_catalog.md'), + ('arithmeticComputeBoundedInterval', 'Arithmetic', '(value)', 'Compute the central numerical or symbolic data of a bounded interval.', 'professional_function_catalog.md'), + ('arithmeticComputeNumericSequence', 'Arithmetic', '(value)', 'Compute the central numerical or symbolic data of a numeric sequence.', 'professional_function_catalog.md'), + ('arithmeticComputeRatioExpression', 'Arithmetic', '(value)', 'Compute the central numerical or symbolic data of a ratio expression.', 'professional_function_catalog.md'), + ('arithmeticComputeRoundingRule', 'Arithmetic', '(value)', 'Compute the central numerical or symbolic data of a rounding rule.', 'professional_function_catalog.md'), + ('arithmeticConstructBinaryOperation', 'Arithmetic', '(*args)', 'Construct a binary operation from explicit inputs for Arithmetic.', 'professional_function_catalog.md'), + ('arithmeticConstructBoundedInterval', 'Arithmetic', '(*args)', 'Construct a bounded interval from explicit inputs for Arithmetic.', 'professional_function_catalog.md'), + ('arithmeticConstructNumericSequence', 'Arithmetic', '(*args)', 'Construct a numeric sequence from explicit inputs for Arithmetic.', 'professional_function_catalog.md'), + ('arithmeticConstructRatioExpression', 'Arithmetic', '(*args)', 'Construct a ratio expression from explicit inputs for Arithmetic.', 'professional_function_catalog.md'), + ('arithmeticConstructRoundingRule', 'Arithmetic', '(*args)', 'Construct a rounding rule from explicit inputs for Arithmetic.', 'professional_function_catalog.md'), + ('arithmeticDecomposeBinaryOperation', 'Arithmetic', '(value)', 'Decompose a binary operation into simpler or canonical components.', 'professional_function_catalog.md'), + ('arithmeticDecomposeBoundedInterval', 'Arithmetic', '(value)', 'Decompose a bounded interval into simpler or canonical components.', 'professional_function_catalog.md'), + ('arithmeticDecomposeNumericSequence', 'Arithmetic', '(value)', 'Decompose a numeric sequence into simpler or canonical components.', 'professional_function_catalog.md'), + ('arithmeticDecomposeRatioExpression', 'Arithmetic', '(value)', 'Decompose a ratio expression into simpler or canonical components.', 'professional_function_catalog.md'), + ('arithmeticDecomposeRoundingRule', 'Arithmetic', '(value)', 'Decompose a rounding rule into simpler or canonical components.', 'professional_function_catalog.md'), + ('arithmeticDocumentBinaryOperation', 'Arithmetic', '(value)', 'Return a structured explanation of a binary operation and related assumptions.', 'professional_function_catalog.md'), + ('arithmeticDocumentBoundedInterval', 'Arithmetic', '(value)', 'Return a structured explanation of a bounded interval and related assumptions.', 'professional_function_catalog.md'), + ('arithmeticDocumentNumericSequence', 'Arithmetic', '(value)', 'Return a structured explanation of a numeric sequence and related assumptions.', 'professional_function_catalog.md'), + ('arithmeticDocumentRatioExpression', 'Arithmetic', '(value)', 'Return a structured explanation of a ratio expression and related assumptions.', 'professional_function_catalog.md'), + ('arithmeticDocumentRoundingRule', 'Arithmetic', '(value)', 'Return a structured explanation of a rounding rule and related assumptions.', 'professional_function_catalog.md'), + ('arithmeticEnumerateBinaryOperation', 'Arithmetic', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a binary operation.', 'professional_function_catalog.md'), + ('arithmeticEnumerateBoundedInterval', 'Arithmetic', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a bounded interval.', 'professional_function_catalog.md'), + ('arithmeticEnumerateNumericSequence', 'Arithmetic', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a numeric sequence.', 'professional_function_catalog.md'), + ('arithmeticEnumerateRatioExpression', 'Arithmetic', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a ratio expression.', 'professional_function_catalog.md'), + ('arithmeticEnumerateRoundingRule', 'Arithmetic', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a rounding rule.', 'professional_function_catalog.md'), + ('arithmeticEstimateBinaryOperation', 'Arithmetic', '(value, samples=None)', 'Estimate a binary operation property from finite samples or approximations.', 'professional_function_catalog.md'), + ('arithmeticEstimateBoundedInterval', 'Arithmetic', '(value, samples=None)', 'Estimate a bounded interval property from finite samples or approximations.', 'professional_function_catalog.md'), + ('arithmeticEstimateNumericSequence', 'Arithmetic', '(value, samples=None)', 'Estimate a numeric sequence property from finite samples or approximations.', 'professional_function_catalog.md'), + ('arithmeticEstimateRatioExpression', 'Arithmetic', '(value, samples=None)', 'Estimate a ratio expression property from finite samples or approximations.', 'professional_function_catalog.md'), + ('arithmeticEstimateRoundingRule', 'Arithmetic', '(value, samples=None)', 'Estimate a rounding rule property from finite samples or approximations.', 'professional_function_catalog.md'), + ('arithmeticEvaluateBinaryOperation', 'Arithmetic', '(value, point=None)', 'Evaluate a binary operation at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('arithmeticEvaluateBoundedInterval', 'Arithmetic', '(value, point=None)', 'Evaluate a bounded interval at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('arithmeticEvaluateNumericSequence', 'Arithmetic', '(value, point=None)', 'Evaluate a numeric sequence at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('arithmeticEvaluateRatioExpression', 'Arithmetic', '(value, point=None)', 'Evaluate a ratio expression at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('arithmeticEvaluateRoundingRule', 'Arithmetic', '(value, point=None)', 'Evaluate a rounding rule at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('arithmeticFormatBinaryOperation', 'Arithmetic', '(value)', 'Format a binary operation for deterministic user-facing output.', 'professional_function_catalog.md'), + ('arithmeticFormatBoundedInterval', 'Arithmetic', '(value)', 'Format a bounded interval for deterministic user-facing output.', 'professional_function_catalog.md'), + ('arithmeticFormatNumericSequence', 'Arithmetic', '(value)', 'Format a numeric sequence for deterministic user-facing output.', 'professional_function_catalog.md'), + ('arithmeticFormatRatioExpression', 'Arithmetic', '(value)', 'Format a ratio expression for deterministic user-facing output.', 'professional_function_catalog.md'), + ('arithmeticFormatRoundingRule', 'Arithmetic', '(value)', 'Format a rounding rule for deterministic user-facing output.', 'professional_function_catalog.md'), + ('arithmeticGenerateExampleBinaryOperation', 'Arithmetic', '(size=3)', 'Generate a small documented example of a binary operation.', 'professional_function_catalog.md'), + ('arithmeticGenerateExampleBoundedInterval', 'Arithmetic', '(size=3)', 'Generate a small documented example of a bounded interval.', 'professional_function_catalog.md'), + ('arithmeticGenerateExampleNumericSequence', 'Arithmetic', '(size=3)', 'Generate a small documented example of a numeric sequence.', 'professional_function_catalog.md'), + ('arithmeticGenerateExampleRatioExpression', 'Arithmetic', '(size=3)', 'Generate a small documented example of a ratio expression.', 'professional_function_catalog.md'), + ('arithmeticGenerateExampleRoundingRule', 'Arithmetic', '(size=3)', 'Generate a small documented example of a rounding rule.', 'professional_function_catalog.md'), + ('arithmeticNormalizeBinaryOperation', 'Arithmetic', '(value)', 'Normalize a binary operation into the standard Arithmetic representation.', 'professional_function_catalog.md'), + ('arithmeticNormalizeBoundedInterval', 'Arithmetic', '(value)', 'Normalize a bounded interval into the standard Arithmetic representation.', 'professional_function_catalog.md'), + ('arithmeticNormalizeNumericSequence', 'Arithmetic', '(value)', 'Normalize a numeric sequence into the standard Arithmetic representation.', 'professional_function_catalog.md'), + ('arithmeticNormalizeRatioExpression', 'Arithmetic', '(value)', 'Normalize a ratio expression into the standard Arithmetic representation.', 'professional_function_catalog.md'), + ('arithmeticNormalizeRoundingRule', 'Arithmetic', '(value)', 'Normalize a rounding rule into the standard Arithmetic representation.', 'professional_function_catalog.md'), + ('arithmeticParseBinaryOperation', 'Arithmetic', '(text)', 'Parse a text or structured value into a binary operation.', 'professional_function_catalog.md'), + ('arithmeticParseBoundedInterval', 'Arithmetic', '(text)', 'Parse a text or structured value into a bounded interval.', 'professional_function_catalog.md'), + ('arithmeticParseNumericSequence', 'Arithmetic', '(text)', 'Parse a text or structured value into a numeric sequence.', 'professional_function_catalog.md'), + ('arithmeticParseRatioExpression', 'Arithmetic', '(text)', 'Parse a text or structured value into a ratio expression.', 'professional_function_catalog.md'), + ('arithmeticParseRoundingRule', 'Arithmetic', '(text)', 'Parse a text or structured value into a rounding rule.', 'professional_function_catalog.md'), + ('arithmeticSimplifyBinaryOperation', 'Arithmetic', '(value)', 'Simplify a binary operation without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('arithmeticSimplifyBoundedInterval', 'Arithmetic', '(value)', 'Simplify a bounded interval without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('arithmeticSimplifyNumericSequence', 'Arithmetic', '(value)', 'Simplify a numeric sequence without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('arithmeticSimplifyRatioExpression', 'Arithmetic', '(value)', 'Simplify a ratio expression without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('arithmeticSimplifyRoundingRule', 'Arithmetic', '(value)', 'Simplify a rounding rule without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('arithmeticTestEquivalenceBinaryOperation', 'Arithmetic', '(left, right)', 'Test whether two binary operation values are equivalent in Arithmetic.', 'professional_function_catalog.md'), + ('arithmeticTestEquivalenceBoundedInterval', 'Arithmetic', '(left, right)', 'Test whether two bounded interval values are equivalent in Arithmetic.', 'professional_function_catalog.md'), + ('arithmeticTestEquivalenceNumericSequence', 'Arithmetic', '(left, right)', 'Test whether two numeric sequence values are equivalent in Arithmetic.', 'professional_function_catalog.md'), + ('arithmeticTestEquivalenceRatioExpression', 'Arithmetic', '(left, right)', 'Test whether two ratio expression values are equivalent in Arithmetic.', 'professional_function_catalog.md'), + ('arithmeticTestEquivalenceRoundingRule', 'Arithmetic', '(left, right)', 'Test whether two rounding rule values are equivalent in Arithmetic.', 'professional_function_catalog.md'), + ('arithmeticTransformBinaryOperation', 'Arithmetic', '(value, mapping)', 'Transform a binary operation through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('arithmeticTransformBoundedInterval', 'Arithmetic', '(value, mapping)', 'Transform a bounded interval through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('arithmeticTransformNumericSequence', 'Arithmetic', '(value, mapping)', 'Transform a numeric sequence through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('arithmeticTransformRatioExpression', 'Arithmetic', '(value, mapping)', 'Transform a ratio expression through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('arithmeticTransformRoundingRule', 'Arithmetic', '(value, mapping)', 'Transform a rounding rule through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('arithmeticValidateBinaryOperation', 'Arithmetic', '(value)', 'Validate the binary operation representation and domain rules for Arithmetic.', 'professional_function_catalog.md'), + ('arithmeticValidateBoundedInterval', 'Arithmetic', '(value)', 'Validate the bounded interval representation and domain rules for Arithmetic.', 'professional_function_catalog.md'), + ('arithmeticValidateNumericSequence', 'Arithmetic', '(value)', 'Validate the numeric sequence representation and domain rules for Arithmetic.', 'professional_function_catalog.md'), + ('arithmeticValidateRatioExpression', 'Arithmetic', '(value)', 'Validate the ratio expression representation and domain rules for Arithmetic.', 'professional_function_catalog.md'), + ('arithmeticValidateRoundingRule', 'Arithmetic', '(value)', 'Validate the rounding rule representation and domain rules for Arithmetic.', 'professional_function_catalog.md'), + ('averageRateOfChange', 'Arithmetic', '(f, a, b)', 'Planned roadmap function for Arithmetic from upcoming.md.', 'upcoming.md'), + ('clamp', 'Arithmetic', '(x, lower, upper)', 'Planned roadmap function for Arithmetic from upcoming.md.', 'upcoming.md'), + ('product', 'Arithmetic', '(arr)', 'Planned roadmap function for Arithmetic from upcoming.md.', 'upcoming.md'), + ('reciprocal', 'Arithmetic', '(x)', 'Planned roadmap function for Arithmetic from upcoming.md.', 'upcoming.md'), + ('sign', 'Arithmetic', '(x)', 'Planned roadmap function for Arithmetic from upcoming.md.', 'upcoming.md'), + ('summation', 'Arithmetic', '(arr)', 'Planned roadmap function for Arithmetic from upcoming.md.', 'upcoming.md'), + ('arithmeticGeometryApproximateCurveReduction', 'Arithmetic Geometry', '(value, tolerance=1e-9)', 'Approximate a curve reduction with explicit tolerance controls.', 'professional_function_catalog.md'), + ('arithmeticGeometryApproximateEllipticCurve', 'Arithmetic Geometry', '(value, tolerance=1e-9)', 'Approximate a elliptic curve with explicit tolerance controls.', 'professional_function_catalog.md'), + ('arithmeticGeometryApproximateFiniteFieldPoint', 'Arithmetic Geometry', '(value, tolerance=1e-9)', 'Approximate a finite field point with explicit tolerance controls.', 'professional_function_catalog.md'), + ('arithmeticGeometryApproximateHeightFunction', 'Arithmetic Geometry', '(value, tolerance=1e-9)', 'Approximate a height function with explicit tolerance controls.', 'professional_function_catalog.md'), + ('arithmeticGeometryApproximateRationalPoint', 'Arithmetic Geometry', '(value, tolerance=1e-9)', 'Approximate a rational point with explicit tolerance controls.', 'professional_function_catalog.md'), + ('arithmeticGeometryCanonicalizeCurveReduction', 'Arithmetic Geometry', '(value)', 'Canonicalize a curve reduction so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('arithmeticGeometryCanonicalizeEllipticCurve', 'Arithmetic Geometry', '(value)', 'Canonicalize a elliptic curve so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('arithmeticGeometryCanonicalizeFiniteFieldPoint', 'Arithmetic Geometry', '(value)', 'Canonicalize a finite field point so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('arithmeticGeometryCanonicalizeHeightFunction', 'Arithmetic Geometry', '(value)', 'Canonicalize a height function so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('arithmeticGeometryCanonicalizeRationalPoint', 'Arithmetic Geometry', '(value)', 'Canonicalize a rational point so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('arithmeticGeometryClassifyCurveReduction', 'Arithmetic Geometry', '(value)', 'Classify a curve reduction by its standard Arithmetic Geometry invariants.', 'professional_function_catalog.md'), + ('arithmeticGeometryClassifyEllipticCurve', 'Arithmetic Geometry', '(value)', 'Classify a elliptic curve by its standard Arithmetic Geometry invariants.', 'professional_function_catalog.md'), + ('arithmeticGeometryClassifyFiniteFieldPoint', 'Arithmetic Geometry', '(value)', 'Classify a finite field point by its standard Arithmetic Geometry invariants.', 'professional_function_catalog.md'), + ('arithmeticGeometryClassifyHeightFunction', 'Arithmetic Geometry', '(value)', 'Classify a height function by its standard Arithmetic Geometry invariants.', 'professional_function_catalog.md'), + ('arithmeticGeometryClassifyRationalPoint', 'Arithmetic Geometry', '(value)', 'Classify a rational point by its standard Arithmetic Geometry invariants.', 'professional_function_catalog.md'), + ('arithmeticGeometryCombineCurveReduction', 'Arithmetic Geometry', '(left, right)', 'Combine two curve reduction values with the natural operation for Arithmetic Geometry.', 'professional_function_catalog.md'), + ('arithmeticGeometryCombineEllipticCurve', 'Arithmetic Geometry', '(left, right)', 'Combine two elliptic curve values with the natural operation for Arithmetic Geometry.', 'professional_function_catalog.md'), + ('arithmeticGeometryCombineFiniteFieldPoint', 'Arithmetic Geometry', '(left, right)', 'Combine two finite field point values with the natural operation for Arithmetic Geometry.', 'professional_function_catalog.md'), + ('arithmeticGeometryCombineHeightFunction', 'Arithmetic Geometry', '(left, right)', 'Combine two height function values with the natural operation for Arithmetic Geometry.', 'professional_function_catalog.md'), + ('arithmeticGeometryCombineRationalPoint', 'Arithmetic Geometry', '(left, right)', 'Combine two rational point values with the natural operation for Arithmetic Geometry.', 'professional_function_catalog.md'), + ('arithmeticGeometryCompareCurveReduction', 'Arithmetic Geometry', '(left, right)', 'Compare two curve reduction values under the conventions of Arithmetic Geometry.', 'professional_function_catalog.md'), + ('arithmeticGeometryCompareEllipticCurve', 'Arithmetic Geometry', '(left, right)', 'Compare two elliptic curve values under the conventions of Arithmetic Geometry.', 'professional_function_catalog.md'), + ('arithmeticGeometryCompareFiniteFieldPoint', 'Arithmetic Geometry', '(left, right)', 'Compare two finite field point values under the conventions of Arithmetic Geometry.', 'professional_function_catalog.md'), + ('arithmeticGeometryCompareHeightFunction', 'Arithmetic Geometry', '(left, right)', 'Compare two height function values under the conventions of Arithmetic Geometry.', 'professional_function_catalog.md'), + ('arithmeticGeometryCompareRationalPoint', 'Arithmetic Geometry', '(left, right)', 'Compare two rational point values under the conventions of Arithmetic Geometry.', 'professional_function_catalog.md'), + ('arithmeticGeometryComputeCurveReduction', 'Arithmetic Geometry', '(value)', 'Compute the central numerical or symbolic data of a curve reduction.', 'professional_function_catalog.md'), + ('arithmeticGeometryComputeEllipticCurve', 'Arithmetic Geometry', '(value)', 'Compute the central numerical or symbolic data of a elliptic curve.', 'professional_function_catalog.md'), + ('arithmeticGeometryComputeFiniteFieldPoint', 'Arithmetic Geometry', '(value)', 'Compute the central numerical or symbolic data of a finite field point.', 'professional_function_catalog.md'), + ('arithmeticGeometryComputeHeightFunction', 'Arithmetic Geometry', '(value)', 'Compute the central numerical or symbolic data of a height function.', 'professional_function_catalog.md'), + ('arithmeticGeometryComputeRationalPoint', 'Arithmetic Geometry', '(value)', 'Compute the central numerical or symbolic data of a rational point.', 'professional_function_catalog.md'), + ('arithmeticGeometryConstructCurveReduction', 'Arithmetic Geometry', '(*args)', 'Construct a curve reduction from explicit inputs for Arithmetic Geometry.', 'professional_function_catalog.md'), + ('arithmeticGeometryConstructEllipticCurve', 'Arithmetic Geometry', '(*args)', 'Construct a elliptic curve from explicit inputs for Arithmetic Geometry.', 'professional_function_catalog.md'), + ('arithmeticGeometryConstructFiniteFieldPoint', 'Arithmetic Geometry', '(*args)', 'Construct a finite field point from explicit inputs for Arithmetic Geometry.', 'professional_function_catalog.md'), + ('arithmeticGeometryConstructHeightFunction', 'Arithmetic Geometry', '(*args)', 'Construct a height function from explicit inputs for Arithmetic Geometry.', 'professional_function_catalog.md'), + ('arithmeticGeometryConstructRationalPoint', 'Arithmetic Geometry', '(*args)', 'Construct a rational point from explicit inputs for Arithmetic Geometry.', 'professional_function_catalog.md'), + ('arithmeticGeometryDecomposeCurveReduction', 'Arithmetic Geometry', '(value)', 'Decompose a curve reduction into simpler or canonical components.', 'professional_function_catalog.md'), + ('arithmeticGeometryDecomposeEllipticCurve', 'Arithmetic Geometry', '(value)', 'Decompose a elliptic curve into simpler or canonical components.', 'professional_function_catalog.md'), + ('arithmeticGeometryDecomposeFiniteFieldPoint', 'Arithmetic Geometry', '(value)', 'Decompose a finite field point into simpler or canonical components.', 'professional_function_catalog.md'), + ('arithmeticGeometryDecomposeHeightFunction', 'Arithmetic Geometry', '(value)', 'Decompose a height function into simpler or canonical components.', 'professional_function_catalog.md'), + ('arithmeticGeometryDecomposeRationalPoint', 'Arithmetic Geometry', '(value)', 'Decompose a rational point into simpler or canonical components.', 'professional_function_catalog.md'), + ('arithmeticGeometryDocumentCurveReduction', 'Arithmetic Geometry', '(value)', 'Return a structured explanation of a curve reduction and related assumptions.', 'professional_function_catalog.md'), + ('arithmeticGeometryDocumentEllipticCurve', 'Arithmetic Geometry', '(value)', 'Return a structured explanation of a elliptic curve and related assumptions.', 'professional_function_catalog.md'), + ('arithmeticGeometryDocumentFiniteFieldPoint', 'Arithmetic Geometry', '(value)', 'Return a structured explanation of a finite field point and related assumptions.', 'professional_function_catalog.md'), + ('arithmeticGeometryDocumentHeightFunction', 'Arithmetic Geometry', '(value)', 'Return a structured explanation of a height function and related assumptions.', 'professional_function_catalog.md'), + ('arithmeticGeometryDocumentRationalPoint', 'Arithmetic Geometry', '(value)', 'Return a structured explanation of a rational point and related assumptions.', 'professional_function_catalog.md'), + ('arithmeticGeometryEnumerateCurveReduction', 'Arithmetic Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a curve reduction.', 'professional_function_catalog.md'), + ('arithmeticGeometryEnumerateEllipticCurve', 'Arithmetic Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a elliptic curve.', 'professional_function_catalog.md'), + ('arithmeticGeometryEnumerateFiniteFieldPoint', 'Arithmetic Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a finite field point.', 'professional_function_catalog.md'), + ('arithmeticGeometryEnumerateHeightFunction', 'Arithmetic Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a height function.', 'professional_function_catalog.md'), + ('arithmeticGeometryEnumerateRationalPoint', 'Arithmetic Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a rational point.', 'professional_function_catalog.md'), + ('arithmeticGeometryEstimateCurveReduction', 'Arithmetic Geometry', '(value, samples=None)', 'Estimate a curve reduction property from finite samples or approximations.', 'professional_function_catalog.md'), + ('arithmeticGeometryEstimateEllipticCurve', 'Arithmetic Geometry', '(value, samples=None)', 'Estimate a elliptic curve property from finite samples or approximations.', 'professional_function_catalog.md'), + ('arithmeticGeometryEstimateFiniteFieldPoint', 'Arithmetic Geometry', '(value, samples=None)', 'Estimate a finite field point property from finite samples or approximations.', 'professional_function_catalog.md'), + ('arithmeticGeometryEstimateHeightFunction', 'Arithmetic Geometry', '(value, samples=None)', 'Estimate a height function property from finite samples or approximations.', 'professional_function_catalog.md'), + ('arithmeticGeometryEstimateRationalPoint', 'Arithmetic Geometry', '(value, samples=None)', 'Estimate a rational point property from finite samples or approximations.', 'professional_function_catalog.md'), + ('arithmeticGeometryEvaluateCurveReduction', 'Arithmetic Geometry', '(value, point=None)', 'Evaluate a curve reduction at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('arithmeticGeometryEvaluateEllipticCurve', 'Arithmetic Geometry', '(value, point=None)', 'Evaluate a elliptic curve at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('arithmeticGeometryEvaluateFiniteFieldPoint', 'Arithmetic Geometry', '(value, point=None)', 'Evaluate a finite field point at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('arithmeticGeometryEvaluateHeightFunction', 'Arithmetic Geometry', '(value, point=None)', 'Evaluate a height function at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('arithmeticGeometryEvaluateRationalPoint', 'Arithmetic Geometry', '(value, point=None)', 'Evaluate a rational point at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('arithmeticGeometryFormatCurveReduction', 'Arithmetic Geometry', '(value)', 'Format a curve reduction for deterministic user-facing output.', 'professional_function_catalog.md'), + ('arithmeticGeometryFormatEllipticCurve', 'Arithmetic Geometry', '(value)', 'Format a elliptic curve for deterministic user-facing output.', 'professional_function_catalog.md'), + ('arithmeticGeometryFormatFiniteFieldPoint', 'Arithmetic Geometry', '(value)', 'Format a finite field point for deterministic user-facing output.', 'professional_function_catalog.md'), + ('arithmeticGeometryFormatHeightFunction', 'Arithmetic Geometry', '(value)', 'Format a height function for deterministic user-facing output.', 'professional_function_catalog.md'), + ('arithmeticGeometryFormatRationalPoint', 'Arithmetic Geometry', '(value)', 'Format a rational point for deterministic user-facing output.', 'professional_function_catalog.md'), + ('arithmeticGeometryGenerateExampleCurveReduction', 'Arithmetic Geometry', '(size=3)', 'Generate a small documented example of a curve reduction.', 'professional_function_catalog.md'), + ('arithmeticGeometryGenerateExampleEllipticCurve', 'Arithmetic Geometry', '(size=3)', 'Generate a small documented example of a elliptic curve.', 'professional_function_catalog.md'), + ('arithmeticGeometryGenerateExampleFiniteFieldPoint', 'Arithmetic Geometry', '(size=3)', 'Generate a small documented example of a finite field point.', 'professional_function_catalog.md'), + ('arithmeticGeometryGenerateExampleHeightFunction', 'Arithmetic Geometry', '(size=3)', 'Generate a small documented example of a height function.', 'professional_function_catalog.md'), + ('arithmeticGeometryGenerateExampleRationalPoint', 'Arithmetic Geometry', '(size=3)', 'Generate a small documented example of a rational point.', 'professional_function_catalog.md'), + ('arithmeticGeometryNormalizeCurveReduction', 'Arithmetic Geometry', '(value)', 'Normalize a curve reduction into the standard Arithmetic Geometry representation.', 'professional_function_catalog.md'), + ('arithmeticGeometryNormalizeEllipticCurve', 'Arithmetic Geometry', '(value)', 'Normalize a elliptic curve into the standard Arithmetic Geometry representation.', 'professional_function_catalog.md'), + ('arithmeticGeometryNormalizeFiniteFieldPoint', 'Arithmetic Geometry', '(value)', 'Normalize a finite field point into the standard Arithmetic Geometry representation.', 'professional_function_catalog.md'), + ('arithmeticGeometryNormalizeHeightFunction', 'Arithmetic Geometry', '(value)', 'Normalize a height function into the standard Arithmetic Geometry representation.', 'professional_function_catalog.md'), + ('arithmeticGeometryNormalizeRationalPoint', 'Arithmetic Geometry', '(value)', 'Normalize a rational point into the standard Arithmetic Geometry representation.', 'professional_function_catalog.md'), + ('arithmeticGeometryParseCurveReduction', 'Arithmetic Geometry', '(text)', 'Parse a text or structured value into a curve reduction.', 'professional_function_catalog.md'), + ('arithmeticGeometryParseEllipticCurve', 'Arithmetic Geometry', '(text)', 'Parse a text or structured value into a elliptic curve.', 'professional_function_catalog.md'), + ('arithmeticGeometryParseFiniteFieldPoint', 'Arithmetic Geometry', '(text)', 'Parse a text or structured value into a finite field point.', 'professional_function_catalog.md'), + ('arithmeticGeometryParseHeightFunction', 'Arithmetic Geometry', '(text)', 'Parse a text or structured value into a height function.', 'professional_function_catalog.md'), + ('arithmeticGeometryParseRationalPoint', 'Arithmetic Geometry', '(text)', 'Parse a text or structured value into a rational point.', 'professional_function_catalog.md'), + ('arithmeticGeometrySimplifyCurveReduction', 'Arithmetic Geometry', '(value)', 'Simplify a curve reduction without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('arithmeticGeometrySimplifyEllipticCurve', 'Arithmetic Geometry', '(value)', 'Simplify a elliptic curve without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('arithmeticGeometrySimplifyFiniteFieldPoint', 'Arithmetic Geometry', '(value)', 'Simplify a finite field point without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('arithmeticGeometrySimplifyHeightFunction', 'Arithmetic Geometry', '(value)', 'Simplify a height function without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('arithmeticGeometrySimplifyRationalPoint', 'Arithmetic Geometry', '(value)', 'Simplify a rational point without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('arithmeticGeometryTestEquivalenceCurveReduction', 'Arithmetic Geometry', '(left, right)', 'Test whether two curve reduction values are equivalent in Arithmetic Geometry.', 'professional_function_catalog.md'), + ('arithmeticGeometryTestEquivalenceEllipticCurve', 'Arithmetic Geometry', '(left, right)', 'Test whether two elliptic curve values are equivalent in Arithmetic Geometry.', 'professional_function_catalog.md'), + ('arithmeticGeometryTestEquivalenceFiniteFieldPoint', 'Arithmetic Geometry', '(left, right)', 'Test whether two finite field point values are equivalent in Arithmetic Geometry.', 'professional_function_catalog.md'), + ('arithmeticGeometryTestEquivalenceHeightFunction', 'Arithmetic Geometry', '(left, right)', 'Test whether two height function values are equivalent in Arithmetic Geometry.', 'professional_function_catalog.md'), + ('arithmeticGeometryTestEquivalenceRationalPoint', 'Arithmetic Geometry', '(left, right)', 'Test whether two rational point values are equivalent in Arithmetic Geometry.', 'professional_function_catalog.md'), + ('arithmeticGeometryTransformCurveReduction', 'Arithmetic Geometry', '(value, mapping)', 'Transform a curve reduction through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('arithmeticGeometryTransformEllipticCurve', 'Arithmetic Geometry', '(value, mapping)', 'Transform a elliptic curve through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('arithmeticGeometryTransformFiniteFieldPoint', 'Arithmetic Geometry', '(value, mapping)', 'Transform a finite field point through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('arithmeticGeometryTransformHeightFunction', 'Arithmetic Geometry', '(value, mapping)', 'Transform a height function through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('arithmeticGeometryTransformRationalPoint', 'Arithmetic Geometry', '(value, mapping)', 'Transform a rational point through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('arithmeticGeometryValidateCurveReduction', 'Arithmetic Geometry', '(value)', 'Validate the curve reduction representation and domain rules for Arithmetic Geometry.', 'professional_function_catalog.md'), + ('arithmeticGeometryValidateEllipticCurve', 'Arithmetic Geometry', '(value)', 'Validate the elliptic curve representation and domain rules for Arithmetic Geometry.', 'professional_function_catalog.md'), + ('arithmeticGeometryValidateFiniteFieldPoint', 'Arithmetic Geometry', '(value)', 'Validate the finite field point representation and domain rules for Arithmetic Geometry.', 'professional_function_catalog.md'), + ('arithmeticGeometryValidateHeightFunction', 'Arithmetic Geometry', '(value)', 'Validate the height function representation and domain rules for Arithmetic Geometry.', 'professional_function_catalog.md'), + ('arithmeticGeometryValidateRationalPoint', 'Arithmetic Geometry', '(value)', 'Validate the rational point representation and domain rules for Arithmetic Geometry.', 'professional_function_catalog.md'), + ('countPointsEllipticCurveModP', 'Arithmetic Geometry', '(a, b, p)', 'Planned roadmap function for Arithmetic Geometry from upcoming.md.', 'upcoming.md'), + ('ellipticCurveAdd', 'Arithmetic Geometry', '(P, Q, a, modulus=None)', 'Planned roadmap function for Arithmetic Geometry from upcoming.md.', 'upcoming.md'), + ('ellipticCurveDiscriminant', 'Arithmetic Geometry', '(a, b)', 'Planned roadmap function for Arithmetic Geometry from upcoming.md.', 'upcoming.md'), + ('ellipticCurveScalarMultiply', 'Arithmetic Geometry', '(P, n, a, modulus=None)', 'Planned roadmap function for Arithmetic Geometry from upcoming.md.', 'upcoming.md'), + ('hasGoodReduction', 'Arithmetic Geometry', '(a, b, p)', 'Planned roadmap function for Arithmetic Geometry from upcoming.md.', 'upcoming.md'), + ('isPointOnEllipticCurve', 'Arithmetic Geometry', '(point, a, b, modulus=None)', 'Planned roadmap function for Arithmetic Geometry from upcoming.md.', 'upcoming.md'), + ('pointsOnCurveModP', 'Arithmetic Geometry', '(polynomial, p)', 'Planned roadmap function for Arithmetic Geometry from upcoming.md.', 'upcoming.md'), + ('rationalPointHeight', 'Arithmetic Geometry', '(point)', 'Planned roadmap function for Arithmetic Geometry from upcoming.md.', 'upcoming.md'), + ('automataAndFormalLanguagesApproximateAutomaton', 'Automata and Formal Languages', '(value, tolerance=1e-9)', 'Approximate a automaton with explicit tolerance controls.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesApproximateDerivation', 'Automata and Formal Languages', '(value, tolerance=1e-9)', 'Approximate a derivation with explicit tolerance controls.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesApproximateGrammar', 'Automata and Formal Languages', '(value, tolerance=1e-9)', 'Approximate a grammar with explicit tolerance controls.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesApproximateParserState', 'Automata and Formal Languages', '(value, tolerance=1e-9)', 'Approximate a parser state with explicit tolerance controls.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesApproximateRegularLanguage', 'Automata and Formal Languages', '(value, tolerance=1e-9)', 'Approximate a regular language with explicit tolerance controls.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesCanonicalizeAutomaton', 'Automata and Formal Languages', '(value)', 'Canonicalize a automaton so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesCanonicalizeDerivation', 'Automata and Formal Languages', '(value)', 'Canonicalize a derivation so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesCanonicalizeGrammar', 'Automata and Formal Languages', '(value)', 'Canonicalize a grammar so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesCanonicalizeParserState', 'Automata and Formal Languages', '(value)', 'Canonicalize a parser state so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesCanonicalizeRegularLanguage', 'Automata and Formal Languages', '(value)', 'Canonicalize a regular language so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesClassifyAutomaton', 'Automata and Formal Languages', '(value)', 'Classify a automaton by its standard Automata and Formal Languages invariants.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesClassifyDerivation', 'Automata and Formal Languages', '(value)', 'Classify a derivation by its standard Automata and Formal Languages invariants.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesClassifyGrammar', 'Automata and Formal Languages', '(value)', 'Classify a grammar by its standard Automata and Formal Languages invariants.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesClassifyParserState', 'Automata and Formal Languages', '(value)', 'Classify a parser state by its standard Automata and Formal Languages invariants.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesClassifyRegularLanguage', 'Automata and Formal Languages', '(value)', 'Classify a regular language by its standard Automata and Formal Languages invariants.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesCombineAutomaton', 'Automata and Formal Languages', '(left, right)', 'Combine two automaton values with the natural operation for Automata and Formal Languages.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesCombineDerivation', 'Automata and Formal Languages', '(left, right)', 'Combine two derivation values with the natural operation for Automata and Formal Languages.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesCombineGrammar', 'Automata and Formal Languages', '(left, right)', 'Combine two grammar values with the natural operation for Automata and Formal Languages.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesCombineParserState', 'Automata and Formal Languages', '(left, right)', 'Combine two parser state values with the natural operation for Automata and Formal Languages.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesCombineRegularLanguage', 'Automata and Formal Languages', '(left, right)', 'Combine two regular language values with the natural operation for Automata and Formal Languages.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesCompareAutomaton', 'Automata and Formal Languages', '(left, right)', 'Compare two automaton values under the conventions of Automata and Formal Languages.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesCompareDerivation', 'Automata and Formal Languages', '(left, right)', 'Compare two derivation values under the conventions of Automata and Formal Languages.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesCompareGrammar', 'Automata and Formal Languages', '(left, right)', 'Compare two grammar values under the conventions of Automata and Formal Languages.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesCompareParserState', 'Automata and Formal Languages', '(left, right)', 'Compare two parser state values under the conventions of Automata and Formal Languages.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesCompareRegularLanguage', 'Automata and Formal Languages', '(left, right)', 'Compare two regular language values under the conventions of Automata and Formal Languages.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesComputeAutomaton', 'Automata and Formal Languages', '(value)', 'Compute the central numerical or symbolic data of a automaton.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesComputeDerivation', 'Automata and Formal Languages', '(value)', 'Compute the central numerical or symbolic data of a derivation.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesComputeGrammar', 'Automata and Formal Languages', '(value)', 'Compute the central numerical or symbolic data of a grammar.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesComputeParserState', 'Automata and Formal Languages', '(value)', 'Compute the central numerical or symbolic data of a parser state.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesComputeRegularLanguage', 'Automata and Formal Languages', '(value)', 'Compute the central numerical or symbolic data of a regular language.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesConstructAutomaton', 'Automata and Formal Languages', '(*args)', 'Construct a automaton from explicit inputs for Automata and Formal Languages.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesConstructDerivation', 'Automata and Formal Languages', '(*args)', 'Construct a derivation from explicit inputs for Automata and Formal Languages.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesConstructGrammar', 'Automata and Formal Languages', '(*args)', 'Construct a grammar from explicit inputs for Automata and Formal Languages.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesConstructParserState', 'Automata and Formal Languages', '(*args)', 'Construct a parser state from explicit inputs for Automata and Formal Languages.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesConstructRegularLanguage', 'Automata and Formal Languages', '(*args)', 'Construct a regular language from explicit inputs for Automata and Formal Languages.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesDecomposeAutomaton', 'Automata and Formal Languages', '(value)', 'Decompose a automaton into simpler or canonical components.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesDecomposeDerivation', 'Automata and Formal Languages', '(value)', 'Decompose a derivation into simpler or canonical components.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesDecomposeGrammar', 'Automata and Formal Languages', '(value)', 'Decompose a grammar into simpler or canonical components.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesDecomposeParserState', 'Automata and Formal Languages', '(value)', 'Decompose a parser state into simpler or canonical components.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesDecomposeRegularLanguage', 'Automata and Formal Languages', '(value)', 'Decompose a regular language into simpler or canonical components.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesDocumentAutomaton', 'Automata and Formal Languages', '(value)', 'Return a structured explanation of a automaton and related assumptions.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesDocumentDerivation', 'Automata and Formal Languages', '(value)', 'Return a structured explanation of a derivation and related assumptions.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesDocumentGrammar', 'Automata and Formal Languages', '(value)', 'Return a structured explanation of a grammar and related assumptions.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesDocumentParserState', 'Automata and Formal Languages', '(value)', 'Return a structured explanation of a parser state and related assumptions.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesDocumentRegularLanguage', 'Automata and Formal Languages', '(value)', 'Return a structured explanation of a regular language and related assumptions.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesEnumerateAutomaton', 'Automata and Formal Languages', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a automaton.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesEnumerateDerivation', 'Automata and Formal Languages', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a derivation.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesEnumerateGrammar', 'Automata and Formal Languages', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a grammar.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesEnumerateParserState', 'Automata and Formal Languages', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a parser state.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesEnumerateRegularLanguage', 'Automata and Formal Languages', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a regular language.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesEstimateAutomaton', 'Automata and Formal Languages', '(value, samples=None)', 'Estimate a automaton property from finite samples or approximations.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesEstimateDerivation', 'Automata and Formal Languages', '(value, samples=None)', 'Estimate a derivation property from finite samples or approximations.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesEstimateGrammar', 'Automata and Formal Languages', '(value, samples=None)', 'Estimate a grammar property from finite samples or approximations.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesEstimateParserState', 'Automata and Formal Languages', '(value, samples=None)', 'Estimate a parser state property from finite samples or approximations.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesEstimateRegularLanguage', 'Automata and Formal Languages', '(value, samples=None)', 'Estimate a regular language property from finite samples or approximations.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesEvaluateAutomaton', 'Automata and Formal Languages', '(value, point=None)', 'Evaluate a automaton at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesEvaluateDerivation', 'Automata and Formal Languages', '(value, point=None)', 'Evaluate a derivation at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesEvaluateGrammar', 'Automata and Formal Languages', '(value, point=None)', 'Evaluate a grammar at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesEvaluateParserState', 'Automata and Formal Languages', '(value, point=None)', 'Evaluate a parser state at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesEvaluateRegularLanguage', 'Automata and Formal Languages', '(value, point=None)', 'Evaluate a regular language at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesFormatAutomaton', 'Automata and Formal Languages', '(value)', 'Format a automaton for deterministic user-facing output.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesFormatDerivation', 'Automata and Formal Languages', '(value)', 'Format a derivation for deterministic user-facing output.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesFormatGrammar', 'Automata and Formal Languages', '(value)', 'Format a grammar for deterministic user-facing output.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesFormatParserState', 'Automata and Formal Languages', '(value)', 'Format a parser state for deterministic user-facing output.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesFormatRegularLanguage', 'Automata and Formal Languages', '(value)', 'Format a regular language for deterministic user-facing output.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesGenerateExampleAutomaton', 'Automata and Formal Languages', '(size=3)', 'Generate a small documented example of a automaton.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesGenerateExampleDerivation', 'Automata and Formal Languages', '(size=3)', 'Generate a small documented example of a derivation.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesGenerateExampleGrammar', 'Automata and Formal Languages', '(size=3)', 'Generate a small documented example of a grammar.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesGenerateExampleParserState', 'Automata and Formal Languages', '(size=3)', 'Generate a small documented example of a parser state.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesGenerateExampleRegularLanguage', 'Automata and Formal Languages', '(size=3)', 'Generate a small documented example of a regular language.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesNormalizeAutomaton', 'Automata and Formal Languages', '(value)', 'Normalize a automaton into the standard Automata and Formal Languages representation.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesNormalizeDerivation', 'Automata and Formal Languages', '(value)', 'Normalize a derivation into the standard Automata and Formal Languages representation.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesNormalizeGrammar', 'Automata and Formal Languages', '(value)', 'Normalize a grammar into the standard Automata and Formal Languages representation.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesNormalizeParserState', 'Automata and Formal Languages', '(value)', 'Normalize a parser state into the standard Automata and Formal Languages representation.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesNormalizeRegularLanguage', 'Automata and Formal Languages', '(value)', 'Normalize a regular language into the standard Automata and Formal Languages representation.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesParseAutomaton', 'Automata and Formal Languages', '(text)', 'Parse a text or structured value into a automaton.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesParseDerivation', 'Automata and Formal Languages', '(text)', 'Parse a text or structured value into a derivation.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesParseGrammar', 'Automata and Formal Languages', '(text)', 'Parse a text or structured value into a grammar.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesParseParserState', 'Automata and Formal Languages', '(text)', 'Parse a text or structured value into a parser state.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesParseRegularLanguage', 'Automata and Formal Languages', '(text)', 'Parse a text or structured value into a regular language.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesSimplifyAutomaton', 'Automata and Formal Languages', '(value)', 'Simplify a automaton without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesSimplifyDerivation', 'Automata and Formal Languages', '(value)', 'Simplify a derivation without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesSimplifyGrammar', 'Automata and Formal Languages', '(value)', 'Simplify a grammar without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesSimplifyParserState', 'Automata and Formal Languages', '(value)', 'Simplify a parser state without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesSimplifyRegularLanguage', 'Automata and Formal Languages', '(value)', 'Simplify a regular language without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesTestEquivalenceAutomaton', 'Automata and Formal Languages', '(left, right)', 'Test whether two automaton values are equivalent in Automata and Formal Languages.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesTestEquivalenceDerivation', 'Automata and Formal Languages', '(left, right)', 'Test whether two derivation values are equivalent in Automata and Formal Languages.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesTestEquivalenceGrammar', 'Automata and Formal Languages', '(left, right)', 'Test whether two grammar values are equivalent in Automata and Formal Languages.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesTestEquivalenceParserState', 'Automata and Formal Languages', '(left, right)', 'Test whether two parser state values are equivalent in Automata and Formal Languages.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesTestEquivalenceRegularLanguage', 'Automata and Formal Languages', '(left, right)', 'Test whether two regular language values are equivalent in Automata and Formal Languages.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesTransformAutomaton', 'Automata and Formal Languages', '(value, mapping)', 'Transform a automaton through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesTransformDerivation', 'Automata and Formal Languages', '(value, mapping)', 'Transform a derivation through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesTransformGrammar', 'Automata and Formal Languages', '(value, mapping)', 'Transform a grammar through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesTransformParserState', 'Automata and Formal Languages', '(value, mapping)', 'Transform a parser state through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesTransformRegularLanguage', 'Automata and Formal Languages', '(value, mapping)', 'Transform a regular language through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesValidateAutomaton', 'Automata and Formal Languages', '(value)', 'Validate the automaton representation and domain rules for Automata and Formal Languages.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesValidateDerivation', 'Automata and Formal Languages', '(value)', 'Validate the derivation representation and domain rules for Automata and Formal Languages.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesValidateGrammar', 'Automata and Formal Languages', '(value)', 'Validate the grammar representation and domain rules for Automata and Formal Languages.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesValidateParserState', 'Automata and Formal Languages', '(value)', 'Validate the parser state representation and domain rules for Automata and Formal Languages.', 'professional_function_catalog.md'), + ('automataAndFormalLanguagesValidateRegularLanguage', 'Automata and Formal Languages', '(value)', 'Validate the regular language representation and domain rules for Automata and Formal Languages.', 'professional_function_catalog.md'), + ('cykParse', 'Automata and Formal Languages', '(grammar, inputString)', 'Planned roadmap function for Automata and Formal Languages from upcoming.md.', 'upcoming.md'), + ('dfaAccepts', 'Automata and Formal Languages', '(dfa, inputString)', 'Planned roadmap function for Automata and Formal Languages from upcoming.md.', 'upcoming.md'), + ('grammarDerives', 'Automata and Formal Languages', '(grammar, inputString, maxDepth)', 'Planned roadmap function for Automata and Formal Languages from upcoming.md.', 'upcoming.md'), + ('minimizeDfa', 'Automata and Formal Languages', '(dfa)', 'Planned roadmap function for Automata and Formal Languages from upcoming.md.', 'upcoming.md'), + ('nfaAccepts', 'Automata and Formal Languages', '(nfa, inputString)', 'Planned roadmap function for Automata and Formal Languages from upcoming.md.', 'upcoming.md'), + ('nfaToDfa', 'Automata and Formal Languages', '(nfa)', 'Planned roadmap function for Automata and Formal Languages from upcoming.md.', 'upcoming.md'), + ('regularLanguageIntersection', 'Automata and Formal Languages', '(dfaA, dfaB)', 'Planned roadmap function for Automata and Formal Languages from upcoming.md.', 'upcoming.md'), + ('regularLanguageUnion', 'Automata and Formal Languages', '(dfaA, dfaB)', 'Planned roadmap function for Automata and Formal Languages from upcoming.md.', 'upcoming.md'), + ('bayesianStatisticsApproximateConjugateModel', 'Bayesian Statistics', '(value, tolerance=1e-9)', 'Approximate a conjugate model with explicit tolerance controls.', 'professional_function_catalog.md'), + ('bayesianStatisticsApproximateCredibleSet', 'Bayesian Statistics', '(value, tolerance=1e-9)', 'Approximate a credible set with explicit tolerance controls.', 'professional_function_catalog.md'), + ('bayesianStatisticsApproximateLikelihood', 'Bayesian Statistics', '(value, tolerance=1e-9)', 'Approximate a likelihood with explicit tolerance controls.', 'professional_function_catalog.md'), + ('bayesianStatisticsApproximatePosterior', 'Bayesian Statistics', '(value, tolerance=1e-9)', 'Approximate a posterior with explicit tolerance controls.', 'professional_function_catalog.md'), + ('bayesianStatisticsApproximatePrior', 'Bayesian Statistics', '(value, tolerance=1e-9)', 'Approximate a prior with explicit tolerance controls.', 'professional_function_catalog.md'), + ('bayesianStatisticsCanonicalizeConjugateModel', 'Bayesian Statistics', '(value)', 'Canonicalize a conjugate model so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('bayesianStatisticsCanonicalizeCredibleSet', 'Bayesian Statistics', '(value)', 'Canonicalize a credible set so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('bayesianStatisticsCanonicalizeLikelihood', 'Bayesian Statistics', '(value)', 'Canonicalize a likelihood so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('bayesianStatisticsCanonicalizePosterior', 'Bayesian Statistics', '(value)', 'Canonicalize a posterior so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('bayesianStatisticsCanonicalizePrior', 'Bayesian Statistics', '(value)', 'Canonicalize a prior so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('bayesianStatisticsClassifyConjugateModel', 'Bayesian Statistics', '(value)', 'Classify a conjugate model by its standard Bayesian Statistics invariants.', 'professional_function_catalog.md'), + ('bayesianStatisticsClassifyCredibleSet', 'Bayesian Statistics', '(value)', 'Classify a credible set by its standard Bayesian Statistics invariants.', 'professional_function_catalog.md'), + ('bayesianStatisticsClassifyLikelihood', 'Bayesian Statistics', '(value)', 'Classify a likelihood by its standard Bayesian Statistics invariants.', 'professional_function_catalog.md'), + ('bayesianStatisticsClassifyPosterior', 'Bayesian Statistics', '(value)', 'Classify a posterior by its standard Bayesian Statistics invariants.', 'professional_function_catalog.md'), + ('bayesianStatisticsClassifyPrior', 'Bayesian Statistics', '(value)', 'Classify a prior by its standard Bayesian Statistics invariants.', 'professional_function_catalog.md'), + ('bayesianStatisticsCombineConjugateModel', 'Bayesian Statistics', '(left, right)', 'Combine two conjugate model values with the natural operation for Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianStatisticsCombineCredibleSet', 'Bayesian Statistics', '(left, right)', 'Combine two credible set values with the natural operation for Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianStatisticsCombineLikelihood', 'Bayesian Statistics', '(left, right)', 'Combine two likelihood values with the natural operation for Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianStatisticsCombinePosterior', 'Bayesian Statistics', '(left, right)', 'Combine two posterior values with the natural operation for Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianStatisticsCombinePrior', 'Bayesian Statistics', '(left, right)', 'Combine two prior values with the natural operation for Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianStatisticsCompareConjugateModel', 'Bayesian Statistics', '(left, right)', 'Compare two conjugate model values under the conventions of Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianStatisticsCompareCredibleSet', 'Bayesian Statistics', '(left, right)', 'Compare two credible set values under the conventions of Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianStatisticsCompareLikelihood', 'Bayesian Statistics', '(left, right)', 'Compare two likelihood values under the conventions of Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianStatisticsComparePosterior', 'Bayesian Statistics', '(left, right)', 'Compare two posterior values under the conventions of Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianStatisticsComparePrior', 'Bayesian Statistics', '(left, right)', 'Compare two prior values under the conventions of Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianStatisticsComputeConjugateModel', 'Bayesian Statistics', '(value)', 'Compute the central numerical or symbolic data of a conjugate model.', 'professional_function_catalog.md'), + ('bayesianStatisticsComputeCredibleSet', 'Bayesian Statistics', '(value)', 'Compute the central numerical or symbolic data of a credible set.', 'professional_function_catalog.md'), + ('bayesianStatisticsComputeLikelihood', 'Bayesian Statistics', '(value)', 'Compute the central numerical or symbolic data of a likelihood.', 'professional_function_catalog.md'), + ('bayesianStatisticsComputePosterior', 'Bayesian Statistics', '(value)', 'Compute the central numerical or symbolic data of a posterior.', 'professional_function_catalog.md'), + ('bayesianStatisticsComputePrior', 'Bayesian Statistics', '(value)', 'Compute the central numerical or symbolic data of a prior.', 'professional_function_catalog.md'), + ('bayesianStatisticsConstructConjugateModel', 'Bayesian Statistics', '(*args)', 'Construct a conjugate model from explicit inputs for Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianStatisticsConstructCredibleSet', 'Bayesian Statistics', '(*args)', 'Construct a credible set from explicit inputs for Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianStatisticsConstructLikelihood', 'Bayesian Statistics', '(*args)', 'Construct a likelihood from explicit inputs for Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianStatisticsConstructPosterior', 'Bayesian Statistics', '(*args)', 'Construct a posterior from explicit inputs for Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianStatisticsConstructPrior', 'Bayesian Statistics', '(*args)', 'Construct a prior from explicit inputs for Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianStatisticsDecomposeConjugateModel', 'Bayesian Statistics', '(value)', 'Decompose a conjugate model into simpler or canonical components.', 'professional_function_catalog.md'), + ('bayesianStatisticsDecomposeCredibleSet', 'Bayesian Statistics', '(value)', 'Decompose a credible set into simpler or canonical components.', 'professional_function_catalog.md'), + ('bayesianStatisticsDecomposeLikelihood', 'Bayesian Statistics', '(value)', 'Decompose a likelihood into simpler or canonical components.', 'professional_function_catalog.md'), + ('bayesianStatisticsDecomposePosterior', 'Bayesian Statistics', '(value)', 'Decompose a posterior into simpler or canonical components.', 'professional_function_catalog.md'), + ('bayesianStatisticsDecomposePrior', 'Bayesian Statistics', '(value)', 'Decompose a prior into simpler or canonical components.', 'professional_function_catalog.md'), + ('bayesianStatisticsDocumentConjugateModel', 'Bayesian Statistics', '(value)', 'Return a structured explanation of a conjugate model and related assumptions.', 'professional_function_catalog.md'), + ('bayesianStatisticsDocumentCredibleSet', 'Bayesian Statistics', '(value)', 'Return a structured explanation of a credible set and related assumptions.', 'professional_function_catalog.md'), + ('bayesianStatisticsDocumentLikelihood', 'Bayesian Statistics', '(value)', 'Return a structured explanation of a likelihood and related assumptions.', 'professional_function_catalog.md'), + ('bayesianStatisticsDocumentPosterior', 'Bayesian Statistics', '(value)', 'Return a structured explanation of a posterior and related assumptions.', 'professional_function_catalog.md'), + ('bayesianStatisticsDocumentPrior', 'Bayesian Statistics', '(value)', 'Return a structured explanation of a prior and related assumptions.', 'professional_function_catalog.md'), + ('bayesianStatisticsEnumerateConjugateModel', 'Bayesian Statistics', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a conjugate model.', 'professional_function_catalog.md'), + ('bayesianStatisticsEnumerateCredibleSet', 'Bayesian Statistics', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a credible set.', 'professional_function_catalog.md'), + ('bayesianStatisticsEnumerateLikelihood', 'Bayesian Statistics', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a likelihood.', 'professional_function_catalog.md'), + ('bayesianStatisticsEnumeratePosterior', 'Bayesian Statistics', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a posterior.', 'professional_function_catalog.md'), + ('bayesianStatisticsEnumeratePrior', 'Bayesian Statistics', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a prior.', 'professional_function_catalog.md'), + ('bayesianStatisticsEstimateConjugateModel', 'Bayesian Statistics', '(value, samples=None)', 'Estimate a conjugate model property from finite samples or approximations.', 'professional_function_catalog.md'), + ('bayesianStatisticsEstimateCredibleSet', 'Bayesian Statistics', '(value, samples=None)', 'Estimate a credible set property from finite samples or approximations.', 'professional_function_catalog.md'), + ('bayesianStatisticsEstimateLikelihood', 'Bayesian Statistics', '(value, samples=None)', 'Estimate a likelihood property from finite samples or approximations.', 'professional_function_catalog.md'), + ('bayesianStatisticsEstimatePosterior', 'Bayesian Statistics', '(value, samples=None)', 'Estimate a posterior property from finite samples or approximations.', 'professional_function_catalog.md'), + ('bayesianStatisticsEstimatePrior', 'Bayesian Statistics', '(value, samples=None)', 'Estimate a prior property from finite samples or approximations.', 'professional_function_catalog.md'), + ('bayesianStatisticsEvaluateConjugateModel', 'Bayesian Statistics', '(value, point=None)', 'Evaluate a conjugate model at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('bayesianStatisticsEvaluateCredibleSet', 'Bayesian Statistics', '(value, point=None)', 'Evaluate a credible set at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('bayesianStatisticsEvaluateLikelihood', 'Bayesian Statistics', '(value, point=None)', 'Evaluate a likelihood at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('bayesianStatisticsEvaluatePosterior', 'Bayesian Statistics', '(value, point=None)', 'Evaluate a posterior at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('bayesianStatisticsEvaluatePrior', 'Bayesian Statistics', '(value, point=None)', 'Evaluate a prior at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('bayesianStatisticsFormatConjugateModel', 'Bayesian Statistics', '(value)', 'Format a conjugate model for deterministic user-facing output.', 'professional_function_catalog.md'), + ('bayesianStatisticsFormatCredibleSet', 'Bayesian Statistics', '(value)', 'Format a credible set for deterministic user-facing output.', 'professional_function_catalog.md'), + ('bayesianStatisticsFormatLikelihood', 'Bayesian Statistics', '(value)', 'Format a likelihood for deterministic user-facing output.', 'professional_function_catalog.md'), + ('bayesianStatisticsFormatPosterior', 'Bayesian Statistics', '(value)', 'Format a posterior for deterministic user-facing output.', 'professional_function_catalog.md'), + ('bayesianStatisticsFormatPrior', 'Bayesian Statistics', '(value)', 'Format a prior for deterministic user-facing output.', 'professional_function_catalog.md'), + ('bayesianStatisticsGenerateExampleConjugateModel', 'Bayesian Statistics', '(size=3)', 'Generate a small documented example of a conjugate model.', 'professional_function_catalog.md'), + ('bayesianStatisticsGenerateExampleCredibleSet', 'Bayesian Statistics', '(size=3)', 'Generate a small documented example of a credible set.', 'professional_function_catalog.md'), + ('bayesianStatisticsGenerateExampleLikelihood', 'Bayesian Statistics', '(size=3)', 'Generate a small documented example of a likelihood.', 'professional_function_catalog.md'), + ('bayesianStatisticsGenerateExamplePosterior', 'Bayesian Statistics', '(size=3)', 'Generate a small documented example of a posterior.', 'professional_function_catalog.md'), + ('bayesianStatisticsGenerateExamplePrior', 'Bayesian Statistics', '(size=3)', 'Generate a small documented example of a prior.', 'professional_function_catalog.md'), + ('bayesianStatisticsNormalizeConjugateModel', 'Bayesian Statistics', '(value)', 'Normalize a conjugate model into the standard Bayesian Statistics representation.', 'professional_function_catalog.md'), + ('bayesianStatisticsNormalizeCredibleSet', 'Bayesian Statistics', '(value)', 'Normalize a credible set into the standard Bayesian Statistics representation.', 'professional_function_catalog.md'), + ('bayesianStatisticsNormalizeLikelihood', 'Bayesian Statistics', '(value)', 'Normalize a likelihood into the standard Bayesian Statistics representation.', 'professional_function_catalog.md'), + ('bayesianStatisticsNormalizePosterior', 'Bayesian Statistics', '(value)', 'Normalize a posterior into the standard Bayesian Statistics representation.', 'professional_function_catalog.md'), + ('bayesianStatisticsNormalizePrior', 'Bayesian Statistics', '(value)', 'Normalize a prior into the standard Bayesian Statistics representation.', 'professional_function_catalog.md'), + ('bayesianStatisticsParseConjugateModel', 'Bayesian Statistics', '(text)', 'Parse a text or structured value into a conjugate model.', 'professional_function_catalog.md'), + ('bayesianStatisticsParseCredibleSet', 'Bayesian Statistics', '(text)', 'Parse a text or structured value into a credible set.', 'professional_function_catalog.md'), + ('bayesianStatisticsParseLikelihood', 'Bayesian Statistics', '(text)', 'Parse a text or structured value into a likelihood.', 'professional_function_catalog.md'), + ('bayesianStatisticsParsePosterior', 'Bayesian Statistics', '(text)', 'Parse a text or structured value into a posterior.', 'professional_function_catalog.md'), + ('bayesianStatisticsParsePrior', 'Bayesian Statistics', '(text)', 'Parse a text or structured value into a prior.', 'professional_function_catalog.md'), + ('bayesianStatisticsSimplifyConjugateModel', 'Bayesian Statistics', '(value)', 'Simplify a conjugate model without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('bayesianStatisticsSimplifyCredibleSet', 'Bayesian Statistics', '(value)', 'Simplify a credible set without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('bayesianStatisticsSimplifyLikelihood', 'Bayesian Statistics', '(value)', 'Simplify a likelihood without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('bayesianStatisticsSimplifyPosterior', 'Bayesian Statistics', '(value)', 'Simplify a posterior without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('bayesianStatisticsSimplifyPrior', 'Bayesian Statistics', '(value)', 'Simplify a prior without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('bayesianStatisticsTestEquivalenceConjugateModel', 'Bayesian Statistics', '(left, right)', 'Test whether two conjugate model values are equivalent in Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianStatisticsTestEquivalenceCredibleSet', 'Bayesian Statistics', '(left, right)', 'Test whether two credible set values are equivalent in Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianStatisticsTestEquivalenceLikelihood', 'Bayesian Statistics', '(left, right)', 'Test whether two likelihood values are equivalent in Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianStatisticsTestEquivalencePosterior', 'Bayesian Statistics', '(left, right)', 'Test whether two posterior values are equivalent in Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianStatisticsTestEquivalencePrior', 'Bayesian Statistics', '(left, right)', 'Test whether two prior values are equivalent in Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianStatisticsTransformConjugateModel', 'Bayesian Statistics', '(value, mapping)', 'Transform a conjugate model through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('bayesianStatisticsTransformCredibleSet', 'Bayesian Statistics', '(value, mapping)', 'Transform a credible set through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('bayesianStatisticsTransformLikelihood', 'Bayesian Statistics', '(value, mapping)', 'Transform a likelihood through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('bayesianStatisticsTransformPosterior', 'Bayesian Statistics', '(value, mapping)', 'Transform a posterior through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('bayesianStatisticsTransformPrior', 'Bayesian Statistics', '(value, mapping)', 'Transform a prior through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('bayesianStatisticsValidateConjugateModel', 'Bayesian Statistics', '(value)', 'Validate the conjugate model representation and domain rules for Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianStatisticsValidateCredibleSet', 'Bayesian Statistics', '(value)', 'Validate the credible set representation and domain rules for Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianStatisticsValidateLikelihood', 'Bayesian Statistics', '(value)', 'Validate the likelihood representation and domain rules for Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianStatisticsValidatePosterior', 'Bayesian Statistics', '(value)', 'Validate the posterior representation and domain rules for Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianStatisticsValidatePrior', 'Bayesian Statistics', '(value)', 'Validate the prior representation and domain rules for Bayesian Statistics.', 'professional_function_catalog.md'), + ('bayesianUpdateDiscrete', 'Bayesian Statistics', '(prior, likelihood)', 'Planned roadmap function for Bayesian Statistics from upcoming.md.', 'upcoming.md'), + ('betaMean', 'Bayesian Statistics', '(alpha, beta)', 'Planned roadmap function for Bayesian Statistics from upcoming.md.', 'upcoming.md'), + ('betaPosterior', 'Bayesian Statistics', '(alpha, beta, successes, failures)', 'Planned roadmap function for Bayesian Statistics from upcoming.md.', 'upcoming.md'), + ('betaVariance', 'Bayesian Statistics', '(alpha, beta)', 'Planned roadmap function for Bayesian Statistics from upcoming.md.', 'upcoming.md'), + ('credibleIntervalDiscrete', 'Bayesian Statistics', '(distribution, confidence)', 'Planned roadmap function for Bayesian Statistics from upcoming.md.', 'upcoming.md'), + ('maximumAPosteriori', 'Bayesian Statistics', '(distribution)', 'Planned roadmap function for Bayesian Statistics from upcoming.md.', 'upcoming.md'), + ('normalizeProbabilities', 'Bayesian Statistics', '(weights)', 'Planned roadmap function for Bayesian Statistics from upcoming.md.', 'upcoming.md'), + ('posteriorPredictiveDiscrete', 'Bayesian Statistics', '(posterior, likelihoods)', 'Planned roadmap function for Bayesian Statistics from upcoming.md.', 'upcoming.md'), + ('calculusApproximateContinuityProfile', 'Calculus', '(value, tolerance=1e-9)', 'Approximate a continuity profile with explicit tolerance controls.', 'professional_function_catalog.md'), + ('calculusApproximateDerivativeModel', 'Calculus', '(value, tolerance=1e-9)', 'Approximate a derivative model with explicit tolerance controls.', 'professional_function_catalog.md'), + ('calculusApproximateIntegralModel', 'Calculus', '(value, tolerance=1e-9)', 'Approximate a integral model with explicit tolerance controls.', 'professional_function_catalog.md'), + ('calculusApproximateLimitModel', 'Calculus', '(value, tolerance=1e-9)', 'Approximate a limit model with explicit tolerance controls.', 'professional_function_catalog.md'), + ('calculusApproximateSingleVariableFunction', 'Calculus', '(value, tolerance=1e-9)', 'Approximate a single-variable function with explicit tolerance controls.', 'professional_function_catalog.md'), + ('calculusCanonicalizeContinuityProfile', 'Calculus', '(value)', 'Canonicalize a continuity profile so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('calculusCanonicalizeDerivativeModel', 'Calculus', '(value)', 'Canonicalize a derivative model so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('calculusCanonicalizeIntegralModel', 'Calculus', '(value)', 'Canonicalize a integral model so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('calculusCanonicalizeLimitModel', 'Calculus', '(value)', 'Canonicalize a limit model so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('calculusCanonicalizeSingleVariableFunction', 'Calculus', '(value)', 'Canonicalize a single-variable function so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('calculusClassifyContinuityProfile', 'Calculus', '(value)', 'Classify a continuity profile by its standard Calculus invariants.', 'professional_function_catalog.md'), + ('calculusClassifyDerivativeModel', 'Calculus', '(value)', 'Classify a derivative model by its standard Calculus invariants.', 'professional_function_catalog.md'), + ('calculusClassifyIntegralModel', 'Calculus', '(value)', 'Classify a integral model by its standard Calculus invariants.', 'professional_function_catalog.md'), + ('calculusClassifyLimitModel', 'Calculus', '(value)', 'Classify a limit model by its standard Calculus invariants.', 'professional_function_catalog.md'), + ('calculusClassifySingleVariableFunction', 'Calculus', '(value)', 'Classify a single-variable function by its standard Calculus invariants.', 'professional_function_catalog.md'), + ('calculusCombineContinuityProfile', 'Calculus', '(left, right)', 'Combine two continuity profile values with the natural operation for Calculus.', 'professional_function_catalog.md'), + ('calculusCombineDerivativeModel', 'Calculus', '(left, right)', 'Combine two derivative model values with the natural operation for Calculus.', 'professional_function_catalog.md'), + ('calculusCombineIntegralModel', 'Calculus', '(left, right)', 'Combine two integral model values with the natural operation for Calculus.', 'professional_function_catalog.md'), + ('calculusCombineLimitModel', 'Calculus', '(left, right)', 'Combine two limit model values with the natural operation for Calculus.', 'professional_function_catalog.md'), + ('calculusCombineSingleVariableFunction', 'Calculus', '(left, right)', 'Combine two single-variable function values with the natural operation for Calculus.', 'professional_function_catalog.md'), + ('calculusCompareContinuityProfile', 'Calculus', '(left, right)', 'Compare two continuity profile values under the conventions of Calculus.', 'professional_function_catalog.md'), + ('calculusCompareDerivativeModel', 'Calculus', '(left, right)', 'Compare two derivative model values under the conventions of Calculus.', 'professional_function_catalog.md'), + ('calculusCompareIntegralModel', 'Calculus', '(left, right)', 'Compare two integral model values under the conventions of Calculus.', 'professional_function_catalog.md'), + ('calculusCompareLimitModel', 'Calculus', '(left, right)', 'Compare two limit model values under the conventions of Calculus.', 'professional_function_catalog.md'), + ('calculusCompareSingleVariableFunction', 'Calculus', '(left, right)', 'Compare two single-variable function values under the conventions of Calculus.', 'professional_function_catalog.md'), + ('calculusComputeContinuityProfile', 'Calculus', '(value)', 'Compute the central numerical or symbolic data of a continuity profile.', 'professional_function_catalog.md'), + ('calculusComputeDerivativeModel', 'Calculus', '(value)', 'Compute the central numerical or symbolic data of a derivative model.', 'professional_function_catalog.md'), + ('calculusComputeIntegralModel', 'Calculus', '(value)', 'Compute the central numerical or symbolic data of a integral model.', 'professional_function_catalog.md'), + ('calculusComputeLimitModel', 'Calculus', '(value)', 'Compute the central numerical or symbolic data of a limit model.', 'professional_function_catalog.md'), + ('calculusComputeSingleVariableFunction', 'Calculus', '(value)', 'Compute the central numerical or symbolic data of a single-variable function.', 'professional_function_catalog.md'), + ('calculusConstructContinuityProfile', 'Calculus', '(*args)', 'Construct a continuity profile from explicit inputs for Calculus.', 'professional_function_catalog.md'), + ('calculusConstructDerivativeModel', 'Calculus', '(*args)', 'Construct a derivative model from explicit inputs for Calculus.', 'professional_function_catalog.md'), + ('calculusConstructIntegralModel', 'Calculus', '(*args)', 'Construct a integral model from explicit inputs for Calculus.', 'professional_function_catalog.md'), + ('calculusConstructLimitModel', 'Calculus', '(*args)', 'Construct a limit model from explicit inputs for Calculus.', 'professional_function_catalog.md'), + ('calculusConstructSingleVariableFunction', 'Calculus', '(*args)', 'Construct a single-variable function from explicit inputs for Calculus.', 'professional_function_catalog.md'), + ('calculusDecomposeContinuityProfile', 'Calculus', '(value)', 'Decompose a continuity profile into simpler or canonical components.', 'professional_function_catalog.md'), + ('calculusDecomposeDerivativeModel', 'Calculus', '(value)', 'Decompose a derivative model into simpler or canonical components.', 'professional_function_catalog.md'), + ('calculusDecomposeIntegralModel', 'Calculus', '(value)', 'Decompose a integral model into simpler or canonical components.', 'professional_function_catalog.md'), + ('calculusDecomposeLimitModel', 'Calculus', '(value)', 'Decompose a limit model into simpler or canonical components.', 'professional_function_catalog.md'), + ('calculusDecomposeSingleVariableFunction', 'Calculus', '(value)', 'Decompose a single-variable function into simpler or canonical components.', 'professional_function_catalog.md'), + ('calculusDocumentContinuityProfile', 'Calculus', '(value)', 'Return a structured explanation of a continuity profile and related assumptions.', 'professional_function_catalog.md'), + ('calculusDocumentDerivativeModel', 'Calculus', '(value)', 'Return a structured explanation of a derivative model and related assumptions.', 'professional_function_catalog.md'), + ('calculusDocumentIntegralModel', 'Calculus', '(value)', 'Return a structured explanation of a integral model and related assumptions.', 'professional_function_catalog.md'), + ('calculusDocumentLimitModel', 'Calculus', '(value)', 'Return a structured explanation of a limit model and related assumptions.', 'professional_function_catalog.md'), + ('calculusDocumentSingleVariableFunction', 'Calculus', '(value)', 'Return a structured explanation of a single-variable function and related assumptions.', 'professional_function_catalog.md'), + ('calculusEnumerateContinuityProfile', 'Calculus', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a continuity profile.', 'professional_function_catalog.md'), + ('calculusEnumerateDerivativeModel', 'Calculus', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a derivative model.', 'professional_function_catalog.md'), + ('calculusEnumerateIntegralModel', 'Calculus', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a integral model.', 'professional_function_catalog.md'), + ('calculusEnumerateLimitModel', 'Calculus', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a limit model.', 'professional_function_catalog.md'), + ('calculusEnumerateSingleVariableFunction', 'Calculus', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a single-variable function.', 'professional_function_catalog.md'), + ('calculusEstimateContinuityProfile', 'Calculus', '(value, samples=None)', 'Estimate a continuity profile property from finite samples or approximations.', 'professional_function_catalog.md'), + ('calculusEstimateDerivativeModel', 'Calculus', '(value, samples=None)', 'Estimate a derivative model property from finite samples or approximations.', 'professional_function_catalog.md'), + ('calculusEstimateIntegralModel', 'Calculus', '(value, samples=None)', 'Estimate a integral model property from finite samples or approximations.', 'professional_function_catalog.md'), + ('calculusEstimateLimitModel', 'Calculus', '(value, samples=None)', 'Estimate a limit model property from finite samples or approximations.', 'professional_function_catalog.md'), + ('calculusEstimateSingleVariableFunction', 'Calculus', '(value, samples=None)', 'Estimate a single-variable function property from finite samples or approximations.', 'professional_function_catalog.md'), + ('calculusEvaluateContinuityProfile', 'Calculus', '(value, point=None)', 'Evaluate a continuity profile at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('calculusEvaluateDerivativeModel', 'Calculus', '(value, point=None)', 'Evaluate a derivative model at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('calculusEvaluateIntegralModel', 'Calculus', '(value, point=None)', 'Evaluate a integral model at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('calculusEvaluateLimitModel', 'Calculus', '(value, point=None)', 'Evaluate a limit model at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('calculusEvaluateSingleVariableFunction', 'Calculus', '(value, point=None)', 'Evaluate a single-variable function at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('calculusFormatContinuityProfile', 'Calculus', '(value)', 'Format a continuity profile for deterministic user-facing output.', 'professional_function_catalog.md'), + ('calculusFormatDerivativeModel', 'Calculus', '(value)', 'Format a derivative model for deterministic user-facing output.', 'professional_function_catalog.md'), + ('calculusFormatIntegralModel', 'Calculus', '(value)', 'Format a integral model for deterministic user-facing output.', 'professional_function_catalog.md'), + ('calculusFormatLimitModel', 'Calculus', '(value)', 'Format a limit model for deterministic user-facing output.', 'professional_function_catalog.md'), + ('calculusFormatSingleVariableFunction', 'Calculus', '(value)', 'Format a single-variable function for deterministic user-facing output.', 'professional_function_catalog.md'), + ('calculusGenerateExampleContinuityProfile', 'Calculus', '(size=3)', 'Generate a small documented example of a continuity profile.', 'professional_function_catalog.md'), + ('calculusGenerateExampleDerivativeModel', 'Calculus', '(size=3)', 'Generate a small documented example of a derivative model.', 'professional_function_catalog.md'), + ('calculusGenerateExampleIntegralModel', 'Calculus', '(size=3)', 'Generate a small documented example of a integral model.', 'professional_function_catalog.md'), + ('calculusGenerateExampleLimitModel', 'Calculus', '(size=3)', 'Generate a small documented example of a limit model.', 'professional_function_catalog.md'), + ('calculusGenerateExampleSingleVariableFunction', 'Calculus', '(size=3)', 'Generate a small documented example of a single-variable function.', 'professional_function_catalog.md'), + ('calculusNormalizeContinuityProfile', 'Calculus', '(value)', 'Normalize a continuity profile into the standard Calculus representation.', 'professional_function_catalog.md'), + ('calculusNormalizeDerivativeModel', 'Calculus', '(value)', 'Normalize a derivative model into the standard Calculus representation.', 'professional_function_catalog.md'), + ('calculusNormalizeIntegralModel', 'Calculus', '(value)', 'Normalize a integral model into the standard Calculus representation.', 'professional_function_catalog.md'), + ('calculusNormalizeLimitModel', 'Calculus', '(value)', 'Normalize a limit model into the standard Calculus representation.', 'professional_function_catalog.md'), + ('calculusNormalizeSingleVariableFunction', 'Calculus', '(value)', 'Normalize a single-variable function into the standard Calculus representation.', 'professional_function_catalog.md'), + ('calculusParseContinuityProfile', 'Calculus', '(text)', 'Parse a text or structured value into a continuity profile.', 'professional_function_catalog.md'), + ('calculusParseDerivativeModel', 'Calculus', '(text)', 'Parse a text or structured value into a derivative model.', 'professional_function_catalog.md'), + ('calculusParseIntegralModel', 'Calculus', '(text)', 'Parse a text or structured value into a integral model.', 'professional_function_catalog.md'), + ('calculusParseLimitModel', 'Calculus', '(text)', 'Parse a text or structured value into a limit model.', 'professional_function_catalog.md'), + ('calculusParseSingleVariableFunction', 'Calculus', '(text)', 'Parse a text or structured value into a single-variable function.', 'professional_function_catalog.md'), + ('calculusSimplifyContinuityProfile', 'Calculus', '(value)', 'Simplify a continuity profile without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('calculusSimplifyDerivativeModel', 'Calculus', '(value)', 'Simplify a derivative model without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('calculusSimplifyIntegralModel', 'Calculus', '(value)', 'Simplify a integral model without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('calculusSimplifyLimitModel', 'Calculus', '(value)', 'Simplify a limit model without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('calculusSimplifySingleVariableFunction', 'Calculus', '(value)', 'Simplify a single-variable function without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('calculusTestEquivalenceContinuityProfile', 'Calculus', '(left, right)', 'Test whether two continuity profile values are equivalent in Calculus.', 'professional_function_catalog.md'), + ('calculusTestEquivalenceDerivativeModel', 'Calculus', '(left, right)', 'Test whether two derivative model values are equivalent in Calculus.', 'professional_function_catalog.md'), + ('calculusTestEquivalenceIntegralModel', 'Calculus', '(left, right)', 'Test whether two integral model values are equivalent in Calculus.', 'professional_function_catalog.md'), + ('calculusTestEquivalenceLimitModel', 'Calculus', '(left, right)', 'Test whether two limit model values are equivalent in Calculus.', 'professional_function_catalog.md'), + ('calculusTestEquivalenceSingleVariableFunction', 'Calculus', '(left, right)', 'Test whether two single-variable function values are equivalent in Calculus.', 'professional_function_catalog.md'), + ('calculusTransformContinuityProfile', 'Calculus', '(value, mapping)', 'Transform a continuity profile through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('calculusTransformDerivativeModel', 'Calculus', '(value, mapping)', 'Transform a derivative model through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('calculusTransformIntegralModel', 'Calculus', '(value, mapping)', 'Transform a integral model through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('calculusTransformLimitModel', 'Calculus', '(value, mapping)', 'Transform a limit model through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('calculusTransformSingleVariableFunction', 'Calculus', '(value, mapping)', 'Transform a single-variable function through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('calculusValidateContinuityProfile', 'Calculus', '(value)', 'Validate the continuity profile representation and domain rules for Calculus.', 'professional_function_catalog.md'), + ('calculusValidateDerivativeModel', 'Calculus', '(value)', 'Validate the derivative model representation and domain rules for Calculus.', 'professional_function_catalog.md'), + ('calculusValidateIntegralModel', 'Calculus', '(value)', 'Validate the integral model representation and domain rules for Calculus.', 'professional_function_catalog.md'), + ('calculusValidateLimitModel', 'Calculus', '(value)', 'Validate the limit model representation and domain rules for Calculus.', 'professional_function_catalog.md'), + ('calculusValidateSingleVariableFunction', 'Calculus', '(value)', 'Validate the single-variable function representation and domain rules for Calculus.', 'professional_function_catalog.md'), + ('criticalPointType', 'Calculus', '(f, x)', 'Planned roadmap function for Calculus from upcoming.md.', 'upcoming.md'), + ('gradient', 'Calculus', '(f, point)', 'Planned roadmap function for Calculus from upcoming.md.', 'upcoming.md'), + ('leftLimit', 'Calculus', '(f, a)', 'Planned roadmap function for Calculus from upcoming.md.', 'upcoming.md'), + ('newtonMethod', 'Calculus', '(f, derivativeFunction, initialGuess)', 'Planned roadmap function for Calculus from upcoming.md.', 'upcoming.md'), + ('nthDerivative', 'Calculus', '(f, x, n)', 'Planned roadmap function for Calculus from upcoming.md.', 'upcoming.md'), + ('partialDerivative', 'Calculus', '(f, point, variableIndex)', 'Planned roadmap function for Calculus from upcoming.md.', 'upcoming.md'), + ('riemannSum', 'Calculus', '(f, a, b, n, method="midpoint")', 'Planned roadmap function for Calculus from upcoming.md.', 'upcoming.md'), + ('rightLimit', 'Calculus', '(f, a)', 'Planned roadmap function for Calculus from upcoming.md.', 'upcoming.md'), + ('secondDerivative', 'Calculus', '(f, x)', 'Planned roadmap function for Calculus from upcoming.md.', 'upcoming.md'), + ('trapezoidalIntegral', 'Calculus', '(f, a, b, n=1000)', 'Planned roadmap function for Calculus from upcoming.md.', 'upcoming.md'), + ('brachistochroneResidual', 'Calculus of Variations', '(path)', 'Planned roadmap function for Calculus of Variations from upcoming.md.', 'upcoming.md'), + ('calculusOfVariationsApproximateEulerLagrangeResidual', 'Calculus of Variations', '(value, tolerance=1e-9)', 'Approximate a Euler Lagrange residual with explicit tolerance controls.', 'professional_function_catalog.md'), + ('calculusOfVariationsApproximateExtremalCurve', 'Calculus of Variations', '(value, tolerance=1e-9)', 'Approximate a extremal curve with explicit tolerance controls.', 'professional_function_catalog.md'), + ('calculusOfVariationsApproximateFunctional', 'Calculus of Variations', '(value, tolerance=1e-9)', 'Approximate a functional with explicit tolerance controls.', 'professional_function_catalog.md'), + ('calculusOfVariationsApproximatePathEnergy', 'Calculus of Variations', '(value, tolerance=1e-9)', 'Approximate a path energy with explicit tolerance controls.', 'professional_function_catalog.md'), + ('calculusOfVariationsApproximateVariation', 'Calculus of Variations', '(value, tolerance=1e-9)', 'Approximate a variation with explicit tolerance controls.', 'professional_function_catalog.md'), + ('calculusOfVariationsCanonicalizeEulerLagrangeResidual', 'Calculus of Variations', '(value)', 'Canonicalize a Euler Lagrange residual so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('calculusOfVariationsCanonicalizeExtremalCurve', 'Calculus of Variations', '(value)', 'Canonicalize a extremal curve so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('calculusOfVariationsCanonicalizeFunctional', 'Calculus of Variations', '(value)', 'Canonicalize a functional so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('calculusOfVariationsCanonicalizePathEnergy', 'Calculus of Variations', '(value)', 'Canonicalize a path energy so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('calculusOfVariationsCanonicalizeVariation', 'Calculus of Variations', '(value)', 'Canonicalize a variation so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('calculusOfVariationsClassifyEulerLagrangeResidual', 'Calculus of Variations', '(value)', 'Classify a Euler Lagrange residual by its standard Calculus of Variations invariants.', 'professional_function_catalog.md'), + ('calculusOfVariationsClassifyExtremalCurve', 'Calculus of Variations', '(value)', 'Classify a extremal curve by its standard Calculus of Variations invariants.', 'professional_function_catalog.md'), + ('calculusOfVariationsClassifyFunctional', 'Calculus of Variations', '(value)', 'Classify a functional by its standard Calculus of Variations invariants.', 'professional_function_catalog.md'), + ('calculusOfVariationsClassifyPathEnergy', 'Calculus of Variations', '(value)', 'Classify a path energy by its standard Calculus of Variations invariants.', 'professional_function_catalog.md'), + ('calculusOfVariationsClassifyVariation', 'Calculus of Variations', '(value)', 'Classify a variation by its standard Calculus of Variations invariants.', 'professional_function_catalog.md'), + ('calculusOfVariationsCombineEulerLagrangeResidual', 'Calculus of Variations', '(left, right)', 'Combine two Euler Lagrange residual values with the natural operation for Calculus of Variations.', 'professional_function_catalog.md'), + ('calculusOfVariationsCombineExtremalCurve', 'Calculus of Variations', '(left, right)', 'Combine two extremal curve values with the natural operation for Calculus of Variations.', 'professional_function_catalog.md'), + ('calculusOfVariationsCombineFunctional', 'Calculus of Variations', '(left, right)', 'Combine two functional values with the natural operation for Calculus of Variations.', 'professional_function_catalog.md'), + ('calculusOfVariationsCombinePathEnergy', 'Calculus of Variations', '(left, right)', 'Combine two path energy values with the natural operation for Calculus of Variations.', 'professional_function_catalog.md'), + ('calculusOfVariationsCombineVariation', 'Calculus of Variations', '(left, right)', 'Combine two variation values with the natural operation for Calculus of Variations.', 'professional_function_catalog.md'), + ('calculusOfVariationsCompareEulerLagrangeResidual', 'Calculus of Variations', '(left, right)', 'Compare two Euler Lagrange residual values under the conventions of Calculus of Variations.', 'professional_function_catalog.md'), + ('calculusOfVariationsCompareExtremalCurve', 'Calculus of Variations', '(left, right)', 'Compare two extremal curve values under the conventions of Calculus of Variations.', 'professional_function_catalog.md'), + ('calculusOfVariationsCompareFunctional', 'Calculus of Variations', '(left, right)', 'Compare two functional values under the conventions of Calculus of Variations.', 'professional_function_catalog.md'), + ('calculusOfVariationsComparePathEnergy', 'Calculus of Variations', '(left, right)', 'Compare two path energy values under the conventions of Calculus of Variations.', 'professional_function_catalog.md'), + ('calculusOfVariationsCompareVariation', 'Calculus of Variations', '(left, right)', 'Compare two variation values under the conventions of Calculus of Variations.', 'professional_function_catalog.md'), + ('calculusOfVariationsComputeEulerLagrangeResidual', 'Calculus of Variations', '(value)', 'Compute the central numerical or symbolic data of a Euler Lagrange residual.', 'professional_function_catalog.md'), + ('calculusOfVariationsComputeExtremalCurve', 'Calculus of Variations', '(value)', 'Compute the central numerical or symbolic data of a extremal curve.', 'professional_function_catalog.md'), + ('calculusOfVariationsComputeFunctional', 'Calculus of Variations', '(value)', 'Compute the central numerical or symbolic data of a functional.', 'professional_function_catalog.md'), + ('calculusOfVariationsComputePathEnergy', 'Calculus of Variations', '(value)', 'Compute the central numerical or symbolic data of a path energy.', 'professional_function_catalog.md'), + ('calculusOfVariationsComputeVariation', 'Calculus of Variations', '(value)', 'Compute the central numerical or symbolic data of a variation.', 'professional_function_catalog.md'), + ('calculusOfVariationsConstructEulerLagrangeResidual', 'Calculus of Variations', '(*args)', 'Construct a Euler Lagrange residual from explicit inputs for Calculus of Variations.', 'professional_function_catalog.md'), + ('calculusOfVariationsConstructExtremalCurve', 'Calculus of Variations', '(*args)', 'Construct a extremal curve from explicit inputs for Calculus of Variations.', 'professional_function_catalog.md'), + ('calculusOfVariationsConstructFunctional', 'Calculus of Variations', '(*args)', 'Construct a functional from explicit inputs for Calculus of Variations.', 'professional_function_catalog.md'), + ('calculusOfVariationsConstructPathEnergy', 'Calculus of Variations', '(*args)', 'Construct a path energy from explicit inputs for Calculus of Variations.', 'professional_function_catalog.md'), + ('calculusOfVariationsConstructVariation', 'Calculus of Variations', '(*args)', 'Construct a variation from explicit inputs for Calculus of Variations.', 'professional_function_catalog.md'), + ('calculusOfVariationsDecomposeEulerLagrangeResidual', 'Calculus of Variations', '(value)', 'Decompose a Euler Lagrange residual into simpler or canonical components.', 'professional_function_catalog.md'), + ('calculusOfVariationsDecomposeExtremalCurve', 'Calculus of Variations', '(value)', 'Decompose a extremal curve into simpler or canonical components.', 'professional_function_catalog.md'), + ('calculusOfVariationsDecomposeFunctional', 'Calculus of Variations', '(value)', 'Decompose a functional into simpler or canonical components.', 'professional_function_catalog.md'), + ('calculusOfVariationsDecomposePathEnergy', 'Calculus of Variations', '(value)', 'Decompose a path energy into simpler or canonical components.', 'professional_function_catalog.md'), + ('calculusOfVariationsDecomposeVariation', 'Calculus of Variations', '(value)', 'Decompose a variation into simpler or canonical components.', 'professional_function_catalog.md'), + ('calculusOfVariationsDocumentEulerLagrangeResidual', 'Calculus of Variations', '(value)', 'Return a structured explanation of a Euler Lagrange residual and related assumptions.', 'professional_function_catalog.md'), + ('calculusOfVariationsDocumentExtremalCurve', 'Calculus of Variations', '(value)', 'Return a structured explanation of a extremal curve and related assumptions.', 'professional_function_catalog.md'), + ('calculusOfVariationsDocumentFunctional', 'Calculus of Variations', '(value)', 'Return a structured explanation of a functional and related assumptions.', 'professional_function_catalog.md'), + ('calculusOfVariationsDocumentPathEnergy', 'Calculus of Variations', '(value)', 'Return a structured explanation of a path energy and related assumptions.', 'professional_function_catalog.md'), + ('calculusOfVariationsDocumentVariation', 'Calculus of Variations', '(value)', 'Return a structured explanation of a variation and related assumptions.', 'professional_function_catalog.md'), + ('calculusOfVariationsEnumerateEulerLagrangeResidual', 'Calculus of Variations', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a Euler Lagrange residual.', 'professional_function_catalog.md'), + ('calculusOfVariationsEnumerateExtremalCurve', 'Calculus of Variations', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a extremal curve.', 'professional_function_catalog.md'), + ('calculusOfVariationsEnumerateFunctional', 'Calculus of Variations', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a functional.', 'professional_function_catalog.md'), + ('calculusOfVariationsEnumeratePathEnergy', 'Calculus of Variations', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a path energy.', 'professional_function_catalog.md'), + ('calculusOfVariationsEnumerateVariation', 'Calculus of Variations', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a variation.', 'professional_function_catalog.md'), + ('calculusOfVariationsEstimateEulerLagrangeResidual', 'Calculus of Variations', '(value, samples=None)', 'Estimate a Euler Lagrange residual property from finite samples or approximations.', 'professional_function_catalog.md'), + ('calculusOfVariationsEstimateExtremalCurve', 'Calculus of Variations', '(value, samples=None)', 'Estimate a extremal curve property from finite samples or approximations.', 'professional_function_catalog.md'), + ('calculusOfVariationsEstimateFunctional', 'Calculus of Variations', '(value, samples=None)', 'Estimate a functional property from finite samples or approximations.', 'professional_function_catalog.md'), + ('calculusOfVariationsEstimatePathEnergy', 'Calculus of Variations', '(value, samples=None)', 'Estimate a path energy property from finite samples or approximations.', 'professional_function_catalog.md'), + ('calculusOfVariationsEstimateVariation', 'Calculus of Variations', '(value, samples=None)', 'Estimate a variation property from finite samples or approximations.', 'professional_function_catalog.md'), + ('calculusOfVariationsEvaluateEulerLagrangeResidual', 'Calculus of Variations', '(value, point=None)', 'Evaluate a Euler Lagrange residual at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('calculusOfVariationsEvaluateExtremalCurve', 'Calculus of Variations', '(value, point=None)', 'Evaluate a extremal curve at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('calculusOfVariationsEvaluateFunctional', 'Calculus of Variations', '(value, point=None)', 'Evaluate a functional at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('calculusOfVariationsEvaluatePathEnergy', 'Calculus of Variations', '(value, point=None)', 'Evaluate a path energy at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('calculusOfVariationsEvaluateVariation', 'Calculus of Variations', '(value, point=None)', 'Evaluate a variation at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('calculusOfVariationsFormatEulerLagrangeResidual', 'Calculus of Variations', '(value)', 'Format a Euler Lagrange residual for deterministic user-facing output.', 'professional_function_catalog.md'), + ('calculusOfVariationsFormatExtremalCurve', 'Calculus of Variations', '(value)', 'Format a extremal curve for deterministic user-facing output.', 'professional_function_catalog.md'), + ('calculusOfVariationsFormatFunctional', 'Calculus of Variations', '(value)', 'Format a functional for deterministic user-facing output.', 'professional_function_catalog.md'), + ('calculusOfVariationsFormatPathEnergy', 'Calculus of Variations', '(value)', 'Format a path energy for deterministic user-facing output.', 'professional_function_catalog.md'), + ('calculusOfVariationsFormatVariation', 'Calculus of Variations', '(value)', 'Format a variation for deterministic user-facing output.', 'professional_function_catalog.md'), + ('calculusOfVariationsGenerateExampleEulerLagrangeResidual', 'Calculus of Variations', '(size=3)', 'Generate a small documented example of a Euler Lagrange residual.', 'professional_function_catalog.md'), + ('calculusOfVariationsGenerateExampleExtremalCurve', 'Calculus of Variations', '(size=3)', 'Generate a small documented example of a extremal curve.', 'professional_function_catalog.md'), + ('calculusOfVariationsGenerateExampleFunctional', 'Calculus of Variations', '(size=3)', 'Generate a small documented example of a functional.', 'professional_function_catalog.md'), + ('calculusOfVariationsGenerateExamplePathEnergy', 'Calculus of Variations', '(size=3)', 'Generate a small documented example of a path energy.', 'professional_function_catalog.md'), + ('calculusOfVariationsGenerateExampleVariation', 'Calculus of Variations', '(size=3)', 'Generate a small documented example of a variation.', 'professional_function_catalog.md'), + ('calculusOfVariationsNormalizeEulerLagrangeResidual', 'Calculus of Variations', '(value)', 'Normalize a Euler Lagrange residual into the standard Calculus of Variations representation.', 'professional_function_catalog.md'), + ('calculusOfVariationsNormalizeExtremalCurve', 'Calculus of Variations', '(value)', 'Normalize a extremal curve into the standard Calculus of Variations representation.', 'professional_function_catalog.md'), + ('calculusOfVariationsNormalizeFunctional', 'Calculus of Variations', '(value)', 'Normalize a functional into the standard Calculus of Variations representation.', 'professional_function_catalog.md'), + ('calculusOfVariationsNormalizePathEnergy', 'Calculus of Variations', '(value)', 'Normalize a path energy into the standard Calculus of Variations representation.', 'professional_function_catalog.md'), + ('calculusOfVariationsNormalizeVariation', 'Calculus of Variations', '(value)', 'Normalize a variation into the standard Calculus of Variations representation.', 'professional_function_catalog.md'), + ('calculusOfVariationsParseEulerLagrangeResidual', 'Calculus of Variations', '(text)', 'Parse a text or structured value into a Euler Lagrange residual.', 'professional_function_catalog.md'), + ('calculusOfVariationsParseExtremalCurve', 'Calculus of Variations', '(text)', 'Parse a text or structured value into a extremal curve.', 'professional_function_catalog.md'), + ('calculusOfVariationsParseFunctional', 'Calculus of Variations', '(text)', 'Parse a text or structured value into a functional.', 'professional_function_catalog.md'), + ('calculusOfVariationsParsePathEnergy', 'Calculus of Variations', '(text)', 'Parse a text or structured value into a path energy.', 'professional_function_catalog.md'), + ('calculusOfVariationsParseVariation', 'Calculus of Variations', '(text)', 'Parse a text or structured value into a variation.', 'professional_function_catalog.md'), + ('calculusOfVariationsSimplifyEulerLagrangeResidual', 'Calculus of Variations', '(value)', 'Simplify a Euler Lagrange residual without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('calculusOfVariationsSimplifyExtremalCurve', 'Calculus of Variations', '(value)', 'Simplify a extremal curve without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('calculusOfVariationsSimplifyFunctional', 'Calculus of Variations', '(value)', 'Simplify a functional without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('calculusOfVariationsSimplifyPathEnergy', 'Calculus of Variations', '(value)', 'Simplify a path energy without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('calculusOfVariationsSimplifyVariation', 'Calculus of Variations', '(value)', 'Simplify a variation without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('calculusOfVariationsTestEquivalenceEulerLagrangeResidual', 'Calculus of Variations', '(left, right)', 'Test whether two Euler Lagrange residual values are equivalent in Calculus of Variations.', 'professional_function_catalog.md'), + ('calculusOfVariationsTestEquivalenceExtremalCurve', 'Calculus of Variations', '(left, right)', 'Test whether two extremal curve values are equivalent in Calculus of Variations.', 'professional_function_catalog.md'), + ('calculusOfVariationsTestEquivalenceFunctional', 'Calculus of Variations', '(left, right)', 'Test whether two functional values are equivalent in Calculus of Variations.', 'professional_function_catalog.md'), + ('calculusOfVariationsTestEquivalencePathEnergy', 'Calculus of Variations', '(left, right)', 'Test whether two path energy values are equivalent in Calculus of Variations.', 'professional_function_catalog.md'), + ('calculusOfVariationsTestEquivalenceVariation', 'Calculus of Variations', '(left, right)', 'Test whether two variation values are equivalent in Calculus of Variations.', 'professional_function_catalog.md'), + ('calculusOfVariationsTransformEulerLagrangeResidual', 'Calculus of Variations', '(value, mapping)', 'Transform a Euler Lagrange residual through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('calculusOfVariationsTransformExtremalCurve', 'Calculus of Variations', '(value, mapping)', 'Transform a extremal curve through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('calculusOfVariationsTransformFunctional', 'Calculus of Variations', '(value, mapping)', 'Transform a functional through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('calculusOfVariationsTransformPathEnergy', 'Calculus of Variations', '(value, mapping)', 'Transform a path energy through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('calculusOfVariationsTransformVariation', 'Calculus of Variations', '(value, mapping)', 'Transform a variation through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('calculusOfVariationsValidateEulerLagrangeResidual', 'Calculus of Variations', '(value)', 'Validate the Euler Lagrange residual representation and domain rules for Calculus of Variations.', 'professional_function_catalog.md'), + ('calculusOfVariationsValidateExtremalCurve', 'Calculus of Variations', '(value)', 'Validate the extremal curve representation and domain rules for Calculus of Variations.', 'professional_function_catalog.md'), + ('calculusOfVariationsValidateFunctional', 'Calculus of Variations', '(value)', 'Validate the functional representation and domain rules for Calculus of Variations.', 'professional_function_catalog.md'), + ('calculusOfVariationsValidatePathEnergy', 'Calculus of Variations', '(value)', 'Validate the path energy representation and domain rules for Calculus of Variations.', 'professional_function_catalog.md'), + ('calculusOfVariationsValidateVariation', 'Calculus of Variations', '(value)', 'Validate the variation representation and domain rules for Calculus of Variations.', 'professional_function_catalog.md'), + ('energyFunctional', 'Calculus of Variations', '(path)', 'Planned roadmap function for Calculus of Variations from upcoming.md.', 'upcoming.md'), + ('eulerLagrangeResidual', 'Calculus of Variations', '(lagrangian, path, tValues)', 'Planned roadmap function for Calculus of Variations from upcoming.md.', 'upcoming.md'), + ('firstVariation', 'Calculus of Variations', '(functional, path, perturbation)', 'Planned roadmap function for Calculus of Variations from upcoming.md.', 'upcoming.md'), + ('functionalPathIntegral', 'Calculus of Variations', '(lagrangian, path, tValues)', 'Planned roadmap function for Calculus of Variations from upcoming.md.', 'upcoming.md'), + ('gradientDescentPath', 'Calculus of Variations', '(functional, path, step, iterations)', 'Planned roadmap function for Calculus of Variations from upcoming.md.', 'upcoming.md'), + ('shortestPathFunctional', 'Calculus of Variations', '(path)', 'Planned roadmap function for Calculus of Variations from upcoming.md.', 'upcoming.md'), + ('variationPath', 'Calculus of Variations', '(path, perturbation, epsilon)', 'Planned roadmap function for Calculus of Variations from upcoming.md.', 'upcoming.md'), + ('categoryTheoryApproximateCategory', 'Category Theory', '(value, tolerance=1e-9)', 'Approximate a category with explicit tolerance controls.', 'professional_function_catalog.md'), + ('categoryTheoryApproximateFunctor', 'Category Theory', '(value, tolerance=1e-9)', 'Approximate a functor with explicit tolerance controls.', 'professional_function_catalog.md'), + ('categoryTheoryApproximateMorphism', 'Category Theory', '(value, tolerance=1e-9)', 'Approximate a morphism with explicit tolerance controls.', 'professional_function_catalog.md'), + ('categoryTheoryApproximateNaturalTransformation', 'Category Theory', '(value, tolerance=1e-9)', 'Approximate a natural transformation with explicit tolerance controls.', 'professional_function_catalog.md'), + ('categoryTheoryApproximateObject', 'Category Theory', '(value, tolerance=1e-9)', 'Approximate a object with explicit tolerance controls.', 'professional_function_catalog.md'), + ('categoryTheoryCanonicalizeCategory', 'Category Theory', '(value)', 'Canonicalize a category so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('categoryTheoryCanonicalizeFunctor', 'Category Theory', '(value)', 'Canonicalize a functor so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('categoryTheoryCanonicalizeMorphism', 'Category Theory', '(value)', 'Canonicalize a morphism so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('categoryTheoryCanonicalizeNaturalTransformation', 'Category Theory', '(value)', 'Canonicalize a natural transformation so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('categoryTheoryCanonicalizeObject', 'Category Theory', '(value)', 'Canonicalize a object so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('categoryTheoryClassifyCategory', 'Category Theory', '(value)', 'Classify a category by its standard Category Theory invariants.', 'professional_function_catalog.md'), + ('categoryTheoryClassifyFunctor', 'Category Theory', '(value)', 'Classify a functor by its standard Category Theory invariants.', 'professional_function_catalog.md'), + ('categoryTheoryClassifyMorphism', 'Category Theory', '(value)', 'Classify a morphism by its standard Category Theory invariants.', 'professional_function_catalog.md'), + ('categoryTheoryClassifyNaturalTransformation', 'Category Theory', '(value)', 'Classify a natural transformation by its standard Category Theory invariants.', 'professional_function_catalog.md'), + ('categoryTheoryClassifyObject', 'Category Theory', '(value)', 'Classify a object by its standard Category Theory invariants.', 'professional_function_catalog.md'), + ('categoryTheoryCombineCategory', 'Category Theory', '(left, right)', 'Combine two category values with the natural operation for Category Theory.', 'professional_function_catalog.md'), + ('categoryTheoryCombineFunctor', 'Category Theory', '(left, right)', 'Combine two functor values with the natural operation for Category Theory.', 'professional_function_catalog.md'), + ('categoryTheoryCombineMorphism', 'Category Theory', '(left, right)', 'Combine two morphism values with the natural operation for Category Theory.', 'professional_function_catalog.md'), + ('categoryTheoryCombineNaturalTransformation', 'Category Theory', '(left, right)', 'Combine two natural transformation values with the natural operation for Category Theory.', 'professional_function_catalog.md'), + ('categoryTheoryCombineObject', 'Category Theory', '(left, right)', 'Combine two object values with the natural operation for Category Theory.', 'professional_function_catalog.md'), + ('categoryTheoryCompareCategory', 'Category Theory', '(left, right)', 'Compare two category values under the conventions of Category Theory.', 'professional_function_catalog.md'), + ('categoryTheoryCompareFunctor', 'Category Theory', '(left, right)', 'Compare two functor values under the conventions of Category Theory.', 'professional_function_catalog.md'), + ('categoryTheoryCompareMorphism', 'Category Theory', '(left, right)', 'Compare two morphism values under the conventions of Category Theory.', 'professional_function_catalog.md'), + ('categoryTheoryCompareNaturalTransformation', 'Category Theory', '(left, right)', 'Compare two natural transformation values under the conventions of Category Theory.', 'professional_function_catalog.md'), + ('categoryTheoryCompareObject', 'Category Theory', '(left, right)', 'Compare two object values under the conventions of Category Theory.', 'professional_function_catalog.md'), + ('categoryTheoryComputeCategory', 'Category Theory', '(value)', 'Compute the central numerical or symbolic data of a category.', 'professional_function_catalog.md'), + ('categoryTheoryComputeFunctor', 'Category Theory', '(value)', 'Compute the central numerical or symbolic data of a functor.', 'professional_function_catalog.md'), + ('categoryTheoryComputeMorphism', 'Category Theory', '(value)', 'Compute the central numerical or symbolic data of a morphism.', 'professional_function_catalog.md'), + ('categoryTheoryComputeNaturalTransformation', 'Category Theory', '(value)', 'Compute the central numerical or symbolic data of a natural transformation.', 'professional_function_catalog.md'), + ('categoryTheoryComputeObject', 'Category Theory', '(value)', 'Compute the central numerical or symbolic data of a object.', 'professional_function_catalog.md'), + ('categoryTheoryConstructCategory', 'Category Theory', '(*args)', 'Construct a category from explicit inputs for Category Theory.', 'professional_function_catalog.md'), + ('categoryTheoryConstructFunctor', 'Category Theory', '(*args)', 'Construct a functor from explicit inputs for Category Theory.', 'professional_function_catalog.md'), + ('categoryTheoryConstructMorphism', 'Category Theory', '(*args)', 'Construct a morphism from explicit inputs for Category Theory.', 'professional_function_catalog.md'), + ('categoryTheoryConstructNaturalTransformation', 'Category Theory', '(*args)', 'Construct a natural transformation from explicit inputs for Category Theory.', 'professional_function_catalog.md'), + ('categoryTheoryConstructObject', 'Category Theory', '(*args)', 'Construct a object from explicit inputs for Category Theory.', 'professional_function_catalog.md'), + ('categoryTheoryDecomposeCategory', 'Category Theory', '(value)', 'Decompose a category into simpler or canonical components.', 'professional_function_catalog.md'), + ('categoryTheoryDecomposeFunctor', 'Category Theory', '(value)', 'Decompose a functor into simpler or canonical components.', 'professional_function_catalog.md'), + ('categoryTheoryDecomposeMorphism', 'Category Theory', '(value)', 'Decompose a morphism into simpler or canonical components.', 'professional_function_catalog.md'), + ('categoryTheoryDecomposeNaturalTransformation', 'Category Theory', '(value)', 'Decompose a natural transformation into simpler or canonical components.', 'professional_function_catalog.md'), + ('categoryTheoryDecomposeObject', 'Category Theory', '(value)', 'Decompose a object into simpler or canonical components.', 'professional_function_catalog.md'), + ('categoryTheoryDocumentCategory', 'Category Theory', '(value)', 'Return a structured explanation of a category and related assumptions.', 'professional_function_catalog.md'), + ('categoryTheoryDocumentFunctor', 'Category Theory', '(value)', 'Return a structured explanation of a functor and related assumptions.', 'professional_function_catalog.md'), + ('categoryTheoryDocumentMorphism', 'Category Theory', '(value)', 'Return a structured explanation of a morphism and related assumptions.', 'professional_function_catalog.md'), + ('categoryTheoryDocumentNaturalTransformation', 'Category Theory', '(value)', 'Return a structured explanation of a natural transformation and related assumptions.', 'professional_function_catalog.md'), + ('categoryTheoryDocumentObject', 'Category Theory', '(value)', 'Return a structured explanation of a object and related assumptions.', 'professional_function_catalog.md'), + ('categoryTheoryEnumerateCategory', 'Category Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a category.', 'professional_function_catalog.md'), + ('categoryTheoryEnumerateFunctor', 'Category Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a functor.', 'professional_function_catalog.md'), + ('categoryTheoryEnumerateMorphism', 'Category Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a morphism.', 'professional_function_catalog.md'), + ('categoryTheoryEnumerateNaturalTransformation', 'Category Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a natural transformation.', 'professional_function_catalog.md'), + ('categoryTheoryEnumerateObject', 'Category Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a object.', 'professional_function_catalog.md'), + ('categoryTheoryEstimateCategory', 'Category Theory', '(value, samples=None)', 'Estimate a category property from finite samples or approximations.', 'professional_function_catalog.md'), + ('categoryTheoryEstimateFunctor', 'Category Theory', '(value, samples=None)', 'Estimate a functor property from finite samples or approximations.', 'professional_function_catalog.md'), + ('categoryTheoryEstimateMorphism', 'Category Theory', '(value, samples=None)', 'Estimate a morphism property from finite samples or approximations.', 'professional_function_catalog.md'), + ('categoryTheoryEstimateNaturalTransformation', 'Category Theory', '(value, samples=None)', 'Estimate a natural transformation property from finite samples or approximations.', 'professional_function_catalog.md'), + ('categoryTheoryEstimateObject', 'Category Theory', '(value, samples=None)', 'Estimate a object property from finite samples or approximations.', 'professional_function_catalog.md'), + ('categoryTheoryEvaluateCategory', 'Category Theory', '(value, point=None)', 'Evaluate a category at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('categoryTheoryEvaluateFunctor', 'Category Theory', '(value, point=None)', 'Evaluate a functor at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('categoryTheoryEvaluateMorphism', 'Category Theory', '(value, point=None)', 'Evaluate a morphism at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('categoryTheoryEvaluateNaturalTransformation', 'Category Theory', '(value, point=None)', 'Evaluate a natural transformation at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('categoryTheoryEvaluateObject', 'Category Theory', '(value, point=None)', 'Evaluate a object at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('categoryTheoryFormatCategory', 'Category Theory', '(value)', 'Format a category for deterministic user-facing output.', 'professional_function_catalog.md'), + ('categoryTheoryFormatFunctor', 'Category Theory', '(value)', 'Format a functor for deterministic user-facing output.', 'professional_function_catalog.md'), + ('categoryTheoryFormatMorphism', 'Category Theory', '(value)', 'Format a morphism for deterministic user-facing output.', 'professional_function_catalog.md'), + ('categoryTheoryFormatNaturalTransformation', 'Category Theory', '(value)', 'Format a natural transformation for deterministic user-facing output.', 'professional_function_catalog.md'), + ('categoryTheoryFormatObject', 'Category Theory', '(value)', 'Format a object for deterministic user-facing output.', 'professional_function_catalog.md'), + ('categoryTheoryGenerateExampleCategory', 'Category Theory', '(size=3)', 'Generate a small documented example of a category.', 'professional_function_catalog.md'), + ('categoryTheoryGenerateExampleFunctor', 'Category Theory', '(size=3)', 'Generate a small documented example of a functor.', 'professional_function_catalog.md'), + ('categoryTheoryGenerateExampleMorphism', 'Category Theory', '(size=3)', 'Generate a small documented example of a morphism.', 'professional_function_catalog.md'), + ('categoryTheoryGenerateExampleNaturalTransformation', 'Category Theory', '(size=3)', 'Generate a small documented example of a natural transformation.', 'professional_function_catalog.md'), + ('categoryTheoryGenerateExampleObject', 'Category Theory', '(size=3)', 'Generate a small documented example of a object.', 'professional_function_catalog.md'), + ('categoryTheoryNormalizeCategory', 'Category Theory', '(value)', 'Normalize a category into the standard Category Theory representation.', 'professional_function_catalog.md'), + ('categoryTheoryNormalizeFunctor', 'Category Theory', '(value)', 'Normalize a functor into the standard Category Theory representation.', 'professional_function_catalog.md'), + ('categoryTheoryNormalizeMorphism', 'Category Theory', '(value)', 'Normalize a morphism into the standard Category Theory representation.', 'professional_function_catalog.md'), + ('categoryTheoryNormalizeNaturalTransformation', 'Category Theory', '(value)', 'Normalize a natural transformation into the standard Category Theory representation.', 'professional_function_catalog.md'), + ('categoryTheoryNormalizeObject', 'Category Theory', '(value)', 'Normalize a object into the standard Category Theory representation.', 'professional_function_catalog.md'), + ('categoryTheoryParseCategory', 'Category Theory', '(text)', 'Parse a text or structured value into a category.', 'professional_function_catalog.md'), + ('categoryTheoryParseFunctor', 'Category Theory', '(text)', 'Parse a text or structured value into a functor.', 'professional_function_catalog.md'), + ('categoryTheoryParseMorphism', 'Category Theory', '(text)', 'Parse a text or structured value into a morphism.', 'professional_function_catalog.md'), + ('categoryTheoryParseNaturalTransformation', 'Category Theory', '(text)', 'Parse a text or structured value into a natural transformation.', 'professional_function_catalog.md'), + ('categoryTheoryParseObject', 'Category Theory', '(text)', 'Parse a text or structured value into a object.', 'professional_function_catalog.md'), + ('categoryTheorySimplifyCategory', 'Category Theory', '(value)', 'Simplify a category without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('categoryTheorySimplifyFunctor', 'Category Theory', '(value)', 'Simplify a functor without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('categoryTheorySimplifyMorphism', 'Category Theory', '(value)', 'Simplify a morphism without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('categoryTheorySimplifyNaturalTransformation', 'Category Theory', '(value)', 'Simplify a natural transformation without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('categoryTheorySimplifyObject', 'Category Theory', '(value)', 'Simplify a object without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('categoryTheoryTestEquivalenceCategory', 'Category Theory', '(left, right)', 'Test whether two category values are equivalent in Category Theory.', 'professional_function_catalog.md'), + ('categoryTheoryTestEquivalenceFunctor', 'Category Theory', '(left, right)', 'Test whether two functor values are equivalent in Category Theory.', 'professional_function_catalog.md'), + ('categoryTheoryTestEquivalenceMorphism', 'Category Theory', '(left, right)', 'Test whether two morphism values are equivalent in Category Theory.', 'professional_function_catalog.md'), + ('categoryTheoryTestEquivalenceNaturalTransformation', 'Category Theory', '(left, right)', 'Test whether two natural transformation values are equivalent in Category Theory.', 'professional_function_catalog.md'), + ('categoryTheoryTestEquivalenceObject', 'Category Theory', '(left, right)', 'Test whether two object values are equivalent in Category Theory.', 'professional_function_catalog.md'), + ('categoryTheoryTransformCategory', 'Category Theory', '(value, mapping)', 'Transform a category through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('categoryTheoryTransformFunctor', 'Category Theory', '(value, mapping)', 'Transform a functor through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('categoryTheoryTransformMorphism', 'Category Theory', '(value, mapping)', 'Transform a morphism through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('categoryTheoryTransformNaturalTransformation', 'Category Theory', '(value, mapping)', 'Transform a natural transformation through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('categoryTheoryTransformObject', 'Category Theory', '(value, mapping)', 'Transform a object through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('categoryTheoryValidateCategory', 'Category Theory', '(value)', 'Validate the category representation and domain rules for Category Theory.', 'professional_function_catalog.md'), + ('categoryTheoryValidateFunctor', 'Category Theory', '(value)', 'Validate the functor representation and domain rules for Category Theory.', 'professional_function_catalog.md'), + ('categoryTheoryValidateMorphism', 'Category Theory', '(value)', 'Validate the morphism representation and domain rules for Category Theory.', 'professional_function_catalog.md'), + ('categoryTheoryValidateNaturalTransformation', 'Category Theory', '(value)', 'Validate the natural transformation representation and domain rules for Category Theory.', 'professional_function_catalog.md'), + ('categoryTheoryValidateObject', 'Category Theory', '(value)', 'Validate the object representation and domain rules for Category Theory.', 'professional_function_catalog.md'), + ('isCategory', 'Category Theory', '(objects, morphisms, compose, identity)', 'Planned roadmap function for Category Theory from upcoming.md.', 'upcoming.md'), + ('isFunctor', 'Category Theory', '(sourceCategory, targetCategory, objectMap, morphismMap)', 'Planned roadmap function for Category Theory from upcoming.md.', 'upcoming.md'), + ('naturalTransformation', 'Category Theory', '(functorF, functorG, components)', 'Planned roadmap function for Category Theory from upcoming.md.', 'upcoming.md'), + ('oppositeCategory', 'Category Theory', '(category)', 'Planned roadmap function for Category Theory from upcoming.md.', 'upcoming.md'), + ('productCategory', 'Category Theory', '(categoryA, categoryB)', 'Planned roadmap function for Category Theory from upcoming.md.', 'upcoming.md'), + ('bifurcationDataLogistic', 'Chaos Theory', '(rValues, x0, burnIn, samples)', 'Planned roadmap function for Chaos Theory from upcoming.md.', 'upcoming.md'), + ('chaosGame', 'Chaos Theory', '(vertices, ratios, choices, start)', 'Planned roadmap function for Chaos Theory from upcoming.md.', 'upcoming.md'), + ('chaosTheoryApproximateAttractor', 'Chaos Theory', '(value, tolerance=1e-9)', 'Approximate a attractor with explicit tolerance controls.', 'professional_function_catalog.md'), + ('chaosTheoryApproximateBifurcationSample', 'Chaos Theory', '(value, tolerance=1e-9)', 'Approximate a bifurcation sample with explicit tolerance controls.', 'professional_function_catalog.md'), + ('chaosTheoryApproximateChaoticMap', 'Chaos Theory', '(value, tolerance=1e-9)', 'Approximate a chaotic map with explicit tolerance controls.', 'professional_function_catalog.md'), + ('chaosTheoryApproximateLyapunovEstimate', 'Chaos Theory', '(value, tolerance=1e-9)', 'Approximate a Lyapunov estimate with explicit tolerance controls.', 'professional_function_catalog.md'), + ('chaosTheoryApproximateSensitiveOrbit', 'Chaos Theory', '(value, tolerance=1e-9)', 'Approximate a sensitive orbit with explicit tolerance controls.', 'professional_function_catalog.md'), + ('chaosTheoryCanonicalizeAttractor', 'Chaos Theory', '(value)', 'Canonicalize a attractor so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('chaosTheoryCanonicalizeBifurcationSample', 'Chaos Theory', '(value)', 'Canonicalize a bifurcation sample so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('chaosTheoryCanonicalizeChaoticMap', 'Chaos Theory', '(value)', 'Canonicalize a chaotic map so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('chaosTheoryCanonicalizeLyapunovEstimate', 'Chaos Theory', '(value)', 'Canonicalize a Lyapunov estimate so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('chaosTheoryCanonicalizeSensitiveOrbit', 'Chaos Theory', '(value)', 'Canonicalize a sensitive orbit so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('chaosTheoryClassifyAttractor', 'Chaos Theory', '(value)', 'Classify a attractor by its standard Chaos Theory invariants.', 'professional_function_catalog.md'), + ('chaosTheoryClassifyBifurcationSample', 'Chaos Theory', '(value)', 'Classify a bifurcation sample by its standard Chaos Theory invariants.', 'professional_function_catalog.md'), + ('chaosTheoryClassifyChaoticMap', 'Chaos Theory', '(value)', 'Classify a chaotic map by its standard Chaos Theory invariants.', 'professional_function_catalog.md'), + ('chaosTheoryClassifyLyapunovEstimate', 'Chaos Theory', '(value)', 'Classify a Lyapunov estimate by its standard Chaos Theory invariants.', 'professional_function_catalog.md'), + ('chaosTheoryClassifySensitiveOrbit', 'Chaos Theory', '(value)', 'Classify a sensitive orbit by its standard Chaos Theory invariants.', 'professional_function_catalog.md'), + ('chaosTheoryCombineAttractor', 'Chaos Theory', '(left, right)', 'Combine two attractor values with the natural operation for Chaos Theory.', 'professional_function_catalog.md'), + ('chaosTheoryCombineBifurcationSample', 'Chaos Theory', '(left, right)', 'Combine two bifurcation sample values with the natural operation for Chaos Theory.', 'professional_function_catalog.md'), + ('chaosTheoryCombineChaoticMap', 'Chaos Theory', '(left, right)', 'Combine two chaotic map values with the natural operation for Chaos Theory.', 'professional_function_catalog.md'), + ('chaosTheoryCombineLyapunovEstimate', 'Chaos Theory', '(left, right)', 'Combine two Lyapunov estimate values with the natural operation for Chaos Theory.', 'professional_function_catalog.md'), + ('chaosTheoryCombineSensitiveOrbit', 'Chaos Theory', '(left, right)', 'Combine two sensitive orbit values with the natural operation for Chaos Theory.', 'professional_function_catalog.md'), + ('chaosTheoryCompareAttractor', 'Chaos Theory', '(left, right)', 'Compare two attractor values under the conventions of Chaos Theory.', 'professional_function_catalog.md'), + ('chaosTheoryCompareBifurcationSample', 'Chaos Theory', '(left, right)', 'Compare two bifurcation sample values under the conventions of Chaos Theory.', 'professional_function_catalog.md'), + ('chaosTheoryCompareChaoticMap', 'Chaos Theory', '(left, right)', 'Compare two chaotic map values under the conventions of Chaos Theory.', 'professional_function_catalog.md'), + ('chaosTheoryCompareLyapunovEstimate', 'Chaos Theory', '(left, right)', 'Compare two Lyapunov estimate values under the conventions of Chaos Theory.', 'professional_function_catalog.md'), + ('chaosTheoryCompareSensitiveOrbit', 'Chaos Theory', '(left, right)', 'Compare two sensitive orbit values under the conventions of Chaos Theory.', 'professional_function_catalog.md'), + ('chaosTheoryComputeAttractor', 'Chaos Theory', '(value)', 'Compute the central numerical or symbolic data of a attractor.', 'professional_function_catalog.md'), + ('chaosTheoryComputeBifurcationSample', 'Chaos Theory', '(value)', 'Compute the central numerical or symbolic data of a bifurcation sample.', 'professional_function_catalog.md'), + ('chaosTheoryComputeChaoticMap', 'Chaos Theory', '(value)', 'Compute the central numerical or symbolic data of a chaotic map.', 'professional_function_catalog.md'), + ('chaosTheoryComputeLyapunovEstimate', 'Chaos Theory', '(value)', 'Compute the central numerical or symbolic data of a Lyapunov estimate.', 'professional_function_catalog.md'), + ('chaosTheoryComputeSensitiveOrbit', 'Chaos Theory', '(value)', 'Compute the central numerical or symbolic data of a sensitive orbit.', 'professional_function_catalog.md'), + ('chaosTheoryConstructAttractor', 'Chaos Theory', '(*args)', 'Construct a attractor from explicit inputs for Chaos Theory.', 'professional_function_catalog.md'), + ('chaosTheoryConstructBifurcationSample', 'Chaos Theory', '(*args)', 'Construct a bifurcation sample from explicit inputs for Chaos Theory.', 'professional_function_catalog.md'), + ('chaosTheoryConstructChaoticMap', 'Chaos Theory', '(*args)', 'Construct a chaotic map from explicit inputs for Chaos Theory.', 'professional_function_catalog.md'), + ('chaosTheoryConstructLyapunovEstimate', 'Chaos Theory', '(*args)', 'Construct a Lyapunov estimate from explicit inputs for Chaos Theory.', 'professional_function_catalog.md'), + ('chaosTheoryConstructSensitiveOrbit', 'Chaos Theory', '(*args)', 'Construct a sensitive orbit from explicit inputs for Chaos Theory.', 'professional_function_catalog.md'), + ('chaosTheoryDecomposeAttractor', 'Chaos Theory', '(value)', 'Decompose a attractor into simpler or canonical components.', 'professional_function_catalog.md'), + ('chaosTheoryDecomposeBifurcationSample', 'Chaos Theory', '(value)', 'Decompose a bifurcation sample into simpler or canonical components.', 'professional_function_catalog.md'), + ('chaosTheoryDecomposeChaoticMap', 'Chaos Theory', '(value)', 'Decompose a chaotic map into simpler or canonical components.', 'professional_function_catalog.md'), + ('chaosTheoryDecomposeLyapunovEstimate', 'Chaos Theory', '(value)', 'Decompose a Lyapunov estimate into simpler or canonical components.', 'professional_function_catalog.md'), + ('chaosTheoryDecomposeSensitiveOrbit', 'Chaos Theory', '(value)', 'Decompose a sensitive orbit into simpler or canonical components.', 'professional_function_catalog.md'), + ('chaosTheoryDocumentAttractor', 'Chaos Theory', '(value)', 'Return a structured explanation of a attractor and related assumptions.', 'professional_function_catalog.md'), + ('chaosTheoryDocumentBifurcationSample', 'Chaos Theory', '(value)', 'Return a structured explanation of a bifurcation sample and related assumptions.', 'professional_function_catalog.md'), + ('chaosTheoryDocumentChaoticMap', 'Chaos Theory', '(value)', 'Return a structured explanation of a chaotic map and related assumptions.', 'professional_function_catalog.md'), + ('chaosTheoryDocumentLyapunovEstimate', 'Chaos Theory', '(value)', 'Return a structured explanation of a Lyapunov estimate and related assumptions.', 'professional_function_catalog.md'), + ('chaosTheoryDocumentSensitiveOrbit', 'Chaos Theory', '(value)', 'Return a structured explanation of a sensitive orbit and related assumptions.', 'professional_function_catalog.md'), + ('chaosTheoryEnumerateAttractor', 'Chaos Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a attractor.', 'professional_function_catalog.md'), + ('chaosTheoryEnumerateBifurcationSample', 'Chaos Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a bifurcation sample.', 'professional_function_catalog.md'), + ('chaosTheoryEnumerateChaoticMap', 'Chaos Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a chaotic map.', 'professional_function_catalog.md'), + ('chaosTheoryEnumerateLyapunovEstimate', 'Chaos Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a Lyapunov estimate.', 'professional_function_catalog.md'), + ('chaosTheoryEnumerateSensitiveOrbit', 'Chaos Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a sensitive orbit.', 'professional_function_catalog.md'), + ('chaosTheoryEstimateAttractor', 'Chaos Theory', '(value, samples=None)', 'Estimate a attractor property from finite samples or approximations.', 'professional_function_catalog.md'), + ('chaosTheoryEstimateBifurcationSample', 'Chaos Theory', '(value, samples=None)', 'Estimate a bifurcation sample property from finite samples or approximations.', 'professional_function_catalog.md'), + ('chaosTheoryEstimateChaoticMap', 'Chaos Theory', '(value, samples=None)', 'Estimate a chaotic map property from finite samples or approximations.', 'professional_function_catalog.md'), + ('chaosTheoryEstimateLyapunovEstimate', 'Chaos Theory', '(value, samples=None)', 'Estimate a Lyapunov estimate property from finite samples or approximations.', 'professional_function_catalog.md'), + ('chaosTheoryEstimateSensitiveOrbit', 'Chaos Theory', '(value, samples=None)', 'Estimate a sensitive orbit property from finite samples or approximations.', 'professional_function_catalog.md'), + ('chaosTheoryEvaluateAttractor', 'Chaos Theory', '(value, point=None)', 'Evaluate a attractor at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('chaosTheoryEvaluateBifurcationSample', 'Chaos Theory', '(value, point=None)', 'Evaluate a bifurcation sample at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('chaosTheoryEvaluateChaoticMap', 'Chaos Theory', '(value, point=None)', 'Evaluate a chaotic map at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('chaosTheoryEvaluateLyapunovEstimate', 'Chaos Theory', '(value, point=None)', 'Evaluate a Lyapunov estimate at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('chaosTheoryEvaluateSensitiveOrbit', 'Chaos Theory', '(value, point=None)', 'Evaluate a sensitive orbit at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('chaosTheoryFormatAttractor', 'Chaos Theory', '(value)', 'Format a attractor for deterministic user-facing output.', 'professional_function_catalog.md'), + ('chaosTheoryFormatBifurcationSample', 'Chaos Theory', '(value)', 'Format a bifurcation sample for deterministic user-facing output.', 'professional_function_catalog.md'), + ('chaosTheoryFormatChaoticMap', 'Chaos Theory', '(value)', 'Format a chaotic map for deterministic user-facing output.', 'professional_function_catalog.md'), + ('chaosTheoryFormatLyapunovEstimate', 'Chaos Theory', '(value)', 'Format a Lyapunov estimate for deterministic user-facing output.', 'professional_function_catalog.md'), + ('chaosTheoryFormatSensitiveOrbit', 'Chaos Theory', '(value)', 'Format a sensitive orbit for deterministic user-facing output.', 'professional_function_catalog.md'), + ('chaosTheoryGenerateExampleAttractor', 'Chaos Theory', '(size=3)', 'Generate a small documented example of a attractor.', 'professional_function_catalog.md'), + ('chaosTheoryGenerateExampleBifurcationSample', 'Chaos Theory', '(size=3)', 'Generate a small documented example of a bifurcation sample.', 'professional_function_catalog.md'), + ('chaosTheoryGenerateExampleChaoticMap', 'Chaos Theory', '(size=3)', 'Generate a small documented example of a chaotic map.', 'professional_function_catalog.md'), + ('chaosTheoryGenerateExampleLyapunovEstimate', 'Chaos Theory', '(size=3)', 'Generate a small documented example of a Lyapunov estimate.', 'professional_function_catalog.md'), + ('chaosTheoryGenerateExampleSensitiveOrbit', 'Chaos Theory', '(size=3)', 'Generate a small documented example of a sensitive orbit.', 'professional_function_catalog.md'), + ('chaosTheoryNormalizeAttractor', 'Chaos Theory', '(value)', 'Normalize a attractor into the standard Chaos Theory representation.', 'professional_function_catalog.md'), + ('chaosTheoryNormalizeBifurcationSample', 'Chaos Theory', '(value)', 'Normalize a bifurcation sample into the standard Chaos Theory representation.', 'professional_function_catalog.md'), + ('chaosTheoryNormalizeChaoticMap', 'Chaos Theory', '(value)', 'Normalize a chaotic map into the standard Chaos Theory representation.', 'professional_function_catalog.md'), + ('chaosTheoryNormalizeLyapunovEstimate', 'Chaos Theory', '(value)', 'Normalize a Lyapunov estimate into the standard Chaos Theory representation.', 'professional_function_catalog.md'), + ('chaosTheoryNormalizeSensitiveOrbit', 'Chaos Theory', '(value)', 'Normalize a sensitive orbit into the standard Chaos Theory representation.', 'professional_function_catalog.md'), + ('chaosTheoryParseAttractor', 'Chaos Theory', '(text)', 'Parse a text or structured value into a attractor.', 'professional_function_catalog.md'), + ('chaosTheoryParseBifurcationSample', 'Chaos Theory', '(text)', 'Parse a text or structured value into a bifurcation sample.', 'professional_function_catalog.md'), + ('chaosTheoryParseChaoticMap', 'Chaos Theory', '(text)', 'Parse a text or structured value into a chaotic map.', 'professional_function_catalog.md'), + ('chaosTheoryParseLyapunovEstimate', 'Chaos Theory', '(text)', 'Parse a text or structured value into a Lyapunov estimate.', 'professional_function_catalog.md'), + ('chaosTheoryParseSensitiveOrbit', 'Chaos Theory', '(text)', 'Parse a text or structured value into a sensitive orbit.', 'professional_function_catalog.md'), + ('chaosTheorySimplifyAttractor', 'Chaos Theory', '(value)', 'Simplify a attractor without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('chaosTheorySimplifyBifurcationSample', 'Chaos Theory', '(value)', 'Simplify a bifurcation sample without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('chaosTheorySimplifyChaoticMap', 'Chaos Theory', '(value)', 'Simplify a chaotic map without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('chaosTheorySimplifyLyapunovEstimate', 'Chaos Theory', '(value)', 'Simplify a Lyapunov estimate without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('chaosTheorySimplifySensitiveOrbit', 'Chaos Theory', '(value)', 'Simplify a sensitive orbit without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('chaosTheoryTestEquivalenceAttractor', 'Chaos Theory', '(left, right)', 'Test whether two attractor values are equivalent in Chaos Theory.', 'professional_function_catalog.md'), + ('chaosTheoryTestEquivalenceBifurcationSample', 'Chaos Theory', '(left, right)', 'Test whether two bifurcation sample values are equivalent in Chaos Theory.', 'professional_function_catalog.md'), + ('chaosTheoryTestEquivalenceChaoticMap', 'Chaos Theory', '(left, right)', 'Test whether two chaotic map values are equivalent in Chaos Theory.', 'professional_function_catalog.md'), + ('chaosTheoryTestEquivalenceLyapunovEstimate', 'Chaos Theory', '(left, right)', 'Test whether two Lyapunov estimate values are equivalent in Chaos Theory.', 'professional_function_catalog.md'), + ('chaosTheoryTestEquivalenceSensitiveOrbit', 'Chaos Theory', '(left, right)', 'Test whether two sensitive orbit values are equivalent in Chaos Theory.', 'professional_function_catalog.md'), + ('chaosTheoryTransformAttractor', 'Chaos Theory', '(value, mapping)', 'Transform a attractor through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('chaosTheoryTransformBifurcationSample', 'Chaos Theory', '(value, mapping)', 'Transform a bifurcation sample through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('chaosTheoryTransformChaoticMap', 'Chaos Theory', '(value, mapping)', 'Transform a chaotic map through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('chaosTheoryTransformLyapunovEstimate', 'Chaos Theory', '(value, mapping)', 'Transform a Lyapunov estimate through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('chaosTheoryTransformSensitiveOrbit', 'Chaos Theory', '(value, mapping)', 'Transform a sensitive orbit through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('chaosTheoryValidateAttractor', 'Chaos Theory', '(value)', 'Validate the attractor representation and domain rules for Chaos Theory.', 'professional_function_catalog.md'), + ('chaosTheoryValidateBifurcationSample', 'Chaos Theory', '(value)', 'Validate the bifurcation sample representation and domain rules for Chaos Theory.', 'professional_function_catalog.md'), + ('chaosTheoryValidateChaoticMap', 'Chaos Theory', '(value)', 'Validate the chaotic map representation and domain rules for Chaos Theory.', 'professional_function_catalog.md'), + ('chaosTheoryValidateLyapunovEstimate', 'Chaos Theory', '(value)', 'Validate the Lyapunov estimate representation and domain rules for Chaos Theory.', 'professional_function_catalog.md'), + ('chaosTheoryValidateSensitiveOrbit', 'Chaos Theory', '(value)', 'Validate the sensitive orbit representation and domain rules for Chaos Theory.', 'professional_function_catalog.md'), + ('henonMap', 'Chaos Theory', '(a, b, point)', 'Planned roadmap function for Chaos Theory from upcoming.md.', 'upcoming.md'), + ('lorenzStep', 'Chaos Theory', '(point, sigma, rho, beta, dt)', 'Planned roadmap function for Chaos Theory from upcoming.md.', 'upcoming.md'), + ('lyapunovExponentMap', 'Chaos Theory', '(f, derivative, x0, steps)', 'Planned roadmap function for Chaos Theory from upcoming.md.', 'upcoming.md'), + ('poincareSection', 'Chaos Theory', '(points, coordinateIndex, value)', 'Planned roadmap function for Chaos Theory from upcoming.md.', 'upcoming.md'), + ('sensitivityToInitialConditions', 'Chaos Theory', '(f, x0, delta, steps)', 'Planned roadmap function for Chaos Theory from upcoming.md.', 'upcoming.md'), + ('tentMap', 'Chaos Theory', '(mu, x)', 'Planned roadmap function for Chaos Theory from upcoming.md.', 'upcoming.md'), + ('codingTheoryApproximateCodeword', 'Coding Theory', '(value, tolerance=1e-9)', 'Approximate a codeword with explicit tolerance controls.', 'professional_function_catalog.md'), + ('codingTheoryApproximateGeneratorMatrix', 'Coding Theory', '(value, tolerance=1e-9)', 'Approximate a generator matrix with explicit tolerance controls.', 'professional_function_catalog.md'), + ('codingTheoryApproximateLinearCode', 'Coding Theory', '(value, tolerance=1e-9)', 'Approximate a linear code with explicit tolerance controls.', 'professional_function_catalog.md'), + ('codingTheoryApproximateParityCheck', 'Coding Theory', '(value, tolerance=1e-9)', 'Approximate a parity check with explicit tolerance controls.', 'professional_function_catalog.md'), + ('codingTheoryApproximateSyndrome', 'Coding Theory', '(value, tolerance=1e-9)', 'Approximate a syndrome with explicit tolerance controls.', 'professional_function_catalog.md'), + ('codingTheoryCanonicalizeCodeword', 'Coding Theory', '(value)', 'Canonicalize a codeword so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('codingTheoryCanonicalizeGeneratorMatrix', 'Coding Theory', '(value)', 'Canonicalize a generator matrix so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('codingTheoryCanonicalizeLinearCode', 'Coding Theory', '(value)', 'Canonicalize a linear code so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('codingTheoryCanonicalizeParityCheck', 'Coding Theory', '(value)', 'Canonicalize a parity check so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('codingTheoryCanonicalizeSyndrome', 'Coding Theory', '(value)', 'Canonicalize a syndrome so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('codingTheoryClassifyCodeword', 'Coding Theory', '(value)', 'Classify a codeword by its standard Coding Theory invariants.', 'professional_function_catalog.md'), + ('codingTheoryClassifyGeneratorMatrix', 'Coding Theory', '(value)', 'Classify a generator matrix by its standard Coding Theory invariants.', 'professional_function_catalog.md'), + ('codingTheoryClassifyLinearCode', 'Coding Theory', '(value)', 'Classify a linear code by its standard Coding Theory invariants.', 'professional_function_catalog.md'), + ('codingTheoryClassifyParityCheck', 'Coding Theory', '(value)', 'Classify a parity check by its standard Coding Theory invariants.', 'professional_function_catalog.md'), + ('codingTheoryClassifySyndrome', 'Coding Theory', '(value)', 'Classify a syndrome by its standard Coding Theory invariants.', 'professional_function_catalog.md'), + ('codingTheoryCombineCodeword', 'Coding Theory', '(left, right)', 'Combine two codeword values with the natural operation for Coding Theory.', 'professional_function_catalog.md'), + ('codingTheoryCombineGeneratorMatrix', 'Coding Theory', '(left, right)', 'Combine two generator matrix values with the natural operation for Coding Theory.', 'professional_function_catalog.md'), + ('codingTheoryCombineLinearCode', 'Coding Theory', '(left, right)', 'Combine two linear code values with the natural operation for Coding Theory.', 'professional_function_catalog.md'), + ('codingTheoryCombineParityCheck', 'Coding Theory', '(left, right)', 'Combine two parity check values with the natural operation for Coding Theory.', 'professional_function_catalog.md'), + ('codingTheoryCombineSyndrome', 'Coding Theory', '(left, right)', 'Combine two syndrome values with the natural operation for Coding Theory.', 'professional_function_catalog.md'), + ('codingTheoryCompareCodeword', 'Coding Theory', '(left, right)', 'Compare two codeword values under the conventions of Coding Theory.', 'professional_function_catalog.md'), + ('codingTheoryCompareGeneratorMatrix', 'Coding Theory', '(left, right)', 'Compare two generator matrix values under the conventions of Coding Theory.', 'professional_function_catalog.md'), + ('codingTheoryCompareLinearCode', 'Coding Theory', '(left, right)', 'Compare two linear code values under the conventions of Coding Theory.', 'professional_function_catalog.md'), + ('codingTheoryCompareParityCheck', 'Coding Theory', '(left, right)', 'Compare two parity check values under the conventions of Coding Theory.', 'professional_function_catalog.md'), + ('codingTheoryCompareSyndrome', 'Coding Theory', '(left, right)', 'Compare two syndrome values under the conventions of Coding Theory.', 'professional_function_catalog.md'), + ('codingTheoryComputeCodeword', 'Coding Theory', '(value)', 'Compute the central numerical or symbolic data of a codeword.', 'professional_function_catalog.md'), + ('codingTheoryComputeGeneratorMatrix', 'Coding Theory', '(value)', 'Compute the central numerical or symbolic data of a generator matrix.', 'professional_function_catalog.md'), + ('codingTheoryComputeLinearCode', 'Coding Theory', '(value)', 'Compute the central numerical or symbolic data of a linear code.', 'professional_function_catalog.md'), + ('codingTheoryComputeParityCheck', 'Coding Theory', '(value)', 'Compute the central numerical or symbolic data of a parity check.', 'professional_function_catalog.md'), + ('codingTheoryComputeSyndrome', 'Coding Theory', '(value)', 'Compute the central numerical or symbolic data of a syndrome.', 'professional_function_catalog.md'), + ('codingTheoryConstructCodeword', 'Coding Theory', '(*args)', 'Construct a codeword from explicit inputs for Coding Theory.', 'professional_function_catalog.md'), + ('codingTheoryConstructGeneratorMatrix', 'Coding Theory', '(*args)', 'Construct a generator matrix from explicit inputs for Coding Theory.', 'professional_function_catalog.md'), + ('codingTheoryConstructLinearCode', 'Coding Theory', '(*args)', 'Construct a linear code from explicit inputs for Coding Theory.', 'professional_function_catalog.md'), + ('codingTheoryConstructParityCheck', 'Coding Theory', '(*args)', 'Construct a parity check from explicit inputs for Coding Theory.', 'professional_function_catalog.md'), + ('codingTheoryConstructSyndrome', 'Coding Theory', '(*args)', 'Construct a syndrome from explicit inputs for Coding Theory.', 'professional_function_catalog.md'), + ('codingTheoryDecomposeCodeword', 'Coding Theory', '(value)', 'Decompose a codeword into simpler or canonical components.', 'professional_function_catalog.md'), + ('codingTheoryDecomposeGeneratorMatrix', 'Coding Theory', '(value)', 'Decompose a generator matrix into simpler or canonical components.', 'professional_function_catalog.md'), + ('codingTheoryDecomposeLinearCode', 'Coding Theory', '(value)', 'Decompose a linear code into simpler or canonical components.', 'professional_function_catalog.md'), + ('codingTheoryDecomposeParityCheck', 'Coding Theory', '(value)', 'Decompose a parity check into simpler or canonical components.', 'professional_function_catalog.md'), + ('codingTheoryDecomposeSyndrome', 'Coding Theory', '(value)', 'Decompose a syndrome into simpler or canonical components.', 'professional_function_catalog.md'), + ('codingTheoryDocumentCodeword', 'Coding Theory', '(value)', 'Return a structured explanation of a codeword and related assumptions.', 'professional_function_catalog.md'), + ('codingTheoryDocumentGeneratorMatrix', 'Coding Theory', '(value)', 'Return a structured explanation of a generator matrix and related assumptions.', 'professional_function_catalog.md'), + ('codingTheoryDocumentLinearCode', 'Coding Theory', '(value)', 'Return a structured explanation of a linear code and related assumptions.', 'professional_function_catalog.md'), + ('codingTheoryDocumentParityCheck', 'Coding Theory', '(value)', 'Return a structured explanation of a parity check and related assumptions.', 'professional_function_catalog.md'), + ('codingTheoryDocumentSyndrome', 'Coding Theory', '(value)', 'Return a structured explanation of a syndrome and related assumptions.', 'professional_function_catalog.md'), + ('codingTheoryEnumerateCodeword', 'Coding Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a codeword.', 'professional_function_catalog.md'), + ('codingTheoryEnumerateGeneratorMatrix', 'Coding Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a generator matrix.', 'professional_function_catalog.md'), + ('codingTheoryEnumerateLinearCode', 'Coding Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a linear code.', 'professional_function_catalog.md'), + ('codingTheoryEnumerateParityCheck', 'Coding Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a parity check.', 'professional_function_catalog.md'), + ('codingTheoryEnumerateSyndrome', 'Coding Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a syndrome.', 'professional_function_catalog.md'), + ('codingTheoryEstimateCodeword', 'Coding Theory', '(value, samples=None)', 'Estimate a codeword property from finite samples or approximations.', 'professional_function_catalog.md'), + ('codingTheoryEstimateGeneratorMatrix', 'Coding Theory', '(value, samples=None)', 'Estimate a generator matrix property from finite samples or approximations.', 'professional_function_catalog.md'), + ('codingTheoryEstimateLinearCode', 'Coding Theory', '(value, samples=None)', 'Estimate a linear code property from finite samples or approximations.', 'professional_function_catalog.md'), + ('codingTheoryEstimateParityCheck', 'Coding Theory', '(value, samples=None)', 'Estimate a parity check property from finite samples or approximations.', 'professional_function_catalog.md'), + ('codingTheoryEstimateSyndrome', 'Coding Theory', '(value, samples=None)', 'Estimate a syndrome property from finite samples or approximations.', 'professional_function_catalog.md'), + ('codingTheoryEvaluateCodeword', 'Coding Theory', '(value, point=None)', 'Evaluate a codeword at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('codingTheoryEvaluateGeneratorMatrix', 'Coding Theory', '(value, point=None)', 'Evaluate a generator matrix at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('codingTheoryEvaluateLinearCode', 'Coding Theory', '(value, point=None)', 'Evaluate a linear code at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('codingTheoryEvaluateParityCheck', 'Coding Theory', '(value, point=None)', 'Evaluate a parity check at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('codingTheoryEvaluateSyndrome', 'Coding Theory', '(value, point=None)', 'Evaluate a syndrome at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('codingTheoryFormatCodeword', 'Coding Theory', '(value)', 'Format a codeword for deterministic user-facing output.', 'professional_function_catalog.md'), + ('codingTheoryFormatGeneratorMatrix', 'Coding Theory', '(value)', 'Format a generator matrix for deterministic user-facing output.', 'professional_function_catalog.md'), + ('codingTheoryFormatLinearCode', 'Coding Theory', '(value)', 'Format a linear code for deterministic user-facing output.', 'professional_function_catalog.md'), + ('codingTheoryFormatParityCheck', 'Coding Theory', '(value)', 'Format a parity check for deterministic user-facing output.', 'professional_function_catalog.md'), + ('codingTheoryFormatSyndrome', 'Coding Theory', '(value)', 'Format a syndrome for deterministic user-facing output.', 'professional_function_catalog.md'), + ('codingTheoryGenerateExampleCodeword', 'Coding Theory', '(size=3)', 'Generate a small documented example of a codeword.', 'professional_function_catalog.md'), + ('codingTheoryGenerateExampleGeneratorMatrix', 'Coding Theory', '(size=3)', 'Generate a small documented example of a generator matrix.', 'professional_function_catalog.md'), + ('codingTheoryGenerateExampleLinearCode', 'Coding Theory', '(size=3)', 'Generate a small documented example of a linear code.', 'professional_function_catalog.md'), + ('codingTheoryGenerateExampleParityCheck', 'Coding Theory', '(size=3)', 'Generate a small documented example of a parity check.', 'professional_function_catalog.md'), + ('codingTheoryGenerateExampleSyndrome', 'Coding Theory', '(size=3)', 'Generate a small documented example of a syndrome.', 'professional_function_catalog.md'), + ('codingTheoryNormalizeCodeword', 'Coding Theory', '(value)', 'Normalize a codeword into the standard Coding Theory representation.', 'professional_function_catalog.md'), + ('codingTheoryNormalizeGeneratorMatrix', 'Coding Theory', '(value)', 'Normalize a generator matrix into the standard Coding Theory representation.', 'professional_function_catalog.md'), + ('codingTheoryNormalizeLinearCode', 'Coding Theory', '(value)', 'Normalize a linear code into the standard Coding Theory representation.', 'professional_function_catalog.md'), + ('codingTheoryNormalizeParityCheck', 'Coding Theory', '(value)', 'Normalize a parity check into the standard Coding Theory representation.', 'professional_function_catalog.md'), + ('codingTheoryNormalizeSyndrome', 'Coding Theory', '(value)', 'Normalize a syndrome into the standard Coding Theory representation.', 'professional_function_catalog.md'), + ('codingTheoryParseCodeword', 'Coding Theory', '(text)', 'Parse a text or structured value into a codeword.', 'professional_function_catalog.md'), + ('codingTheoryParseGeneratorMatrix', 'Coding Theory', '(text)', 'Parse a text or structured value into a generator matrix.', 'professional_function_catalog.md'), + ('codingTheoryParseLinearCode', 'Coding Theory', '(text)', 'Parse a text or structured value into a linear code.', 'professional_function_catalog.md'), + ('codingTheoryParseParityCheck', 'Coding Theory', '(text)', 'Parse a text or structured value into a parity check.', 'professional_function_catalog.md'), + ('codingTheoryParseSyndrome', 'Coding Theory', '(text)', 'Parse a text or structured value into a syndrome.', 'professional_function_catalog.md'), + ('codingTheorySimplifyCodeword', 'Coding Theory', '(value)', 'Simplify a codeword without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('codingTheorySimplifyGeneratorMatrix', 'Coding Theory', '(value)', 'Simplify a generator matrix without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('codingTheorySimplifyLinearCode', 'Coding Theory', '(value)', 'Simplify a linear code without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('codingTheorySimplifyParityCheck', 'Coding Theory', '(value)', 'Simplify a parity check without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('codingTheorySimplifySyndrome', 'Coding Theory', '(value)', 'Simplify a syndrome without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('codingTheoryTestEquivalenceCodeword', 'Coding Theory', '(left, right)', 'Test whether two codeword values are equivalent in Coding Theory.', 'professional_function_catalog.md'), + ('codingTheoryTestEquivalenceGeneratorMatrix', 'Coding Theory', '(left, right)', 'Test whether two generator matrix values are equivalent in Coding Theory.', 'professional_function_catalog.md'), + ('codingTheoryTestEquivalenceLinearCode', 'Coding Theory', '(left, right)', 'Test whether two linear code values are equivalent in Coding Theory.', 'professional_function_catalog.md'), + ('codingTheoryTestEquivalenceParityCheck', 'Coding Theory', '(left, right)', 'Test whether two parity check values are equivalent in Coding Theory.', 'professional_function_catalog.md'), + ('codingTheoryTestEquivalenceSyndrome', 'Coding Theory', '(left, right)', 'Test whether two syndrome values are equivalent in Coding Theory.', 'professional_function_catalog.md'), + ('codingTheoryTransformCodeword', 'Coding Theory', '(value, mapping)', 'Transform a codeword through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('codingTheoryTransformGeneratorMatrix', 'Coding Theory', '(value, mapping)', 'Transform a generator matrix through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('codingTheoryTransformLinearCode', 'Coding Theory', '(value, mapping)', 'Transform a linear code through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('codingTheoryTransformParityCheck', 'Coding Theory', '(value, mapping)', 'Transform a parity check through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('codingTheoryTransformSyndrome', 'Coding Theory', '(value, mapping)', 'Transform a syndrome through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('codingTheoryValidateCodeword', 'Coding Theory', '(value)', 'Validate the codeword representation and domain rules for Coding Theory.', 'professional_function_catalog.md'), + ('codingTheoryValidateGeneratorMatrix', 'Coding Theory', '(value)', 'Validate the generator matrix representation and domain rules for Coding Theory.', 'professional_function_catalog.md'), + ('codingTheoryValidateLinearCode', 'Coding Theory', '(value)', 'Validate the linear code representation and domain rules for Coding Theory.', 'professional_function_catalog.md'), + ('codingTheoryValidateParityCheck', 'Coding Theory', '(value)', 'Validate the parity check representation and domain rules for Coding Theory.', 'professional_function_catalog.md'), + ('codingTheoryValidateSyndrome', 'Coding Theory', '(value)', 'Validate the syndrome representation and domain rules for Coding Theory.', 'professional_function_catalog.md'), + ('correctSingleBitError', 'Coding Theory', '(received, parityCheckMatrix)', 'Planned roadmap function for Coding Theory from upcoming.md.', 'upcoming.md'), + ('detectError', 'Coding Theory', '(received, parityCheckMatrix)', 'Planned roadmap function for Coding Theory from upcoming.md.', 'upcoming.md'), + ('encodeLinearCode', 'Coding Theory', '(message, generatorMatrix, modulus=2)', 'Planned roadmap function for Coding Theory from upcoming.md.', 'upcoming.md'), + ('hammingCode74Decode', 'Coding Theory', '(codeword)', 'Planned roadmap function for Coding Theory from upcoming.md.', 'upcoming.md'), + ('hammingCode74Encode', 'Coding Theory', '(message)', 'Planned roadmap function for Coding Theory from upcoming.md.', 'upcoming.md'), + ('hammingDistance', 'Coding Theory', '(a, b)', 'Planned roadmap function for Coding Theory from upcoming.md.', 'upcoming.md'), + ('minimumDistance', 'Coding Theory', '(codewords)', 'Planned roadmap function for Coding Theory from upcoming.md.', 'upcoming.md'), + ('syndrome', 'Coding Theory', '(received, parityCheckMatrix, modulus=2)', 'Planned roadmap function for Coding Theory from upcoming.md.', 'upcoming.md'), + ('bellNumber', 'Combinatorics', '(n)', 'Planned roadmap function for Combinatorics from upcoming.md.', 'upcoming.md'), + ('catalanNumber', 'Combinatorics', '(n)', 'Planned roadmap function for Combinatorics from upcoming.md.', 'upcoming.md'), + ('combinatoricsApproximateCombinatorialClass', 'Combinatorics', '(value, tolerance=1e-9)', 'Approximate a combinatorial class with explicit tolerance controls.', 'professional_function_catalog.md'), + ('combinatoricsApproximateCountingIdentity', 'Combinatorics', '(value, tolerance=1e-9)', 'Approximate a counting identity with explicit tolerance controls.', 'professional_function_catalog.md'), + ('combinatoricsApproximateGeneratingFunction', 'Combinatorics', '(value, tolerance=1e-9)', 'Approximate a generating function with explicit tolerance controls.', 'professional_function_catalog.md'), + ('combinatoricsApproximatePartitionFamily', 'Combinatorics', '(value, tolerance=1e-9)', 'Approximate a partition family with explicit tolerance controls.', 'professional_function_catalog.md'), + ('combinatoricsApproximatePermutationFamily', 'Combinatorics', '(value, tolerance=1e-9)', 'Approximate a permutation family with explicit tolerance controls.', 'professional_function_catalog.md'), + ('combinatoricsCanonicalizeCombinatorialClass', 'Combinatorics', '(value)', 'Canonicalize a combinatorial class so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('combinatoricsCanonicalizeCountingIdentity', 'Combinatorics', '(value)', 'Canonicalize a counting identity so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('combinatoricsCanonicalizeGeneratingFunction', 'Combinatorics', '(value)', 'Canonicalize a generating function so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('combinatoricsCanonicalizePartitionFamily', 'Combinatorics', '(value)', 'Canonicalize a partition family so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('combinatoricsCanonicalizePermutationFamily', 'Combinatorics', '(value)', 'Canonicalize a permutation family so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('combinatoricsClassifyCombinatorialClass', 'Combinatorics', '(value)', 'Classify a combinatorial class by its standard Combinatorics invariants.', 'professional_function_catalog.md'), + ('combinatoricsClassifyCountingIdentity', 'Combinatorics', '(value)', 'Classify a counting identity by its standard Combinatorics invariants.', 'professional_function_catalog.md'), + ('combinatoricsClassifyGeneratingFunction', 'Combinatorics', '(value)', 'Classify a generating function by its standard Combinatorics invariants.', 'professional_function_catalog.md'), + ('combinatoricsClassifyPartitionFamily', 'Combinatorics', '(value)', 'Classify a partition family by its standard Combinatorics invariants.', 'professional_function_catalog.md'), + ('combinatoricsClassifyPermutationFamily', 'Combinatorics', '(value)', 'Classify a permutation family by its standard Combinatorics invariants.', 'professional_function_catalog.md'), + ('combinatoricsCombineCombinatorialClass', 'Combinatorics', '(left, right)', 'Combine two combinatorial class values with the natural operation for Combinatorics.', 'professional_function_catalog.md'), + ('combinatoricsCombineCountingIdentity', 'Combinatorics', '(left, right)', 'Combine two counting identity values with the natural operation for Combinatorics.', 'professional_function_catalog.md'), + ('combinatoricsCombineGeneratingFunction', 'Combinatorics', '(left, right)', 'Combine two generating function values with the natural operation for Combinatorics.', 'professional_function_catalog.md'), + ('combinatoricsCombinePartitionFamily', 'Combinatorics', '(left, right)', 'Combine two partition family values with the natural operation for Combinatorics.', 'professional_function_catalog.md'), + ('combinatoricsCombinePermutationFamily', 'Combinatorics', '(left, right)', 'Combine two permutation family values with the natural operation for Combinatorics.', 'professional_function_catalog.md'), + ('combinatoricsCompareCombinatorialClass', 'Combinatorics', '(left, right)', 'Compare two combinatorial class values under the conventions of Combinatorics.', 'professional_function_catalog.md'), + ('combinatoricsCompareCountingIdentity', 'Combinatorics', '(left, right)', 'Compare two counting identity values under the conventions of Combinatorics.', 'professional_function_catalog.md'), + ('combinatoricsCompareGeneratingFunction', 'Combinatorics', '(left, right)', 'Compare two generating function values under the conventions of Combinatorics.', 'professional_function_catalog.md'), + ('combinatoricsComparePartitionFamily', 'Combinatorics', '(left, right)', 'Compare two partition family values under the conventions of Combinatorics.', 'professional_function_catalog.md'), + ('combinatoricsComparePermutationFamily', 'Combinatorics', '(left, right)', 'Compare two permutation family values under the conventions of Combinatorics.', 'professional_function_catalog.md'), + ('combinatoricsComputeCombinatorialClass', 'Combinatorics', '(value)', 'Compute the central numerical or symbolic data of a combinatorial class.', 'professional_function_catalog.md'), + ('combinatoricsComputeCountingIdentity', 'Combinatorics', '(value)', 'Compute the central numerical or symbolic data of a counting identity.', 'professional_function_catalog.md'), + ('combinatoricsComputeGeneratingFunction', 'Combinatorics', '(value)', 'Compute the central numerical or symbolic data of a generating function.', 'professional_function_catalog.md'), + ('combinatoricsComputePartitionFamily', 'Combinatorics', '(value)', 'Compute the central numerical or symbolic data of a partition family.', 'professional_function_catalog.md'), + ('combinatoricsComputePermutationFamily', 'Combinatorics', '(value)', 'Compute the central numerical or symbolic data of a permutation family.', 'professional_function_catalog.md'), + ('combinatoricsConstructCombinatorialClass', 'Combinatorics', '(*args)', 'Construct a combinatorial class from explicit inputs for Combinatorics.', 'professional_function_catalog.md'), + ('combinatoricsConstructCountingIdentity', 'Combinatorics', '(*args)', 'Construct a counting identity from explicit inputs for Combinatorics.', 'professional_function_catalog.md'), + ('combinatoricsConstructGeneratingFunction', 'Combinatorics', '(*args)', 'Construct a generating function from explicit inputs for Combinatorics.', 'professional_function_catalog.md'), + ('combinatoricsConstructPartitionFamily', 'Combinatorics', '(*args)', 'Construct a partition family from explicit inputs for Combinatorics.', 'professional_function_catalog.md'), + ('combinatoricsConstructPermutationFamily', 'Combinatorics', '(*args)', 'Construct a permutation family from explicit inputs for Combinatorics.', 'professional_function_catalog.md'), + ('combinatoricsDecomposeCombinatorialClass', 'Combinatorics', '(value)', 'Decompose a combinatorial class into simpler or canonical components.', 'professional_function_catalog.md'), + ('combinatoricsDecomposeCountingIdentity', 'Combinatorics', '(value)', 'Decompose a counting identity into simpler or canonical components.', 'professional_function_catalog.md'), + ('combinatoricsDecomposeGeneratingFunction', 'Combinatorics', '(value)', 'Decompose a generating function into simpler or canonical components.', 'professional_function_catalog.md'), + ('combinatoricsDecomposePartitionFamily', 'Combinatorics', '(value)', 'Decompose a partition family into simpler or canonical components.', 'professional_function_catalog.md'), + ('combinatoricsDecomposePermutationFamily', 'Combinatorics', '(value)', 'Decompose a permutation family into simpler or canonical components.', 'professional_function_catalog.md'), + ('combinatoricsDocumentCombinatorialClass', 'Combinatorics', '(value)', 'Return a structured explanation of a combinatorial class and related assumptions.', 'professional_function_catalog.md'), + ('combinatoricsDocumentCountingIdentity', 'Combinatorics', '(value)', 'Return a structured explanation of a counting identity and related assumptions.', 'professional_function_catalog.md'), + ('combinatoricsDocumentGeneratingFunction', 'Combinatorics', '(value)', 'Return a structured explanation of a generating function and related assumptions.', 'professional_function_catalog.md'), + ('combinatoricsDocumentPartitionFamily', 'Combinatorics', '(value)', 'Return a structured explanation of a partition family and related assumptions.', 'professional_function_catalog.md'), + ('combinatoricsDocumentPermutationFamily', 'Combinatorics', '(value)', 'Return a structured explanation of a permutation family and related assumptions.', 'professional_function_catalog.md'), + ('combinatoricsEnumerateCombinatorialClass', 'Combinatorics', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a combinatorial class.', 'professional_function_catalog.md'), + ('combinatoricsEnumerateCountingIdentity', 'Combinatorics', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a counting identity.', 'professional_function_catalog.md'), + ('combinatoricsEnumerateGeneratingFunction', 'Combinatorics', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a generating function.', 'professional_function_catalog.md'), + ('combinatoricsEnumeratePartitionFamily', 'Combinatorics', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a partition family.', 'professional_function_catalog.md'), + ('combinatoricsEnumeratePermutationFamily', 'Combinatorics', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a permutation family.', 'professional_function_catalog.md'), + ('combinatoricsEstimateCombinatorialClass', 'Combinatorics', '(value, samples=None)', 'Estimate a combinatorial class property from finite samples or approximations.', 'professional_function_catalog.md'), + ('combinatoricsEstimateCountingIdentity', 'Combinatorics', '(value, samples=None)', 'Estimate a counting identity property from finite samples or approximations.', 'professional_function_catalog.md'), + ('combinatoricsEstimateGeneratingFunction', 'Combinatorics', '(value, samples=None)', 'Estimate a generating function property from finite samples or approximations.', 'professional_function_catalog.md'), + ('combinatoricsEstimatePartitionFamily', 'Combinatorics', '(value, samples=None)', 'Estimate a partition family property from finite samples or approximations.', 'professional_function_catalog.md'), + ('combinatoricsEstimatePermutationFamily', 'Combinatorics', '(value, samples=None)', 'Estimate a permutation family property from finite samples or approximations.', 'professional_function_catalog.md'), + ('combinatoricsEvaluateCombinatorialClass', 'Combinatorics', '(value, point=None)', 'Evaluate a combinatorial class at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('combinatoricsEvaluateCountingIdentity', 'Combinatorics', '(value, point=None)', 'Evaluate a counting identity at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('combinatoricsEvaluateGeneratingFunction', 'Combinatorics', '(value, point=None)', 'Evaluate a generating function at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('combinatoricsEvaluatePartitionFamily', 'Combinatorics', '(value, point=None)', 'Evaluate a partition family at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('combinatoricsEvaluatePermutationFamily', 'Combinatorics', '(value, point=None)', 'Evaluate a permutation family at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('combinatoricsFormatCombinatorialClass', 'Combinatorics', '(value)', 'Format a combinatorial class for deterministic user-facing output.', 'professional_function_catalog.md'), + ('combinatoricsFormatCountingIdentity', 'Combinatorics', '(value)', 'Format a counting identity for deterministic user-facing output.', 'professional_function_catalog.md'), + ('combinatoricsFormatGeneratingFunction', 'Combinatorics', '(value)', 'Format a generating function for deterministic user-facing output.', 'professional_function_catalog.md'), + ('combinatoricsFormatPartitionFamily', 'Combinatorics', '(value)', 'Format a partition family for deterministic user-facing output.', 'professional_function_catalog.md'), + ('combinatoricsFormatPermutationFamily', 'Combinatorics', '(value)', 'Format a permutation family for deterministic user-facing output.', 'professional_function_catalog.md'), + ('combinatoricsGenerateExampleCombinatorialClass', 'Combinatorics', '(size=3)', 'Generate a small documented example of a combinatorial class.', 'professional_function_catalog.md'), + ('combinatoricsGenerateExampleCountingIdentity', 'Combinatorics', '(size=3)', 'Generate a small documented example of a counting identity.', 'professional_function_catalog.md'), + ('combinatoricsGenerateExampleGeneratingFunction', 'Combinatorics', '(size=3)', 'Generate a small documented example of a generating function.', 'professional_function_catalog.md'), + ('combinatoricsGenerateExamplePartitionFamily', 'Combinatorics', '(size=3)', 'Generate a small documented example of a partition family.', 'professional_function_catalog.md'), + ('combinatoricsGenerateExamplePermutationFamily', 'Combinatorics', '(size=3)', 'Generate a small documented example of a permutation family.', 'professional_function_catalog.md'), + ('combinatoricsNormalizeCombinatorialClass', 'Combinatorics', '(value)', 'Normalize a combinatorial class into the standard Combinatorics representation.', 'professional_function_catalog.md'), + ('combinatoricsNormalizeCountingIdentity', 'Combinatorics', '(value)', 'Normalize a counting identity into the standard Combinatorics representation.', 'professional_function_catalog.md'), + ('combinatoricsNormalizeGeneratingFunction', 'Combinatorics', '(value)', 'Normalize a generating function into the standard Combinatorics representation.', 'professional_function_catalog.md'), + ('combinatoricsNormalizePartitionFamily', 'Combinatorics', '(value)', 'Normalize a partition family into the standard Combinatorics representation.', 'professional_function_catalog.md'), + ('combinatoricsNormalizePermutationFamily', 'Combinatorics', '(value)', 'Normalize a permutation family into the standard Combinatorics representation.', 'professional_function_catalog.md'), + ('combinatoricsParseCombinatorialClass', 'Combinatorics', '(text)', 'Parse a text or structured value into a combinatorial class.', 'professional_function_catalog.md'), + ('combinatoricsParseCountingIdentity', 'Combinatorics', '(text)', 'Parse a text or structured value into a counting identity.', 'professional_function_catalog.md'), + ('combinatoricsParseGeneratingFunction', 'Combinatorics', '(text)', 'Parse a text or structured value into a generating function.', 'professional_function_catalog.md'), + ('combinatoricsParsePartitionFamily', 'Combinatorics', '(text)', 'Parse a text or structured value into a partition family.', 'professional_function_catalog.md'), + ('combinatoricsParsePermutationFamily', 'Combinatorics', '(text)', 'Parse a text or structured value into a permutation family.', 'professional_function_catalog.md'), + ('combinatoricsSimplifyCombinatorialClass', 'Combinatorics', '(value)', 'Simplify a combinatorial class without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('combinatoricsSimplifyCountingIdentity', 'Combinatorics', '(value)', 'Simplify a counting identity without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('combinatoricsSimplifyGeneratingFunction', 'Combinatorics', '(value)', 'Simplify a generating function without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('combinatoricsSimplifyPartitionFamily', 'Combinatorics', '(value)', 'Simplify a partition family without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('combinatoricsSimplifyPermutationFamily', 'Combinatorics', '(value)', 'Simplify a permutation family without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('combinatoricsTestEquivalenceCombinatorialClass', 'Combinatorics', '(left, right)', 'Test whether two combinatorial class values are equivalent in Combinatorics.', 'professional_function_catalog.md'), + ('combinatoricsTestEquivalenceCountingIdentity', 'Combinatorics', '(left, right)', 'Test whether two counting identity values are equivalent in Combinatorics.', 'professional_function_catalog.md'), + ('combinatoricsTestEquivalenceGeneratingFunction', 'Combinatorics', '(left, right)', 'Test whether two generating function values are equivalent in Combinatorics.', 'professional_function_catalog.md'), + ('combinatoricsTestEquivalencePartitionFamily', 'Combinatorics', '(left, right)', 'Test whether two partition family values are equivalent in Combinatorics.', 'professional_function_catalog.md'), + ('combinatoricsTestEquivalencePermutationFamily', 'Combinatorics', '(left, right)', 'Test whether two permutation family values are equivalent in Combinatorics.', 'professional_function_catalog.md'), + ('combinatoricsTransformCombinatorialClass', 'Combinatorics', '(value, mapping)', 'Transform a combinatorial class through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('combinatoricsTransformCountingIdentity', 'Combinatorics', '(value, mapping)', 'Transform a counting identity through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('combinatoricsTransformGeneratingFunction', 'Combinatorics', '(value, mapping)', 'Transform a generating function through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('combinatoricsTransformPartitionFamily', 'Combinatorics', '(value, mapping)', 'Transform a partition family through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('combinatoricsTransformPermutationFamily', 'Combinatorics', '(value, mapping)', 'Transform a permutation family through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('combinatoricsValidateCombinatorialClass', 'Combinatorics', '(value)', 'Validate the combinatorial class representation and domain rules for Combinatorics.', 'professional_function_catalog.md'), + ('combinatoricsValidateCountingIdentity', 'Combinatorics', '(value)', 'Validate the counting identity representation and domain rules for Combinatorics.', 'professional_function_catalog.md'), + ('combinatoricsValidateGeneratingFunction', 'Combinatorics', '(value)', 'Validate the generating function representation and domain rules for Combinatorics.', 'professional_function_catalog.md'), + ('combinatoricsValidatePartitionFamily', 'Combinatorics', '(value)', 'Validate the partition family representation and domain rules for Combinatorics.', 'professional_function_catalog.md'), + ('combinatoricsValidatePermutationFamily', 'Combinatorics', '(value)', 'Validate the permutation family representation and domain rules for Combinatorics.', 'professional_function_catalog.md'), + ('compositions', 'Combinatorics', '(n)', 'Planned roadmap function for Combinatorics from upcoming.md.', 'upcoming.md'), + ('generatingFunctionCoefficients', 'Combinatorics', '(sequence, n)', 'Planned roadmap function for Combinatorics from upcoming.md.', 'upcoming.md'), + ('integerPartitions', 'Combinatorics', '(n)', 'Planned roadmap function for Combinatorics from upcoming.md.', 'upcoming.md'), + ('pascalRow', 'Combinatorics', '(n)', 'Planned roadmap function for Combinatorics from upcoming.md.', 'upcoming.md'), + ('stirlingFirstKind', 'Combinatorics', '(n, k)', 'Planned roadmap function for Combinatorics from upcoming.md.', 'upcoming.md'), + ('stirlingSecondKind', 'Combinatorics', '(n, k)', 'Planned roadmap function for Combinatorics from upcoming.md.', 'upcoming.md'), + ('commutativeAlgebraApproximateCommutativeRing', 'Commutative Algebra', '(value, tolerance=1e-9)', 'Approximate a commutative ring with explicit tolerance controls.', 'professional_function_catalog.md'), + ('commutativeAlgebraApproximateIdeal', 'Commutative Algebra', '(value, tolerance=1e-9)', 'Approximate a ideal with explicit tolerance controls.', 'professional_function_catalog.md'), + ('commutativeAlgebraApproximateLocalization', 'Commutative Algebra', '(value, tolerance=1e-9)', 'Approximate a localization with explicit tolerance controls.', 'professional_function_catalog.md'), + ('commutativeAlgebraApproximateModule', 'Commutative Algebra', '(value, tolerance=1e-9)', 'Approximate a module with explicit tolerance controls.', 'professional_function_catalog.md'), + ('commutativeAlgebraApproximateQuotientRing', 'Commutative Algebra', '(value, tolerance=1e-9)', 'Approximate a quotient ring with explicit tolerance controls.', 'professional_function_catalog.md'), + ('commutativeAlgebraCanonicalizeCommutativeRing', 'Commutative Algebra', '(value)', 'Canonicalize a commutative ring so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('commutativeAlgebraCanonicalizeIdeal', 'Commutative Algebra', '(value)', 'Canonicalize a ideal so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('commutativeAlgebraCanonicalizeLocalization', 'Commutative Algebra', '(value)', 'Canonicalize a localization so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('commutativeAlgebraCanonicalizeModule', 'Commutative Algebra', '(value)', 'Canonicalize a module so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('commutativeAlgebraCanonicalizeQuotientRing', 'Commutative Algebra', '(value)', 'Canonicalize a quotient ring so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('commutativeAlgebraClassifyCommutativeRing', 'Commutative Algebra', '(value)', 'Classify a commutative ring by its standard Commutative Algebra invariants.', 'professional_function_catalog.md'), + ('commutativeAlgebraClassifyIdeal', 'Commutative Algebra', '(value)', 'Classify a ideal by its standard Commutative Algebra invariants.', 'professional_function_catalog.md'), + ('commutativeAlgebraClassifyLocalization', 'Commutative Algebra', '(value)', 'Classify a localization by its standard Commutative Algebra invariants.', 'professional_function_catalog.md'), + ('commutativeAlgebraClassifyModule', 'Commutative Algebra', '(value)', 'Classify a module by its standard Commutative Algebra invariants.', 'professional_function_catalog.md'), + ('commutativeAlgebraClassifyQuotientRing', 'Commutative Algebra', '(value)', 'Classify a quotient ring by its standard Commutative Algebra invariants.', 'professional_function_catalog.md'), + ('commutativeAlgebraCombineCommutativeRing', 'Commutative Algebra', '(left, right)', 'Combine two commutative ring values with the natural operation for Commutative Algebra.', 'professional_function_catalog.md'), + ('commutativeAlgebraCombineIdeal', 'Commutative Algebra', '(left, right)', 'Combine two ideal values with the natural operation for Commutative Algebra.', 'professional_function_catalog.md'), + ('commutativeAlgebraCombineLocalization', 'Commutative Algebra', '(left, right)', 'Combine two localization values with the natural operation for Commutative Algebra.', 'professional_function_catalog.md'), + ('commutativeAlgebraCombineModule', 'Commutative Algebra', '(left, right)', 'Combine two module values with the natural operation for Commutative Algebra.', 'professional_function_catalog.md'), + ('commutativeAlgebraCombineQuotientRing', 'Commutative Algebra', '(left, right)', 'Combine two quotient ring values with the natural operation for Commutative Algebra.', 'professional_function_catalog.md'), + ('commutativeAlgebraCompareCommutativeRing', 'Commutative Algebra', '(left, right)', 'Compare two commutative ring values under the conventions of Commutative Algebra.', 'professional_function_catalog.md'), + ('commutativeAlgebraCompareIdeal', 'Commutative Algebra', '(left, right)', 'Compare two ideal values under the conventions of Commutative Algebra.', 'professional_function_catalog.md'), + ('commutativeAlgebraCompareLocalization', 'Commutative Algebra', '(left, right)', 'Compare two localization values under the conventions of Commutative Algebra.', 'professional_function_catalog.md'), + ('commutativeAlgebraCompareModule', 'Commutative Algebra', '(left, right)', 'Compare two module values under the conventions of Commutative Algebra.', 'professional_function_catalog.md'), + ('commutativeAlgebraCompareQuotientRing', 'Commutative Algebra', '(left, right)', 'Compare two quotient ring values under the conventions of Commutative Algebra.', 'professional_function_catalog.md'), + ('commutativeAlgebraComputeCommutativeRing', 'Commutative Algebra', '(value)', 'Compute the central numerical or symbolic data of a commutative ring.', 'professional_function_catalog.md'), + ('commutativeAlgebraComputeIdeal', 'Commutative Algebra', '(value)', 'Compute the central numerical or symbolic data of a ideal.', 'professional_function_catalog.md'), + ('commutativeAlgebraComputeLocalization', 'Commutative Algebra', '(value)', 'Compute the central numerical or symbolic data of a localization.', 'professional_function_catalog.md'), + ('commutativeAlgebraComputeModule', 'Commutative Algebra', '(value)', 'Compute the central numerical or symbolic data of a module.', 'professional_function_catalog.md'), + ('commutativeAlgebraComputeQuotientRing', 'Commutative Algebra', '(value)', 'Compute the central numerical or symbolic data of a quotient ring.', 'professional_function_catalog.md'), + ('commutativeAlgebraConstructCommutativeRing', 'Commutative Algebra', '(*args)', 'Construct a commutative ring from explicit inputs for Commutative Algebra.', 'professional_function_catalog.md'), + ('commutativeAlgebraConstructIdeal', 'Commutative Algebra', '(*args)', 'Construct a ideal from explicit inputs for Commutative Algebra.', 'professional_function_catalog.md'), + ('commutativeAlgebraConstructLocalization', 'Commutative Algebra', '(*args)', 'Construct a localization from explicit inputs for Commutative Algebra.', 'professional_function_catalog.md'), + ('commutativeAlgebraConstructModule', 'Commutative Algebra', '(*args)', 'Construct a module from explicit inputs for Commutative Algebra.', 'professional_function_catalog.md'), + ('commutativeAlgebraConstructQuotientRing', 'Commutative Algebra', '(*args)', 'Construct a quotient ring from explicit inputs for Commutative Algebra.', 'professional_function_catalog.md'), + ('commutativeAlgebraDecomposeCommutativeRing', 'Commutative Algebra', '(value)', 'Decompose a commutative ring into simpler or canonical components.', 'professional_function_catalog.md'), + ('commutativeAlgebraDecomposeIdeal', 'Commutative Algebra', '(value)', 'Decompose a ideal into simpler or canonical components.', 'professional_function_catalog.md'), + ('commutativeAlgebraDecomposeLocalization', 'Commutative Algebra', '(value)', 'Decompose a localization into simpler or canonical components.', 'professional_function_catalog.md'), + ('commutativeAlgebraDecomposeModule', 'Commutative Algebra', '(value)', 'Decompose a module into simpler or canonical components.', 'professional_function_catalog.md'), + ('commutativeAlgebraDecomposeQuotientRing', 'Commutative Algebra', '(value)', 'Decompose a quotient ring into simpler or canonical components.', 'professional_function_catalog.md'), + ('commutativeAlgebraDocumentCommutativeRing', 'Commutative Algebra', '(value)', 'Return a structured explanation of a commutative ring and related assumptions.', 'professional_function_catalog.md'), + ('commutativeAlgebraDocumentIdeal', 'Commutative Algebra', '(value)', 'Return a structured explanation of a ideal and related assumptions.', 'professional_function_catalog.md'), + ('commutativeAlgebraDocumentLocalization', 'Commutative Algebra', '(value)', 'Return a structured explanation of a localization and related assumptions.', 'professional_function_catalog.md'), + ('commutativeAlgebraDocumentModule', 'Commutative Algebra', '(value)', 'Return a structured explanation of a module and related assumptions.', 'professional_function_catalog.md'), + ('commutativeAlgebraDocumentQuotientRing', 'Commutative Algebra', '(value)', 'Return a structured explanation of a quotient ring and related assumptions.', 'professional_function_catalog.md'), + ('commutativeAlgebraEnumerateCommutativeRing', 'Commutative Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a commutative ring.', 'professional_function_catalog.md'), + ('commutativeAlgebraEnumerateIdeal', 'Commutative Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a ideal.', 'professional_function_catalog.md'), + ('commutativeAlgebraEnumerateLocalization', 'Commutative Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a localization.', 'professional_function_catalog.md'), + ('commutativeAlgebraEnumerateModule', 'Commutative Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a module.', 'professional_function_catalog.md'), + ('commutativeAlgebraEnumerateQuotientRing', 'Commutative Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a quotient ring.', 'professional_function_catalog.md'), + ('commutativeAlgebraEstimateCommutativeRing', 'Commutative Algebra', '(value, samples=None)', 'Estimate a commutative ring property from finite samples or approximations.', 'professional_function_catalog.md'), + ('commutativeAlgebraEstimateIdeal', 'Commutative Algebra', '(value, samples=None)', 'Estimate a ideal property from finite samples or approximations.', 'professional_function_catalog.md'), + ('commutativeAlgebraEstimateLocalization', 'Commutative Algebra', '(value, samples=None)', 'Estimate a localization property from finite samples or approximations.', 'professional_function_catalog.md'), + ('commutativeAlgebraEstimateModule', 'Commutative Algebra', '(value, samples=None)', 'Estimate a module property from finite samples or approximations.', 'professional_function_catalog.md'), + ('commutativeAlgebraEstimateQuotientRing', 'Commutative Algebra', '(value, samples=None)', 'Estimate a quotient ring property from finite samples or approximations.', 'professional_function_catalog.md'), + ('commutativeAlgebraEvaluateCommutativeRing', 'Commutative Algebra', '(value, point=None)', 'Evaluate a commutative ring at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('commutativeAlgebraEvaluateIdeal', 'Commutative Algebra', '(value, point=None)', 'Evaluate a ideal at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('commutativeAlgebraEvaluateLocalization', 'Commutative Algebra', '(value, point=None)', 'Evaluate a localization at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('commutativeAlgebraEvaluateModule', 'Commutative Algebra', '(value, point=None)', 'Evaluate a module at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('commutativeAlgebraEvaluateQuotientRing', 'Commutative Algebra', '(value, point=None)', 'Evaluate a quotient ring at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('commutativeAlgebraFormatCommutativeRing', 'Commutative Algebra', '(value)', 'Format a commutative ring for deterministic user-facing output.', 'professional_function_catalog.md'), + ('commutativeAlgebraFormatIdeal', 'Commutative Algebra', '(value)', 'Format a ideal for deterministic user-facing output.', 'professional_function_catalog.md'), + ('commutativeAlgebraFormatLocalization', 'Commutative Algebra', '(value)', 'Format a localization for deterministic user-facing output.', 'professional_function_catalog.md'), + ('commutativeAlgebraFormatModule', 'Commutative Algebra', '(value)', 'Format a module for deterministic user-facing output.', 'professional_function_catalog.md'), + ('commutativeAlgebraFormatQuotientRing', 'Commutative Algebra', '(value)', 'Format a quotient ring for deterministic user-facing output.', 'professional_function_catalog.md'), + ('commutativeAlgebraGenerateExampleCommutativeRing', 'Commutative Algebra', '(size=3)', 'Generate a small documented example of a commutative ring.', 'professional_function_catalog.md'), + ('commutativeAlgebraGenerateExampleIdeal', 'Commutative Algebra', '(size=3)', 'Generate a small documented example of a ideal.', 'professional_function_catalog.md'), + ('commutativeAlgebraGenerateExampleLocalization', 'Commutative Algebra', '(size=3)', 'Generate a small documented example of a localization.', 'professional_function_catalog.md'), + ('commutativeAlgebraGenerateExampleModule', 'Commutative Algebra', '(size=3)', 'Generate a small documented example of a module.', 'professional_function_catalog.md'), + ('commutativeAlgebraGenerateExampleQuotientRing', 'Commutative Algebra', '(size=3)', 'Generate a small documented example of a quotient ring.', 'professional_function_catalog.md'), + ('commutativeAlgebraNormalizeCommutativeRing', 'Commutative Algebra', '(value)', 'Normalize a commutative ring into the standard Commutative Algebra representation.', 'professional_function_catalog.md'), + ('commutativeAlgebraNormalizeIdeal', 'Commutative Algebra', '(value)', 'Normalize a ideal into the standard Commutative Algebra representation.', 'professional_function_catalog.md'), + ('commutativeAlgebraNormalizeLocalization', 'Commutative Algebra', '(value)', 'Normalize a localization into the standard Commutative Algebra representation.', 'professional_function_catalog.md'), + ('commutativeAlgebraNormalizeModule', 'Commutative Algebra', '(value)', 'Normalize a module into the standard Commutative Algebra representation.', 'professional_function_catalog.md'), + ('commutativeAlgebraNormalizeQuotientRing', 'Commutative Algebra', '(value)', 'Normalize a quotient ring into the standard Commutative Algebra representation.', 'professional_function_catalog.md'), + ('commutativeAlgebraParseCommutativeRing', 'Commutative Algebra', '(text)', 'Parse a text or structured value into a commutative ring.', 'professional_function_catalog.md'), + ('commutativeAlgebraParseIdeal', 'Commutative Algebra', '(text)', 'Parse a text or structured value into a ideal.', 'professional_function_catalog.md'), + ('commutativeAlgebraParseLocalization', 'Commutative Algebra', '(text)', 'Parse a text or structured value into a localization.', 'professional_function_catalog.md'), + ('commutativeAlgebraParseModule', 'Commutative Algebra', '(text)', 'Parse a text or structured value into a module.', 'professional_function_catalog.md'), + ('commutativeAlgebraParseQuotientRing', 'Commutative Algebra', '(text)', 'Parse a text or structured value into a quotient ring.', 'professional_function_catalog.md'), + ('commutativeAlgebraSimplifyCommutativeRing', 'Commutative Algebra', '(value)', 'Simplify a commutative ring without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('commutativeAlgebraSimplifyIdeal', 'Commutative Algebra', '(value)', 'Simplify a ideal without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('commutativeAlgebraSimplifyLocalization', 'Commutative Algebra', '(value)', 'Simplify a localization without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('commutativeAlgebraSimplifyModule', 'Commutative Algebra', '(value)', 'Simplify a module without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('commutativeAlgebraSimplifyQuotientRing', 'Commutative Algebra', '(value)', 'Simplify a quotient ring without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('commutativeAlgebraTestEquivalenceCommutativeRing', 'Commutative Algebra', '(left, right)', 'Test whether two commutative ring values are equivalent in Commutative Algebra.', 'professional_function_catalog.md'), + ('commutativeAlgebraTestEquivalenceIdeal', 'Commutative Algebra', '(left, right)', 'Test whether two ideal values are equivalent in Commutative Algebra.', 'professional_function_catalog.md'), + ('commutativeAlgebraTestEquivalenceLocalization', 'Commutative Algebra', '(left, right)', 'Test whether two localization values are equivalent in Commutative Algebra.', 'professional_function_catalog.md'), + ('commutativeAlgebraTestEquivalenceModule', 'Commutative Algebra', '(left, right)', 'Test whether two module values are equivalent in Commutative Algebra.', 'professional_function_catalog.md'), + ('commutativeAlgebraTestEquivalenceQuotientRing', 'Commutative Algebra', '(left, right)', 'Test whether two quotient ring values are equivalent in Commutative Algebra.', 'professional_function_catalog.md'), + ('commutativeAlgebraTransformCommutativeRing', 'Commutative Algebra', '(value, mapping)', 'Transform a commutative ring through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('commutativeAlgebraTransformIdeal', 'Commutative Algebra', '(value, mapping)', 'Transform a ideal through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('commutativeAlgebraTransformLocalization', 'Commutative Algebra', '(value, mapping)', 'Transform a localization through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('commutativeAlgebraTransformModule', 'Commutative Algebra', '(value, mapping)', 'Transform a module through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('commutativeAlgebraTransformQuotientRing', 'Commutative Algebra', '(value, mapping)', 'Transform a quotient ring through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('commutativeAlgebraValidateCommutativeRing', 'Commutative Algebra', '(value)', 'Validate the commutative ring representation and domain rules for Commutative Algebra.', 'professional_function_catalog.md'), + ('commutativeAlgebraValidateIdeal', 'Commutative Algebra', '(value)', 'Validate the ideal representation and domain rules for Commutative Algebra.', 'professional_function_catalog.md'), + ('commutativeAlgebraValidateLocalization', 'Commutative Algebra', '(value)', 'Validate the localization representation and domain rules for Commutative Algebra.', 'professional_function_catalog.md'), + ('commutativeAlgebraValidateModule', 'Commutative Algebra', '(value)', 'Validate the module representation and domain rules for Commutative Algebra.', 'professional_function_catalog.md'), + ('commutativeAlgebraValidateQuotientRing', 'Commutative Algebra', '(value)', 'Validate the quotient ring representation and domain rules for Commutative Algebra.', 'professional_function_catalog.md'), + ('idealGeneratedBy', 'Commutative Algebra', '(generators, ringElements, operations)', 'Planned roadmap function for Commutative Algebra from upcoming.md.', 'upcoming.md'), + ('idealProduct', 'Commutative Algebra', '(I, J, multiply)', 'Planned roadmap function for Commutative Algebra from upcoming.md.', 'upcoming.md'), + ('idealSum', 'Commutative Algebra', '(I, J)', 'Planned roadmap function for Commutative Algebra from upcoming.md.', 'upcoming.md'), + ('isIdeal', 'Commutative Algebra', '(subset, ringElements, add, multiply)', 'Planned roadmap function for Commutative Algebra from upcoming.md.', 'upcoming.md'), + ('isMaximalIdeal', 'Commutative Algebra', '(ideal, ringElements, operations)', 'Planned roadmap function for Commutative Algebra from upcoming.md.', 'upcoming.md'), + ('isPrimeIdeal', 'Commutative Algebra', '(ideal, ringElements, operations)', 'Planned roadmap function for Commutative Algebra from upcoming.md.', 'upcoming.md'), + ('quotientRingClasses', 'Commutative Algebra', '(ringElements, ideal)', 'Planned roadmap function for Commutative Algebra from upcoming.md.', 'upcoming.md'), + ('radicalIdealApprox', 'Commutative Algebra', '(ideal, candidates, powerLimit)', 'Planned roadmap function for Commutative Algebra from upcoming.md.', 'upcoming.md'), + ('cauchyRiemann', 'Complex Analysis', '(u, v, x, y, tolerance=1e-5)', 'Planned roadmap function for Complex Analysis from upcoming.md.', 'upcoming.md'), + ('complexAnalysisApproximateAnalyticCheck', 'Complex Analysis', '(value, tolerance=1e-9)', 'Approximate a analytic check with explicit tolerance controls.', 'professional_function_catalog.md'), + ('complexAnalysisApproximateComplexFunction', 'Complex Analysis', '(value, tolerance=1e-9)', 'Approximate a complex function with explicit tolerance controls.', 'professional_function_catalog.md'), + ('complexAnalysisApproximateComplexTransform', 'Complex Analysis', '(value, tolerance=1e-9)', 'Approximate a complex transform with explicit tolerance controls.', 'professional_function_catalog.md'), + ('complexAnalysisApproximateContour', 'Complex Analysis', '(value, tolerance=1e-9)', 'Approximate a contour with explicit tolerance controls.', 'professional_function_catalog.md'), + ('complexAnalysisApproximateSingularity', 'Complex Analysis', '(value, tolerance=1e-9)', 'Approximate a singularity with explicit tolerance controls.', 'professional_function_catalog.md'), + ('complexAnalysisCanonicalizeAnalyticCheck', 'Complex Analysis', '(value)', 'Canonicalize a analytic check so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('complexAnalysisCanonicalizeComplexFunction', 'Complex Analysis', '(value)', 'Canonicalize a complex function so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('complexAnalysisCanonicalizeComplexTransform', 'Complex Analysis', '(value)', 'Canonicalize a complex transform so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('complexAnalysisCanonicalizeContour', 'Complex Analysis', '(value)', 'Canonicalize a contour so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('complexAnalysisCanonicalizeSingularity', 'Complex Analysis', '(value)', 'Canonicalize a singularity so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('complexAnalysisClassifyAnalyticCheck', 'Complex Analysis', '(value)', 'Classify a analytic check by its standard Complex Analysis invariants.', 'professional_function_catalog.md'), + ('complexAnalysisClassifyComplexFunction', 'Complex Analysis', '(value)', 'Classify a complex function by its standard Complex Analysis invariants.', 'professional_function_catalog.md'), + ('complexAnalysisClassifyComplexTransform', 'Complex Analysis', '(value)', 'Classify a complex transform by its standard Complex Analysis invariants.', 'professional_function_catalog.md'), + ('complexAnalysisClassifyContour', 'Complex Analysis', '(value)', 'Classify a contour by its standard Complex Analysis invariants.', 'professional_function_catalog.md'), + ('complexAnalysisClassifySingularity', 'Complex Analysis', '(value)', 'Classify a singularity by its standard Complex Analysis invariants.', 'professional_function_catalog.md'), + ('complexAnalysisCombineAnalyticCheck', 'Complex Analysis', '(left, right)', 'Combine two analytic check values with the natural operation for Complex Analysis.', 'professional_function_catalog.md'), + ('complexAnalysisCombineComplexFunction', 'Complex Analysis', '(left, right)', 'Combine two complex function values with the natural operation for Complex Analysis.', 'professional_function_catalog.md'), + ('complexAnalysisCombineComplexTransform', 'Complex Analysis', '(left, right)', 'Combine two complex transform values with the natural operation for Complex Analysis.', 'professional_function_catalog.md'), + ('complexAnalysisCombineContour', 'Complex Analysis', '(left, right)', 'Combine two contour values with the natural operation for Complex Analysis.', 'professional_function_catalog.md'), + ('complexAnalysisCombineSingularity', 'Complex Analysis', '(left, right)', 'Combine two singularity values with the natural operation for Complex Analysis.', 'professional_function_catalog.md'), + ('complexAnalysisCompareAnalyticCheck', 'Complex Analysis', '(left, right)', 'Compare two analytic check values under the conventions of Complex Analysis.', 'professional_function_catalog.md'), + ('complexAnalysisCompareComplexFunction', 'Complex Analysis', '(left, right)', 'Compare two complex function values under the conventions of Complex Analysis.', 'professional_function_catalog.md'), + ('complexAnalysisCompareComplexTransform', 'Complex Analysis', '(left, right)', 'Compare two complex transform values under the conventions of Complex Analysis.', 'professional_function_catalog.md'), + ('complexAnalysisCompareContour', 'Complex Analysis', '(left, right)', 'Compare two contour values under the conventions of Complex Analysis.', 'professional_function_catalog.md'), + ('complexAnalysisCompareSingularity', 'Complex Analysis', '(left, right)', 'Compare two singularity values under the conventions of Complex Analysis.', 'professional_function_catalog.md'), + ('complexAnalysisComputeAnalyticCheck', 'Complex Analysis', '(value)', 'Compute the central numerical or symbolic data of a analytic check.', 'professional_function_catalog.md'), + ('complexAnalysisComputeComplexFunction', 'Complex Analysis', '(value)', 'Compute the central numerical or symbolic data of a complex function.', 'professional_function_catalog.md'), + ('complexAnalysisComputeComplexTransform', 'Complex Analysis', '(value)', 'Compute the central numerical or symbolic data of a complex transform.', 'professional_function_catalog.md'), + ('complexAnalysisComputeContour', 'Complex Analysis', '(value)', 'Compute the central numerical or symbolic data of a contour.', 'professional_function_catalog.md'), + ('complexAnalysisComputeSingularity', 'Complex Analysis', '(value)', 'Compute the central numerical or symbolic data of a singularity.', 'professional_function_catalog.md'), + ('complexAnalysisConstructAnalyticCheck', 'Complex Analysis', '(*args)', 'Construct a analytic check from explicit inputs for Complex Analysis.', 'professional_function_catalog.md'), + ('complexAnalysisConstructComplexFunction', 'Complex Analysis', '(*args)', 'Construct a complex function from explicit inputs for Complex Analysis.', 'professional_function_catalog.md'), + ('complexAnalysisConstructComplexTransform', 'Complex Analysis', '(*args)', 'Construct a complex transform from explicit inputs for Complex Analysis.', 'professional_function_catalog.md'), + ('complexAnalysisConstructContour', 'Complex Analysis', '(*args)', 'Construct a contour from explicit inputs for Complex Analysis.', 'professional_function_catalog.md'), + ('complexAnalysisConstructSingularity', 'Complex Analysis', '(*args)', 'Construct a singularity from explicit inputs for Complex Analysis.', 'professional_function_catalog.md'), + ('complexAnalysisDecomposeAnalyticCheck', 'Complex Analysis', '(value)', 'Decompose a analytic check into simpler or canonical components.', 'professional_function_catalog.md'), + ('complexAnalysisDecomposeComplexFunction', 'Complex Analysis', '(value)', 'Decompose a complex function into simpler or canonical components.', 'professional_function_catalog.md'), + ('complexAnalysisDecomposeComplexTransform', 'Complex Analysis', '(value)', 'Decompose a complex transform into simpler or canonical components.', 'professional_function_catalog.md'), + ('complexAnalysisDecomposeContour', 'Complex Analysis', '(value)', 'Decompose a contour into simpler or canonical components.', 'professional_function_catalog.md'), + ('complexAnalysisDecomposeSingularity', 'Complex Analysis', '(value)', 'Decompose a singularity into simpler or canonical components.', 'professional_function_catalog.md'), + ('complexAnalysisDocumentAnalyticCheck', 'Complex Analysis', '(value)', 'Return a structured explanation of a analytic check and related assumptions.', 'professional_function_catalog.md'), + ('complexAnalysisDocumentComplexFunction', 'Complex Analysis', '(value)', 'Return a structured explanation of a complex function and related assumptions.', 'professional_function_catalog.md'), + ('complexAnalysisDocumentComplexTransform', 'Complex Analysis', '(value)', 'Return a structured explanation of a complex transform and related assumptions.', 'professional_function_catalog.md'), + ('complexAnalysisDocumentContour', 'Complex Analysis', '(value)', 'Return a structured explanation of a contour and related assumptions.', 'professional_function_catalog.md'), + ('complexAnalysisDocumentSingularity', 'Complex Analysis', '(value)', 'Return a structured explanation of a singularity and related assumptions.', 'professional_function_catalog.md'), + ('complexAnalysisEnumerateAnalyticCheck', 'Complex Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a analytic check.', 'professional_function_catalog.md'), + ('complexAnalysisEnumerateComplexFunction', 'Complex Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a complex function.', 'professional_function_catalog.md'), + ('complexAnalysisEnumerateComplexTransform', 'Complex Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a complex transform.', 'professional_function_catalog.md'), + ('complexAnalysisEnumerateContour', 'Complex Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a contour.', 'professional_function_catalog.md'), + ('complexAnalysisEnumerateSingularity', 'Complex Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a singularity.', 'professional_function_catalog.md'), + ('complexAnalysisEstimateAnalyticCheck', 'Complex Analysis', '(value, samples=None)', 'Estimate a analytic check property from finite samples or approximations.', 'professional_function_catalog.md'), + ('complexAnalysisEstimateComplexFunction', 'Complex Analysis', '(value, samples=None)', 'Estimate a complex function property from finite samples or approximations.', 'professional_function_catalog.md'), + ('complexAnalysisEstimateComplexTransform', 'Complex Analysis', '(value, samples=None)', 'Estimate a complex transform property from finite samples or approximations.', 'professional_function_catalog.md'), + ('complexAnalysisEstimateContour', 'Complex Analysis', '(value, samples=None)', 'Estimate a contour property from finite samples or approximations.', 'professional_function_catalog.md'), + ('complexAnalysisEstimateSingularity', 'Complex Analysis', '(value, samples=None)', 'Estimate a singularity property from finite samples or approximations.', 'professional_function_catalog.md'), + ('complexAnalysisEvaluateAnalyticCheck', 'Complex Analysis', '(value, point=None)', 'Evaluate a analytic check at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('complexAnalysisEvaluateComplexFunction', 'Complex Analysis', '(value, point=None)', 'Evaluate a complex function at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('complexAnalysisEvaluateComplexTransform', 'Complex Analysis', '(value, point=None)', 'Evaluate a complex transform at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('complexAnalysisEvaluateContour', 'Complex Analysis', '(value, point=None)', 'Evaluate a contour at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('complexAnalysisEvaluateSingularity', 'Complex Analysis', '(value, point=None)', 'Evaluate a singularity at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('complexAnalysisFormatAnalyticCheck', 'Complex Analysis', '(value)', 'Format a analytic check for deterministic user-facing output.', 'professional_function_catalog.md'), + ('complexAnalysisFormatComplexFunction', 'Complex Analysis', '(value)', 'Format a complex function for deterministic user-facing output.', 'professional_function_catalog.md'), + ('complexAnalysisFormatComplexTransform', 'Complex Analysis', '(value)', 'Format a complex transform for deterministic user-facing output.', 'professional_function_catalog.md'), + ('complexAnalysisFormatContour', 'Complex Analysis', '(value)', 'Format a contour for deterministic user-facing output.', 'professional_function_catalog.md'), + ('complexAnalysisFormatSingularity', 'Complex Analysis', '(value)', 'Format a singularity for deterministic user-facing output.', 'professional_function_catalog.md'), + ('complexAnalysisGenerateExampleAnalyticCheck', 'Complex Analysis', '(size=3)', 'Generate a small documented example of a analytic check.', 'professional_function_catalog.md'), + ('complexAnalysisGenerateExampleComplexFunction', 'Complex Analysis', '(size=3)', 'Generate a small documented example of a complex function.', 'professional_function_catalog.md'), + ('complexAnalysisGenerateExampleComplexTransform', 'Complex Analysis', '(size=3)', 'Generate a small documented example of a complex transform.', 'professional_function_catalog.md'), + ('complexAnalysisGenerateExampleContour', 'Complex Analysis', '(size=3)', 'Generate a small documented example of a contour.', 'professional_function_catalog.md'), + ('complexAnalysisGenerateExampleSingularity', 'Complex Analysis', '(size=3)', 'Generate a small documented example of a singularity.', 'professional_function_catalog.md'), + ('complexAnalysisNormalizeAnalyticCheck', 'Complex Analysis', '(value)', 'Normalize a analytic check into the standard Complex Analysis representation.', 'professional_function_catalog.md'), + ('complexAnalysisNormalizeComplexFunction', 'Complex Analysis', '(value)', 'Normalize a complex function into the standard Complex Analysis representation.', 'professional_function_catalog.md'), + ('complexAnalysisNormalizeComplexTransform', 'Complex Analysis', '(value)', 'Normalize a complex transform into the standard Complex Analysis representation.', 'professional_function_catalog.md'), + ('complexAnalysisNormalizeContour', 'Complex Analysis', '(value)', 'Normalize a contour into the standard Complex Analysis representation.', 'professional_function_catalog.md'), + ('complexAnalysisNormalizeSingularity', 'Complex Analysis', '(value)', 'Normalize a singularity into the standard Complex Analysis representation.', 'professional_function_catalog.md'), + ('complexAnalysisParseAnalyticCheck', 'Complex Analysis', '(text)', 'Parse a text or structured value into a analytic check.', 'professional_function_catalog.md'), + ('complexAnalysisParseComplexFunction', 'Complex Analysis', '(text)', 'Parse a text or structured value into a complex function.', 'professional_function_catalog.md'), + ('complexAnalysisParseComplexTransform', 'Complex Analysis', '(text)', 'Parse a text or structured value into a complex transform.', 'professional_function_catalog.md'), + ('complexAnalysisParseContour', 'Complex Analysis', '(text)', 'Parse a text or structured value into a contour.', 'professional_function_catalog.md'), + ('complexAnalysisParseSingularity', 'Complex Analysis', '(text)', 'Parse a text or structured value into a singularity.', 'professional_function_catalog.md'), + ('complexAnalysisSimplifyAnalyticCheck', 'Complex Analysis', '(value)', 'Simplify a analytic check without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('complexAnalysisSimplifyComplexFunction', 'Complex Analysis', '(value)', 'Simplify a complex function without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('complexAnalysisSimplifyComplexTransform', 'Complex Analysis', '(value)', 'Simplify a complex transform without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('complexAnalysisSimplifyContour', 'Complex Analysis', '(value)', 'Simplify a contour without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('complexAnalysisSimplifySingularity', 'Complex Analysis', '(value)', 'Simplify a singularity without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('complexAnalysisTestEquivalenceAnalyticCheck', 'Complex Analysis', '(left, right)', 'Test whether two analytic check values are equivalent in Complex Analysis.', 'professional_function_catalog.md'), + ('complexAnalysisTestEquivalenceComplexFunction', 'Complex Analysis', '(left, right)', 'Test whether two complex function values are equivalent in Complex Analysis.', 'professional_function_catalog.md'), + ('complexAnalysisTestEquivalenceComplexTransform', 'Complex Analysis', '(left, right)', 'Test whether two complex transform values are equivalent in Complex Analysis.', 'professional_function_catalog.md'), + ('complexAnalysisTestEquivalenceContour', 'Complex Analysis', '(left, right)', 'Test whether two contour values are equivalent in Complex Analysis.', 'professional_function_catalog.md'), + ('complexAnalysisTestEquivalenceSingularity', 'Complex Analysis', '(left, right)', 'Test whether two singularity values are equivalent in Complex Analysis.', 'professional_function_catalog.md'), + ('complexAnalysisTransformAnalyticCheck', 'Complex Analysis', '(value, mapping)', 'Transform a analytic check through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('complexAnalysisTransformComplexFunction', 'Complex Analysis', '(value, mapping)', 'Transform a complex function through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('complexAnalysisTransformComplexTransform', 'Complex Analysis', '(value, mapping)', 'Transform a complex transform through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('complexAnalysisTransformContour', 'Complex Analysis', '(value, mapping)', 'Transform a contour through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('complexAnalysisTransformSingularity', 'Complex Analysis', '(value, mapping)', 'Transform a singularity through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('complexAnalysisValidateAnalyticCheck', 'Complex Analysis', '(value)', 'Validate the analytic check representation and domain rules for Complex Analysis.', 'professional_function_catalog.md'), + ('complexAnalysisValidateComplexFunction', 'Complex Analysis', '(value)', 'Validate the complex function representation and domain rules for Complex Analysis.', 'professional_function_catalog.md'), + ('complexAnalysisValidateComplexTransform', 'Complex Analysis', '(value)', 'Validate the complex transform representation and domain rules for Complex Analysis.', 'professional_function_catalog.md'), + ('complexAnalysisValidateContour', 'Complex Analysis', '(value)', 'Validate the contour representation and domain rules for Complex Analysis.', 'professional_function_catalog.md'), + ('complexAnalysisValidateSingularity', 'Complex Analysis', '(value)', 'Validate the singularity representation and domain rules for Complex Analysis.', 'professional_function_catalog.md'), + ('complexDerivative', 'Complex Analysis', '(f, z, h=1e-5)', 'Planned roadmap function for Complex Analysis from upcoming.md.', 'upcoming.md'), + ('complexExponential', 'Complex Analysis', '(z)', 'Planned roadmap function for Complex Analysis from upcoming.md.', 'upcoming.md'), + ('complexLog', 'Complex Analysis', '(z)', 'Planned roadmap function for Complex Analysis from upcoming.md.', 'upcoming.md'), + ('contourIntegral', 'Complex Analysis', '(f, pathPoints)', 'Planned roadmap function for Complex Analysis from upcoming.md.', 'upcoming.md'), + ('isAnalytic', 'Complex Analysis', '(u, v, x, y, tolerance=1e-5)', 'Planned roadmap function for Complex Analysis from upcoming.md.', 'upcoming.md'), + ('mobiusTransform', 'Complex Analysis', '(z, a, b, c, d)', 'Planned roadmap function for Complex Analysis from upcoming.md.', 'upcoming.md'), + ('residueSimplePole', 'Complex Analysis', '(numerator, denominator, pole)', 'Planned roadmap function for Complex Analysis from upcoming.md.', 'upcoming.md'), + ('complex_argument', 'Complex Numbers', '(z)', 'Planned roadmap function for Complex Numbers from upcoming.md.', 'upcoming.md'), + ('complex_conjugate', 'Complex Numbers', '(z)', 'Planned roadmap function for Complex Numbers from upcoming.md.', 'upcoming.md'), + ('complex_division', 'Complex Numbers', '(a, b)', 'Planned roadmap function for Complex Numbers from upcoming.md.', 'upcoming.md'), + ('complex_modulus', 'Complex Numbers', '(z)', 'Planned roadmap function for Complex Numbers from upcoming.md.', 'upcoming.md'), + ('complex_multiplication', 'Complex Numbers', '(a, b)', 'Planned roadmap function for Complex Numbers from upcoming.md.', 'upcoming.md'), + ('complex_power', 'Complex Numbers', '(z, n)', 'Planned roadmap function for Complex Numbers from upcoming.md.', 'upcoming.md'), + ('complexNumbersApproximateComplexOperation', 'Complex Numbers', '(value, tolerance=1e-9)', 'Approximate a complex operation with explicit tolerance controls.', 'professional_function_catalog.md'), + ('complexNumbersApproximateComplexSequence', 'Complex Numbers', '(value, tolerance=1e-9)', 'Approximate a complex sequence with explicit tolerance controls.', 'professional_function_catalog.md'), + ('complexNumbersApproximateComplexValue', 'Complex Numbers', '(value, tolerance=1e-9)', 'Approximate a complex value with explicit tolerance controls.', 'professional_function_catalog.md'), + ('complexNumbersApproximatePolarForm', 'Complex Numbers', '(value, tolerance=1e-9)', 'Approximate a polar form with explicit tolerance controls.', 'professional_function_catalog.md'), + ('complexNumbersApproximateRectangularForm', 'Complex Numbers', '(value, tolerance=1e-9)', 'Approximate a rectangular form with explicit tolerance controls.', 'professional_function_catalog.md'), + ('complexNumbersCanonicalizeComplexOperation', 'Complex Numbers', '(value)', 'Canonicalize a complex operation so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('complexNumbersCanonicalizeComplexSequence', 'Complex Numbers', '(value)', 'Canonicalize a complex sequence so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('complexNumbersCanonicalizeComplexValue', 'Complex Numbers', '(value)', 'Canonicalize a complex value so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('complexNumbersCanonicalizePolarForm', 'Complex Numbers', '(value)', 'Canonicalize a polar form so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('complexNumbersCanonicalizeRectangularForm', 'Complex Numbers', '(value)', 'Canonicalize a rectangular form so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('complexNumbersClassifyComplexOperation', 'Complex Numbers', '(value)', 'Classify a complex operation by its standard Complex Numbers invariants.', 'professional_function_catalog.md'), + ('complexNumbersClassifyComplexSequence', 'Complex Numbers', '(value)', 'Classify a complex sequence by its standard Complex Numbers invariants.', 'professional_function_catalog.md'), + ('complexNumbersClassifyComplexValue', 'Complex Numbers', '(value)', 'Classify a complex value by its standard Complex Numbers invariants.', 'professional_function_catalog.md'), + ('complexNumbersClassifyPolarForm', 'Complex Numbers', '(value)', 'Classify a polar form by its standard Complex Numbers invariants.', 'professional_function_catalog.md'), + ('complexNumbersClassifyRectangularForm', 'Complex Numbers', '(value)', 'Classify a rectangular form by its standard Complex Numbers invariants.', 'professional_function_catalog.md'), + ('complexNumbersCombineComplexOperation', 'Complex Numbers', '(left, right)', 'Combine two complex operation values with the natural operation for Complex Numbers.', 'professional_function_catalog.md'), + ('complexNumbersCombineComplexSequence', 'Complex Numbers', '(left, right)', 'Combine two complex sequence values with the natural operation for Complex Numbers.', 'professional_function_catalog.md'), + ('complexNumbersCombineComplexValue', 'Complex Numbers', '(left, right)', 'Combine two complex value values with the natural operation for Complex Numbers.', 'professional_function_catalog.md'), + ('complexNumbersCombinePolarForm', 'Complex Numbers', '(left, right)', 'Combine two polar form values with the natural operation for Complex Numbers.', 'professional_function_catalog.md'), + ('complexNumbersCombineRectangularForm', 'Complex Numbers', '(left, right)', 'Combine two rectangular form values with the natural operation for Complex Numbers.', 'professional_function_catalog.md'), + ('complexNumbersCompareComplexOperation', 'Complex Numbers', '(left, right)', 'Compare two complex operation values under the conventions of Complex Numbers.', 'professional_function_catalog.md'), + ('complexNumbersCompareComplexSequence', 'Complex Numbers', '(left, right)', 'Compare two complex sequence values under the conventions of Complex Numbers.', 'professional_function_catalog.md'), + ('complexNumbersCompareComplexValue', 'Complex Numbers', '(left, right)', 'Compare two complex value values under the conventions of Complex Numbers.', 'professional_function_catalog.md'), + ('complexNumbersComparePolarForm', 'Complex Numbers', '(left, right)', 'Compare two polar form values under the conventions of Complex Numbers.', 'professional_function_catalog.md'), + ('complexNumbersCompareRectangularForm', 'Complex Numbers', '(left, right)', 'Compare two rectangular form values under the conventions of Complex Numbers.', 'professional_function_catalog.md'), + ('complexNumbersComputeComplexOperation', 'Complex Numbers', '(value)', 'Compute the central numerical or symbolic data of a complex operation.', 'professional_function_catalog.md'), + ('complexNumbersComputeComplexSequence', 'Complex Numbers', '(value)', 'Compute the central numerical or symbolic data of a complex sequence.', 'professional_function_catalog.md'), + ('complexNumbersComputeComplexValue', 'Complex Numbers', '(value)', 'Compute the central numerical or symbolic data of a complex value.', 'professional_function_catalog.md'), + ('complexNumbersComputePolarForm', 'Complex Numbers', '(value)', 'Compute the central numerical or symbolic data of a polar form.', 'professional_function_catalog.md'), + ('complexNumbersComputeRectangularForm', 'Complex Numbers', '(value)', 'Compute the central numerical or symbolic data of a rectangular form.', 'professional_function_catalog.md'), + ('complexNumbersConstructComplexOperation', 'Complex Numbers', '(*args)', 'Construct a complex operation from explicit inputs for Complex Numbers.', 'professional_function_catalog.md'), + ('complexNumbersConstructComplexSequence', 'Complex Numbers', '(*args)', 'Construct a complex sequence from explicit inputs for Complex Numbers.', 'professional_function_catalog.md'), + ('complexNumbersConstructComplexValue', 'Complex Numbers', '(*args)', 'Construct a complex value from explicit inputs for Complex Numbers.', 'professional_function_catalog.md'), + ('complexNumbersConstructPolarForm', 'Complex Numbers', '(*args)', 'Construct a polar form from explicit inputs for Complex Numbers.', 'professional_function_catalog.md'), + ('complexNumbersConstructRectangularForm', 'Complex Numbers', '(*args)', 'Construct a rectangular form from explicit inputs for Complex Numbers.', 'professional_function_catalog.md'), + ('complexNumbersDecomposeComplexOperation', 'Complex Numbers', '(value)', 'Decompose a complex operation into simpler or canonical components.', 'professional_function_catalog.md'), + ('complexNumbersDecomposeComplexSequence', 'Complex Numbers', '(value)', 'Decompose a complex sequence into simpler or canonical components.', 'professional_function_catalog.md'), + ('complexNumbersDecomposeComplexValue', 'Complex Numbers', '(value)', 'Decompose a complex value into simpler or canonical components.', 'professional_function_catalog.md'), + ('complexNumbersDecomposePolarForm', 'Complex Numbers', '(value)', 'Decompose a polar form into simpler or canonical components.', 'professional_function_catalog.md'), + ('complexNumbersDecomposeRectangularForm', 'Complex Numbers', '(value)', 'Decompose a rectangular form into simpler or canonical components.', 'professional_function_catalog.md'), + ('complexNumbersDocumentComplexOperation', 'Complex Numbers', '(value)', 'Return a structured explanation of a complex operation and related assumptions.', 'professional_function_catalog.md'), + ('complexNumbersDocumentComplexSequence', 'Complex Numbers', '(value)', 'Return a structured explanation of a complex sequence and related assumptions.', 'professional_function_catalog.md'), + ('complexNumbersDocumentComplexValue', 'Complex Numbers', '(value)', 'Return a structured explanation of a complex value and related assumptions.', 'professional_function_catalog.md'), + ('complexNumbersDocumentPolarForm', 'Complex Numbers', '(value)', 'Return a structured explanation of a polar form and related assumptions.', 'professional_function_catalog.md'), + ('complexNumbersDocumentRectangularForm', 'Complex Numbers', '(value)', 'Return a structured explanation of a rectangular form and related assumptions.', 'professional_function_catalog.md'), + ('complexNumbersEnumerateComplexOperation', 'Complex Numbers', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a complex operation.', 'professional_function_catalog.md'), + ('complexNumbersEnumerateComplexSequence', 'Complex Numbers', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a complex sequence.', 'professional_function_catalog.md'), + ('complexNumbersEnumerateComplexValue', 'Complex Numbers', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a complex value.', 'professional_function_catalog.md'), + ('complexNumbersEnumeratePolarForm', 'Complex Numbers', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a polar form.', 'professional_function_catalog.md'), + ('complexNumbersEnumerateRectangularForm', 'Complex Numbers', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a rectangular form.', 'professional_function_catalog.md'), + ('complexNumbersEstimateComplexOperation', 'Complex Numbers', '(value, samples=None)', 'Estimate a complex operation property from finite samples or approximations.', 'professional_function_catalog.md'), + ('complexNumbersEstimateComplexSequence', 'Complex Numbers', '(value, samples=None)', 'Estimate a complex sequence property from finite samples or approximations.', 'professional_function_catalog.md'), + ('complexNumbersEstimateComplexValue', 'Complex Numbers', '(value, samples=None)', 'Estimate a complex value property from finite samples or approximations.', 'professional_function_catalog.md'), + ('complexNumbersEstimatePolarForm', 'Complex Numbers', '(value, samples=None)', 'Estimate a polar form property from finite samples or approximations.', 'professional_function_catalog.md'), + ('complexNumbersEstimateRectangularForm', 'Complex Numbers', '(value, samples=None)', 'Estimate a rectangular form property from finite samples or approximations.', 'professional_function_catalog.md'), + ('complexNumbersEvaluateComplexOperation', 'Complex Numbers', '(value, point=None)', 'Evaluate a complex operation at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('complexNumbersEvaluateComplexSequence', 'Complex Numbers', '(value, point=None)', 'Evaluate a complex sequence at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('complexNumbersEvaluateComplexValue', 'Complex Numbers', '(value, point=None)', 'Evaluate a complex value at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('complexNumbersEvaluatePolarForm', 'Complex Numbers', '(value, point=None)', 'Evaluate a polar form at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('complexNumbersEvaluateRectangularForm', 'Complex Numbers', '(value, point=None)', 'Evaluate a rectangular form at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('complexNumbersFormatComplexOperation', 'Complex Numbers', '(value)', 'Format a complex operation for deterministic user-facing output.', 'professional_function_catalog.md'), + ('complexNumbersFormatComplexSequence', 'Complex Numbers', '(value)', 'Format a complex sequence for deterministic user-facing output.', 'professional_function_catalog.md'), + ('complexNumbersFormatComplexValue', 'Complex Numbers', '(value)', 'Format a complex value for deterministic user-facing output.', 'professional_function_catalog.md'), + ('complexNumbersFormatPolarForm', 'Complex Numbers', '(value)', 'Format a polar form for deterministic user-facing output.', 'professional_function_catalog.md'), + ('complexNumbersFormatRectangularForm', 'Complex Numbers', '(value)', 'Format a rectangular form for deterministic user-facing output.', 'professional_function_catalog.md'), + ('complexNumbersGenerateExampleComplexOperation', 'Complex Numbers', '(size=3)', 'Generate a small documented example of a complex operation.', 'professional_function_catalog.md'), + ('complexNumbersGenerateExampleComplexSequence', 'Complex Numbers', '(size=3)', 'Generate a small documented example of a complex sequence.', 'professional_function_catalog.md'), + ('complexNumbersGenerateExampleComplexValue', 'Complex Numbers', '(size=3)', 'Generate a small documented example of a complex value.', 'professional_function_catalog.md'), + ('complexNumbersGenerateExamplePolarForm', 'Complex Numbers', '(size=3)', 'Generate a small documented example of a polar form.', 'professional_function_catalog.md'), + ('complexNumbersGenerateExampleRectangularForm', 'Complex Numbers', '(size=3)', 'Generate a small documented example of a rectangular form.', 'professional_function_catalog.md'), + ('complexNumbersNormalizeComplexOperation', 'Complex Numbers', '(value)', 'Normalize a complex operation into the standard Complex Numbers representation.', 'professional_function_catalog.md'), + ('complexNumbersNormalizeComplexSequence', 'Complex Numbers', '(value)', 'Normalize a complex sequence into the standard Complex Numbers representation.', 'professional_function_catalog.md'), + ('complexNumbersNormalizeComplexValue', 'Complex Numbers', '(value)', 'Normalize a complex value into the standard Complex Numbers representation.', 'professional_function_catalog.md'), + ('complexNumbersNormalizePolarForm', 'Complex Numbers', '(value)', 'Normalize a polar form into the standard Complex Numbers representation.', 'professional_function_catalog.md'), + ('complexNumbersNormalizeRectangularForm', 'Complex Numbers', '(value)', 'Normalize a rectangular form into the standard Complex Numbers representation.', 'professional_function_catalog.md'), + ('complexNumbersParseComplexOperation', 'Complex Numbers', '(text)', 'Parse a text or structured value into a complex operation.', 'professional_function_catalog.md'), + ('complexNumbersParseComplexSequence', 'Complex Numbers', '(text)', 'Parse a text or structured value into a complex sequence.', 'professional_function_catalog.md'), + ('complexNumbersParseComplexValue', 'Complex Numbers', '(text)', 'Parse a text or structured value into a complex value.', 'professional_function_catalog.md'), + ('complexNumbersParsePolarForm', 'Complex Numbers', '(text)', 'Parse a text or structured value into a polar form.', 'professional_function_catalog.md'), + ('complexNumbersParseRectangularForm', 'Complex Numbers', '(text)', 'Parse a text or structured value into a rectangular form.', 'professional_function_catalog.md'), + ('complexNumbersSimplifyComplexOperation', 'Complex Numbers', '(value)', 'Simplify a complex operation without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('complexNumbersSimplifyComplexSequence', 'Complex Numbers', '(value)', 'Simplify a complex sequence without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('complexNumbersSimplifyComplexValue', 'Complex Numbers', '(value)', 'Simplify a complex value without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('complexNumbersSimplifyPolarForm', 'Complex Numbers', '(value)', 'Simplify a polar form without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('complexNumbersSimplifyRectangularForm', 'Complex Numbers', '(value)', 'Simplify a rectangular form without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('complexNumbersTestEquivalenceComplexOperation', 'Complex Numbers', '(left, right)', 'Test whether two complex operation values are equivalent in Complex Numbers.', 'professional_function_catalog.md'), + ('complexNumbersTestEquivalenceComplexSequence', 'Complex Numbers', '(left, right)', 'Test whether two complex sequence values are equivalent in Complex Numbers.', 'professional_function_catalog.md'), + ('complexNumbersTestEquivalenceComplexValue', 'Complex Numbers', '(left, right)', 'Test whether two complex value values are equivalent in Complex Numbers.', 'professional_function_catalog.md'), + ('complexNumbersTestEquivalencePolarForm', 'Complex Numbers', '(left, right)', 'Test whether two polar form values are equivalent in Complex Numbers.', 'professional_function_catalog.md'), + ('complexNumbersTestEquivalenceRectangularForm', 'Complex Numbers', '(left, right)', 'Test whether two rectangular form values are equivalent in Complex Numbers.', 'professional_function_catalog.md'), + ('complexNumbersTransformComplexOperation', 'Complex Numbers', '(value, mapping)', 'Transform a complex operation through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('complexNumbersTransformComplexSequence', 'Complex Numbers', '(value, mapping)', 'Transform a complex sequence through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('complexNumbersTransformComplexValue', 'Complex Numbers', '(value, mapping)', 'Transform a complex value through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('complexNumbersTransformPolarForm', 'Complex Numbers', '(value, mapping)', 'Transform a polar form through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('complexNumbersTransformRectangularForm', 'Complex Numbers', '(value, mapping)', 'Transform a rectangular form through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('complexNumbersValidateComplexOperation', 'Complex Numbers', '(value)', 'Validate the complex operation representation and domain rules for Complex Numbers.', 'professional_function_catalog.md'), + ('complexNumbersValidateComplexSequence', 'Complex Numbers', '(value)', 'Validate the complex sequence representation and domain rules for Complex Numbers.', 'professional_function_catalog.md'), + ('complexNumbersValidateComplexValue', 'Complex Numbers', '(value)', 'Validate the complex value representation and domain rules for Complex Numbers.', 'professional_function_catalog.md'), + ('complexNumbersValidatePolarForm', 'Complex Numbers', '(value)', 'Validate the polar form representation and domain rules for Complex Numbers.', 'professional_function_catalog.md'), + ('complexNumbersValidateRectangularForm', 'Complex Numbers', '(value)', 'Validate the rectangular form representation and domain rules for Complex Numbers.', 'professional_function_catalog.md'), + ('formatComplex', 'Complex Numbers', '(real, imaginary)', 'Planned roadmap function for Complex Numbers from upcoming.md.', 'upcoming.md'), + ('parseComplex', 'Complex Numbers', '(z)', 'Planned roadmap function for Complex Numbers from upcoming.md.', 'upcoming.md'), + ('polarToRectangular', 'Complex Numbers', '(r, theta)', 'Planned roadmap function for Complex Numbers from upcoming.md.', 'upcoming.md'), + ('rectangularToPolar', 'Complex Numbers', '(z)', 'Planned roadmap function for Complex Numbers from upcoming.md.', 'upcoming.md'), + ('characteristicFunction', 'Computability Theory', '(setValues, universalSet)', 'Planned roadmap function for Computability Theory from upcoming.md.', 'upcoming.md'), + ('composePartialFunctions', 'Computability Theory', '(f, g)', 'Planned roadmap function for Computability Theory from upcoming.md.', 'upcoming.md'), + ('computabilityTheoryApproximateDecider', 'Computability Theory', '(value, tolerance=1e-9)', 'Approximate a decider with explicit tolerance controls.', 'professional_function_catalog.md'), + ('computabilityTheoryApproximateEnumerator', 'Computability Theory', '(value, tolerance=1e-9)', 'Approximate a enumerator with explicit tolerance controls.', 'professional_function_catalog.md'), + ('computabilityTheoryApproximateLanguage', 'Computability Theory', '(value, tolerance=1e-9)', 'Approximate a language with explicit tolerance controls.', 'professional_function_catalog.md'), + ('computabilityTheoryApproximateMachine', 'Computability Theory', '(value, tolerance=1e-9)', 'Approximate a machine with explicit tolerance controls.', 'professional_function_catalog.md'), + ('computabilityTheoryApproximatePartialFunction', 'Computability Theory', '(value, tolerance=1e-9)', 'Approximate a partial function with explicit tolerance controls.', 'professional_function_catalog.md'), + ('computabilityTheoryCanonicalizeDecider', 'Computability Theory', '(value)', 'Canonicalize a decider so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('computabilityTheoryCanonicalizeEnumerator', 'Computability Theory', '(value)', 'Canonicalize a enumerator so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('computabilityTheoryCanonicalizeLanguage', 'Computability Theory', '(value)', 'Canonicalize a language so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('computabilityTheoryCanonicalizeMachine', 'Computability Theory', '(value)', 'Canonicalize a machine so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('computabilityTheoryCanonicalizePartialFunction', 'Computability Theory', '(value)', 'Canonicalize a partial function so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('computabilityTheoryClassifyDecider', 'Computability Theory', '(value)', 'Classify a decider by its standard Computability Theory invariants.', 'professional_function_catalog.md'), + ('computabilityTheoryClassifyEnumerator', 'Computability Theory', '(value)', 'Classify a enumerator by its standard Computability Theory invariants.', 'professional_function_catalog.md'), + ('computabilityTheoryClassifyLanguage', 'Computability Theory', '(value)', 'Classify a language by its standard Computability Theory invariants.', 'professional_function_catalog.md'), + ('computabilityTheoryClassifyMachine', 'Computability Theory', '(value)', 'Classify a machine by its standard Computability Theory invariants.', 'professional_function_catalog.md'), + ('computabilityTheoryClassifyPartialFunction', 'Computability Theory', '(value)', 'Classify a partial function by its standard Computability Theory invariants.', 'professional_function_catalog.md'), + ('computabilityTheoryCombineDecider', 'Computability Theory', '(left, right)', 'Combine two decider values with the natural operation for Computability Theory.', 'professional_function_catalog.md'), + ('computabilityTheoryCombineEnumerator', 'Computability Theory', '(left, right)', 'Combine two enumerator values with the natural operation for Computability Theory.', 'professional_function_catalog.md'), + ('computabilityTheoryCombineLanguage', 'Computability Theory', '(left, right)', 'Combine two language values with the natural operation for Computability Theory.', 'professional_function_catalog.md'), + ('computabilityTheoryCombineMachine', 'Computability Theory', '(left, right)', 'Combine two machine values with the natural operation for Computability Theory.', 'professional_function_catalog.md'), + ('computabilityTheoryCombinePartialFunction', 'Computability Theory', '(left, right)', 'Combine two partial function values with the natural operation for Computability Theory.', 'professional_function_catalog.md'), + ('computabilityTheoryCompareDecider', 'Computability Theory', '(left, right)', 'Compare two decider values under the conventions of Computability Theory.', 'professional_function_catalog.md'), + ('computabilityTheoryCompareEnumerator', 'Computability Theory', '(left, right)', 'Compare two enumerator values under the conventions of Computability Theory.', 'professional_function_catalog.md'), + ('computabilityTheoryCompareLanguage', 'Computability Theory', '(left, right)', 'Compare two language values under the conventions of Computability Theory.', 'professional_function_catalog.md'), + ('computabilityTheoryCompareMachine', 'Computability Theory', '(left, right)', 'Compare two machine values under the conventions of Computability Theory.', 'professional_function_catalog.md'), + ('computabilityTheoryComparePartialFunction', 'Computability Theory', '(left, right)', 'Compare two partial function values under the conventions of Computability Theory.', 'professional_function_catalog.md'), + ('computabilityTheoryComputeDecider', 'Computability Theory', '(value)', 'Compute the central numerical or symbolic data of a decider.', 'professional_function_catalog.md'), + ('computabilityTheoryComputeEnumerator', 'Computability Theory', '(value)', 'Compute the central numerical or symbolic data of a enumerator.', 'professional_function_catalog.md'), + ('computabilityTheoryComputeLanguage', 'Computability Theory', '(value)', 'Compute the central numerical or symbolic data of a language.', 'professional_function_catalog.md'), + ('computabilityTheoryComputeMachine', 'Computability Theory', '(value)', 'Compute the central numerical or symbolic data of a machine.', 'professional_function_catalog.md'), + ('computabilityTheoryComputePartialFunction', 'Computability Theory', '(value)', 'Compute the central numerical or symbolic data of a partial function.', 'professional_function_catalog.md'), + ('computabilityTheoryConstructDecider', 'Computability Theory', '(*args)', 'Construct a decider from explicit inputs for Computability Theory.', 'professional_function_catalog.md'), + ('computabilityTheoryConstructEnumerator', 'Computability Theory', '(*args)', 'Construct a enumerator from explicit inputs for Computability Theory.', 'professional_function_catalog.md'), + ('computabilityTheoryConstructLanguage', 'Computability Theory', '(*args)', 'Construct a language from explicit inputs for Computability Theory.', 'professional_function_catalog.md'), + ('computabilityTheoryConstructMachine', 'Computability Theory', '(*args)', 'Construct a machine from explicit inputs for Computability Theory.', 'professional_function_catalog.md'), + ('computabilityTheoryConstructPartialFunction', 'Computability Theory', '(*args)', 'Construct a partial function from explicit inputs for Computability Theory.', 'professional_function_catalog.md'), + ('computabilityTheoryDecomposeDecider', 'Computability Theory', '(value)', 'Decompose a decider into simpler or canonical components.', 'professional_function_catalog.md'), + ('computabilityTheoryDecomposeEnumerator', 'Computability Theory', '(value)', 'Decompose a enumerator into simpler or canonical components.', 'professional_function_catalog.md'), + ('computabilityTheoryDecomposeLanguage', 'Computability Theory', '(value)', 'Decompose a language into simpler or canonical components.', 'professional_function_catalog.md'), + ('computabilityTheoryDecomposeMachine', 'Computability Theory', '(value)', 'Decompose a machine into simpler or canonical components.', 'professional_function_catalog.md'), + ('computabilityTheoryDecomposePartialFunction', 'Computability Theory', '(value)', 'Decompose a partial function into simpler or canonical components.', 'professional_function_catalog.md'), + ('computabilityTheoryDocumentDecider', 'Computability Theory', '(value)', 'Return a structured explanation of a decider and related assumptions.', 'professional_function_catalog.md'), + ('computabilityTheoryDocumentEnumerator', 'Computability Theory', '(value)', 'Return a structured explanation of a enumerator and related assumptions.', 'professional_function_catalog.md'), + ('computabilityTheoryDocumentLanguage', 'Computability Theory', '(value)', 'Return a structured explanation of a language and related assumptions.', 'professional_function_catalog.md'), + ('computabilityTheoryDocumentMachine', 'Computability Theory', '(value)', 'Return a structured explanation of a machine and related assumptions.', 'professional_function_catalog.md'), + ('computabilityTheoryDocumentPartialFunction', 'Computability Theory', '(value)', 'Return a structured explanation of a partial function and related assumptions.', 'professional_function_catalog.md'), + ('computabilityTheoryEnumerateDecider', 'Computability Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a decider.', 'professional_function_catalog.md'), + ('computabilityTheoryEnumerateEnumerator', 'Computability Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a enumerator.', 'professional_function_catalog.md'), + ('computabilityTheoryEnumerateLanguage', 'Computability Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a language.', 'professional_function_catalog.md'), + ('computabilityTheoryEnumerateMachine', 'Computability Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a machine.', 'professional_function_catalog.md'), + ('computabilityTheoryEnumeratePartialFunction', 'Computability Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a partial function.', 'professional_function_catalog.md'), + ('computabilityTheoryEstimateDecider', 'Computability Theory', '(value, samples=None)', 'Estimate a decider property from finite samples or approximations.', 'professional_function_catalog.md'), + ('computabilityTheoryEstimateEnumerator', 'Computability Theory', '(value, samples=None)', 'Estimate a enumerator property from finite samples or approximations.', 'professional_function_catalog.md'), + ('computabilityTheoryEstimateLanguage', 'Computability Theory', '(value, samples=None)', 'Estimate a language property from finite samples or approximations.', 'professional_function_catalog.md'), + ('computabilityTheoryEstimateMachine', 'Computability Theory', '(value, samples=None)', 'Estimate a machine property from finite samples or approximations.', 'professional_function_catalog.md'), + ('computabilityTheoryEstimatePartialFunction', 'Computability Theory', '(value, samples=None)', 'Estimate a partial function property from finite samples or approximations.', 'professional_function_catalog.md'), + ('computabilityTheoryEvaluateDecider', 'Computability Theory', '(value, point=None)', 'Evaluate a decider at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('computabilityTheoryEvaluateEnumerator', 'Computability Theory', '(value, point=None)', 'Evaluate a enumerator at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('computabilityTheoryEvaluateLanguage', 'Computability Theory', '(value, point=None)', 'Evaluate a language at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('computabilityTheoryEvaluateMachine', 'Computability Theory', '(value, point=None)', 'Evaluate a machine at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('computabilityTheoryEvaluatePartialFunction', 'Computability Theory', '(value, point=None)', 'Evaluate a partial function at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('computabilityTheoryFormatDecider', 'Computability Theory', '(value)', 'Format a decider for deterministic user-facing output.', 'professional_function_catalog.md'), + ('computabilityTheoryFormatEnumerator', 'Computability Theory', '(value)', 'Format a enumerator for deterministic user-facing output.', 'professional_function_catalog.md'), + ('computabilityTheoryFormatLanguage', 'Computability Theory', '(value)', 'Format a language for deterministic user-facing output.', 'professional_function_catalog.md'), + ('computabilityTheoryFormatMachine', 'Computability Theory', '(value)', 'Format a machine for deterministic user-facing output.', 'professional_function_catalog.md'), + ('computabilityTheoryFormatPartialFunction', 'Computability Theory', '(value)', 'Format a partial function for deterministic user-facing output.', 'professional_function_catalog.md'), + ('computabilityTheoryGenerateExampleDecider', 'Computability Theory', '(size=3)', 'Generate a small documented example of a decider.', 'professional_function_catalog.md'), + ('computabilityTheoryGenerateExampleEnumerator', 'Computability Theory', '(size=3)', 'Generate a small documented example of a enumerator.', 'professional_function_catalog.md'), + ('computabilityTheoryGenerateExampleLanguage', 'Computability Theory', '(size=3)', 'Generate a small documented example of a language.', 'professional_function_catalog.md'), + ('computabilityTheoryGenerateExampleMachine', 'Computability Theory', '(size=3)', 'Generate a small documented example of a machine.', 'professional_function_catalog.md'), + ('computabilityTheoryGenerateExamplePartialFunction', 'Computability Theory', '(size=3)', 'Generate a small documented example of a partial function.', 'professional_function_catalog.md'), + ('computabilityTheoryNormalizeDecider', 'Computability Theory', '(value)', 'Normalize a decider into the standard Computability Theory representation.', 'professional_function_catalog.md'), + ('computabilityTheoryNormalizeEnumerator', 'Computability Theory', '(value)', 'Normalize a enumerator into the standard Computability Theory representation.', 'professional_function_catalog.md'), + ('computabilityTheoryNormalizeLanguage', 'Computability Theory', '(value)', 'Normalize a language into the standard Computability Theory representation.', 'professional_function_catalog.md'), + ('computabilityTheoryNormalizeMachine', 'Computability Theory', '(value)', 'Normalize a machine into the standard Computability Theory representation.', 'professional_function_catalog.md'), + ('computabilityTheoryNormalizePartialFunction', 'Computability Theory', '(value)', 'Normalize a partial function into the standard Computability Theory representation.', 'professional_function_catalog.md'), + ('computabilityTheoryParseDecider', 'Computability Theory', '(text)', 'Parse a text or structured value into a decider.', 'professional_function_catalog.md'), + ('computabilityTheoryParseEnumerator', 'Computability Theory', '(text)', 'Parse a text or structured value into a enumerator.', 'professional_function_catalog.md'), + ('computabilityTheoryParseLanguage', 'Computability Theory', '(text)', 'Parse a text or structured value into a language.', 'professional_function_catalog.md'), + ('computabilityTheoryParseMachine', 'Computability Theory', '(text)', 'Parse a text or structured value into a machine.', 'professional_function_catalog.md'), + ('computabilityTheoryParsePartialFunction', 'Computability Theory', '(text)', 'Parse a text or structured value into a partial function.', 'professional_function_catalog.md'), + ('computabilityTheorySimplifyDecider', 'Computability Theory', '(value)', 'Simplify a decider without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('computabilityTheorySimplifyEnumerator', 'Computability Theory', '(value)', 'Simplify a enumerator without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('computabilityTheorySimplifyLanguage', 'Computability Theory', '(value)', 'Simplify a language without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('computabilityTheorySimplifyMachine', 'Computability Theory', '(value)', 'Simplify a machine without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('computabilityTheorySimplifyPartialFunction', 'Computability Theory', '(value)', 'Simplify a partial function without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('computabilityTheoryTestEquivalenceDecider', 'Computability Theory', '(left, right)', 'Test whether two decider values are equivalent in Computability Theory.', 'professional_function_catalog.md'), + ('computabilityTheoryTestEquivalenceEnumerator', 'Computability Theory', '(left, right)', 'Test whether two enumerator values are equivalent in Computability Theory.', 'professional_function_catalog.md'), + ('computabilityTheoryTestEquivalenceLanguage', 'Computability Theory', '(left, right)', 'Test whether two language values are equivalent in Computability Theory.', 'professional_function_catalog.md'), + ('computabilityTheoryTestEquivalenceMachine', 'Computability Theory', '(left, right)', 'Test whether two machine values are equivalent in Computability Theory.', 'professional_function_catalog.md'), + ('computabilityTheoryTestEquivalencePartialFunction', 'Computability Theory', '(left, right)', 'Test whether two partial function values are equivalent in Computability Theory.', 'professional_function_catalog.md'), + ('computabilityTheoryTransformDecider', 'Computability Theory', '(value, mapping)', 'Transform a decider through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('computabilityTheoryTransformEnumerator', 'Computability Theory', '(value, mapping)', 'Transform a enumerator through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('computabilityTheoryTransformLanguage', 'Computability Theory', '(value, mapping)', 'Transform a language through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('computabilityTheoryTransformMachine', 'Computability Theory', '(value, mapping)', 'Transform a machine through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('computabilityTheoryTransformPartialFunction', 'Computability Theory', '(value, mapping)', 'Transform a partial function through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('computabilityTheoryValidateDecider', 'Computability Theory', '(value)', 'Validate the decider representation and domain rules for Computability Theory.', 'professional_function_catalog.md'), + ('computabilityTheoryValidateEnumerator', 'Computability Theory', '(value)', 'Validate the enumerator representation and domain rules for Computability Theory.', 'professional_function_catalog.md'), + ('computabilityTheoryValidateLanguage', 'Computability Theory', '(value)', 'Validate the language representation and domain rules for Computability Theory.', 'professional_function_catalog.md'), + ('computabilityTheoryValidateMachine', 'Computability Theory', '(value)', 'Validate the machine representation and domain rules for Computability Theory.', 'professional_function_catalog.md'), + ('computabilityTheoryValidatePartialFunction', 'Computability Theory', '(value)', 'Validate the partial function representation and domain rules for Computability Theory.', 'professional_function_catalog.md'), + ('enumerateLanguage', 'Computability Theory', '(generator, steps)', 'Planned roadmap function for Computability Theory from upcoming.md.', 'upcoming.md'), + ('haltsWithin', 'Computability Theory', '(machine, tape, maxSteps)', 'Planned roadmap function for Computability Theory from upcoming.md.', 'upcoming.md'), + ('isTotalOnSamples', 'Computability Theory', '(function, samples)', 'Planned roadmap function for Computability Theory from upcoming.md.', 'upcoming.md'), + ('primitiveRecursiveAdd', 'Computability Theory', '(a, b)', 'Planned roadmap function for Computability Theory from upcoming.md.', 'upcoming.md'), + ('simulateDFA', 'Computability Theory', '(automaton, inputString)', 'Planned roadmap function for Computability Theory from upcoming.md.', 'upcoming.md'), + ('simulateTuringMachine', 'Computability Theory', '(machine, tape, maxSteps)', 'Planned roadmap function for Computability Theory from upcoming.md.', 'upcoming.md'), + ('boundingBox', 'Computational Geometry', '(points)', 'Planned roadmap function for Computational Geometry from upcoming.md.', 'upcoming.md'), + ('closestPair', 'Computational Geometry', '(points)', 'Planned roadmap function for Computational Geometry from upcoming.md.', 'upcoming.md'), + ('computationalGeometryApproximateConvexHull', 'Computational Geometry', '(value, tolerance=1e-9)', 'Approximate a convex hull with explicit tolerance controls.', 'professional_function_catalog.md'), + ('computationalGeometryApproximateLineSegment', 'Computational Geometry', '(value, tolerance=1e-9)', 'Approximate a line segment with explicit tolerance controls.', 'professional_function_catalog.md'), + ('computationalGeometryApproximatePointSet', 'Computational Geometry', '(value, tolerance=1e-9)', 'Approximate a point set with explicit tolerance controls.', 'professional_function_catalog.md'), + ('computationalGeometryApproximatePolygonMesh', 'Computational Geometry', '(value, tolerance=1e-9)', 'Approximate a polygon mesh with explicit tolerance controls.', 'professional_function_catalog.md'), + ('computationalGeometryApproximateSpatialQuery', 'Computational Geometry', '(value, tolerance=1e-9)', 'Approximate a spatial query with explicit tolerance controls.', 'professional_function_catalog.md'), + ('computationalGeometryCanonicalizeConvexHull', 'Computational Geometry', '(value)', 'Canonicalize a convex hull so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('computationalGeometryCanonicalizeLineSegment', 'Computational Geometry', '(value)', 'Canonicalize a line segment so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('computationalGeometryCanonicalizePointSet', 'Computational Geometry', '(value)', 'Canonicalize a point set so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('computationalGeometryCanonicalizePolygonMesh', 'Computational Geometry', '(value)', 'Canonicalize a polygon mesh so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('computationalGeometryCanonicalizeSpatialQuery', 'Computational Geometry', '(value)', 'Canonicalize a spatial query so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('computationalGeometryClassifyConvexHull', 'Computational Geometry', '(value)', 'Classify a convex hull by its standard Computational Geometry invariants.', 'professional_function_catalog.md'), + ('computationalGeometryClassifyLineSegment', 'Computational Geometry', '(value)', 'Classify a line segment by its standard Computational Geometry invariants.', 'professional_function_catalog.md'), + ('computationalGeometryClassifyPointSet', 'Computational Geometry', '(value)', 'Classify a point set by its standard Computational Geometry invariants.', 'professional_function_catalog.md'), + ('computationalGeometryClassifyPolygonMesh', 'Computational Geometry', '(value)', 'Classify a polygon mesh by its standard Computational Geometry invariants.', 'professional_function_catalog.md'), + ('computationalGeometryClassifySpatialQuery', 'Computational Geometry', '(value)', 'Classify a spatial query by its standard Computational Geometry invariants.', 'professional_function_catalog.md'), + ('computationalGeometryCombineConvexHull', 'Computational Geometry', '(left, right)', 'Combine two convex hull values with the natural operation for Computational Geometry.', 'professional_function_catalog.md'), + ('computationalGeometryCombineLineSegment', 'Computational Geometry', '(left, right)', 'Combine two line segment values with the natural operation for Computational Geometry.', 'professional_function_catalog.md'), + ('computationalGeometryCombinePointSet', 'Computational Geometry', '(left, right)', 'Combine two point set values with the natural operation for Computational Geometry.', 'professional_function_catalog.md'), + ('computationalGeometryCombinePolygonMesh', 'Computational Geometry', '(left, right)', 'Combine two polygon mesh values with the natural operation for Computational Geometry.', 'professional_function_catalog.md'), + ('computationalGeometryCombineSpatialQuery', 'Computational Geometry', '(left, right)', 'Combine two spatial query values with the natural operation for Computational Geometry.', 'professional_function_catalog.md'), + ('computationalGeometryCompareConvexHull', 'Computational Geometry', '(left, right)', 'Compare two convex hull values under the conventions of Computational Geometry.', 'professional_function_catalog.md'), + ('computationalGeometryCompareLineSegment', 'Computational Geometry', '(left, right)', 'Compare two line segment values under the conventions of Computational Geometry.', 'professional_function_catalog.md'), + ('computationalGeometryComparePointSet', 'Computational Geometry', '(left, right)', 'Compare two point set values under the conventions of Computational Geometry.', 'professional_function_catalog.md'), + ('computationalGeometryComparePolygonMesh', 'Computational Geometry', '(left, right)', 'Compare two polygon mesh values under the conventions of Computational Geometry.', 'professional_function_catalog.md'), + ('computationalGeometryCompareSpatialQuery', 'Computational Geometry', '(left, right)', 'Compare two spatial query values under the conventions of Computational Geometry.', 'professional_function_catalog.md'), + ('computationalGeometryComputeConvexHull', 'Computational Geometry', '(value)', 'Compute the central numerical or symbolic data of a convex hull.', 'professional_function_catalog.md'), + ('computationalGeometryComputeLineSegment', 'Computational Geometry', '(value)', 'Compute the central numerical or symbolic data of a line segment.', 'professional_function_catalog.md'), + ('computationalGeometryComputePointSet', 'Computational Geometry', '(value)', 'Compute the central numerical or symbolic data of a point set.', 'professional_function_catalog.md'), + ('computationalGeometryComputePolygonMesh', 'Computational Geometry', '(value)', 'Compute the central numerical or symbolic data of a polygon mesh.', 'professional_function_catalog.md'), + ('computationalGeometryComputeSpatialQuery', 'Computational Geometry', '(value)', 'Compute the central numerical or symbolic data of a spatial query.', 'professional_function_catalog.md'), + ('computationalGeometryConstructConvexHull', 'Computational Geometry', '(*args)', 'Construct a convex hull from explicit inputs for Computational Geometry.', 'professional_function_catalog.md'), + ('computationalGeometryConstructLineSegment', 'Computational Geometry', '(*args)', 'Construct a line segment from explicit inputs for Computational Geometry.', 'professional_function_catalog.md'), + ('computationalGeometryConstructPointSet', 'Computational Geometry', '(*args)', 'Construct a point set from explicit inputs for Computational Geometry.', 'professional_function_catalog.md'), + ('computationalGeometryConstructPolygonMesh', 'Computational Geometry', '(*args)', 'Construct a polygon mesh from explicit inputs for Computational Geometry.', 'professional_function_catalog.md'), + ('computationalGeometryConstructSpatialQuery', 'Computational Geometry', '(*args)', 'Construct a spatial query from explicit inputs for Computational Geometry.', 'professional_function_catalog.md'), + ('computationalGeometryDecomposeConvexHull', 'Computational Geometry', '(value)', 'Decompose a convex hull into simpler or canonical components.', 'professional_function_catalog.md'), + ('computationalGeometryDecomposeLineSegment', 'Computational Geometry', '(value)', 'Decompose a line segment into simpler or canonical components.', 'professional_function_catalog.md'), + ('computationalGeometryDecomposePointSet', 'Computational Geometry', '(value)', 'Decompose a point set into simpler or canonical components.', 'professional_function_catalog.md'), + ('computationalGeometryDecomposePolygonMesh', 'Computational Geometry', '(value)', 'Decompose a polygon mesh into simpler or canonical components.', 'professional_function_catalog.md'), + ('computationalGeometryDecomposeSpatialQuery', 'Computational Geometry', '(value)', 'Decompose a spatial query into simpler or canonical components.', 'professional_function_catalog.md'), + ('computationalGeometryDocumentConvexHull', 'Computational Geometry', '(value)', 'Return a structured explanation of a convex hull and related assumptions.', 'professional_function_catalog.md'), + ('computationalGeometryDocumentLineSegment', 'Computational Geometry', '(value)', 'Return a structured explanation of a line segment and related assumptions.', 'professional_function_catalog.md'), + ('computationalGeometryDocumentPointSet', 'Computational Geometry', '(value)', 'Return a structured explanation of a point set and related assumptions.', 'professional_function_catalog.md'), + ('computationalGeometryDocumentPolygonMesh', 'Computational Geometry', '(value)', 'Return a structured explanation of a polygon mesh and related assumptions.', 'professional_function_catalog.md'), + ('computationalGeometryDocumentSpatialQuery', 'Computational Geometry', '(value)', 'Return a structured explanation of a spatial query and related assumptions.', 'professional_function_catalog.md'), + ('computationalGeometryEnumerateConvexHull', 'Computational Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a convex hull.', 'professional_function_catalog.md'), + ('computationalGeometryEnumerateLineSegment', 'Computational Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a line segment.', 'professional_function_catalog.md'), + ('computationalGeometryEnumeratePointSet', 'Computational Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a point set.', 'professional_function_catalog.md'), + ('computationalGeometryEnumeratePolygonMesh', 'Computational Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a polygon mesh.', 'professional_function_catalog.md'), + ('computationalGeometryEnumerateSpatialQuery', 'Computational Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a spatial query.', 'professional_function_catalog.md'), + ('computationalGeometryEstimateConvexHull', 'Computational Geometry', '(value, samples=None)', 'Estimate a convex hull property from finite samples or approximations.', 'professional_function_catalog.md'), + ('computationalGeometryEstimateLineSegment', 'Computational Geometry', '(value, samples=None)', 'Estimate a line segment property from finite samples or approximations.', 'professional_function_catalog.md'), + ('computationalGeometryEstimatePointSet', 'Computational Geometry', '(value, samples=None)', 'Estimate a point set property from finite samples or approximations.', 'professional_function_catalog.md'), + ('computationalGeometryEstimatePolygonMesh', 'Computational Geometry', '(value, samples=None)', 'Estimate a polygon mesh property from finite samples or approximations.', 'professional_function_catalog.md'), + ('computationalGeometryEstimateSpatialQuery', 'Computational Geometry', '(value, samples=None)', 'Estimate a spatial query property from finite samples or approximations.', 'professional_function_catalog.md'), + ('computationalGeometryEvaluateConvexHull', 'Computational Geometry', '(value, point=None)', 'Evaluate a convex hull at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('computationalGeometryEvaluateLineSegment', 'Computational Geometry', '(value, point=None)', 'Evaluate a line segment at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('computationalGeometryEvaluatePointSet', 'Computational Geometry', '(value, point=None)', 'Evaluate a point set at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('computationalGeometryEvaluatePolygonMesh', 'Computational Geometry', '(value, point=None)', 'Evaluate a polygon mesh at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('computationalGeometryEvaluateSpatialQuery', 'Computational Geometry', '(value, point=None)', 'Evaluate a spatial query at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('computationalGeometryFormatConvexHull', 'Computational Geometry', '(value)', 'Format a convex hull for deterministic user-facing output.', 'professional_function_catalog.md'), + ('computationalGeometryFormatLineSegment', 'Computational Geometry', '(value)', 'Format a line segment for deterministic user-facing output.', 'professional_function_catalog.md'), + ('computationalGeometryFormatPointSet', 'Computational Geometry', '(value)', 'Format a point set for deterministic user-facing output.', 'professional_function_catalog.md'), + ('computationalGeometryFormatPolygonMesh', 'Computational Geometry', '(value)', 'Format a polygon mesh for deterministic user-facing output.', 'professional_function_catalog.md'), + ('computationalGeometryFormatSpatialQuery', 'Computational Geometry', '(value)', 'Format a spatial query for deterministic user-facing output.', 'professional_function_catalog.md'), + ('computationalGeometryGenerateExampleConvexHull', 'Computational Geometry', '(size=3)', 'Generate a small documented example of a convex hull.', 'professional_function_catalog.md'), + ('computationalGeometryGenerateExampleLineSegment', 'Computational Geometry', '(size=3)', 'Generate a small documented example of a line segment.', 'professional_function_catalog.md'), + ('computationalGeometryGenerateExamplePointSet', 'Computational Geometry', '(size=3)', 'Generate a small documented example of a point set.', 'professional_function_catalog.md'), + ('computationalGeometryGenerateExamplePolygonMesh', 'Computational Geometry', '(size=3)', 'Generate a small documented example of a polygon mesh.', 'professional_function_catalog.md'), + ('computationalGeometryGenerateExampleSpatialQuery', 'Computational Geometry', '(size=3)', 'Generate a small documented example of a spatial query.', 'professional_function_catalog.md'), + ('computationalGeometryNormalizeConvexHull', 'Computational Geometry', '(value)', 'Normalize a convex hull into the standard Computational Geometry representation.', 'professional_function_catalog.md'), + ('computationalGeometryNormalizeLineSegment', 'Computational Geometry', '(value)', 'Normalize a line segment into the standard Computational Geometry representation.', 'professional_function_catalog.md'), + ('computationalGeometryNormalizePointSet', 'Computational Geometry', '(value)', 'Normalize a point set into the standard Computational Geometry representation.', 'professional_function_catalog.md'), + ('computationalGeometryNormalizePolygonMesh', 'Computational Geometry', '(value)', 'Normalize a polygon mesh into the standard Computational Geometry representation.', 'professional_function_catalog.md'), + ('computationalGeometryNormalizeSpatialQuery', 'Computational Geometry', '(value)', 'Normalize a spatial query into the standard Computational Geometry representation.', 'professional_function_catalog.md'), + ('computationalGeometryParseConvexHull', 'Computational Geometry', '(text)', 'Parse a text or structured value into a convex hull.', 'professional_function_catalog.md'), + ('computationalGeometryParseLineSegment', 'Computational Geometry', '(text)', 'Parse a text or structured value into a line segment.', 'professional_function_catalog.md'), + ('computationalGeometryParsePointSet', 'Computational Geometry', '(text)', 'Parse a text or structured value into a point set.', 'professional_function_catalog.md'), + ('computationalGeometryParsePolygonMesh', 'Computational Geometry', '(text)', 'Parse a text or structured value into a polygon mesh.', 'professional_function_catalog.md'), + ('computationalGeometryParseSpatialQuery', 'Computational Geometry', '(text)', 'Parse a text or structured value into a spatial query.', 'professional_function_catalog.md'), + ('computationalGeometrySimplifyConvexHull', 'Computational Geometry', '(value)', 'Simplify a convex hull without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('computationalGeometrySimplifyLineSegment', 'Computational Geometry', '(value)', 'Simplify a line segment without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('computationalGeometrySimplifyPointSet', 'Computational Geometry', '(value)', 'Simplify a point set without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('computationalGeometrySimplifyPolygonMesh', 'Computational Geometry', '(value)', 'Simplify a polygon mesh without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('computationalGeometrySimplifySpatialQuery', 'Computational Geometry', '(value)', 'Simplify a spatial query without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('computationalGeometryTestEquivalenceConvexHull', 'Computational Geometry', '(left, right)', 'Test whether two convex hull values are equivalent in Computational Geometry.', 'professional_function_catalog.md'), + ('computationalGeometryTestEquivalenceLineSegment', 'Computational Geometry', '(left, right)', 'Test whether two line segment values are equivalent in Computational Geometry.', 'professional_function_catalog.md'), + ('computationalGeometryTestEquivalencePointSet', 'Computational Geometry', '(left, right)', 'Test whether two point set values are equivalent in Computational Geometry.', 'professional_function_catalog.md'), + ('computationalGeometryTestEquivalencePolygonMesh', 'Computational Geometry', '(left, right)', 'Test whether two polygon mesh values are equivalent in Computational Geometry.', 'professional_function_catalog.md'), + ('computationalGeometryTestEquivalenceSpatialQuery', 'Computational Geometry', '(left, right)', 'Test whether two spatial query values are equivalent in Computational Geometry.', 'professional_function_catalog.md'), + ('computationalGeometryTransformConvexHull', 'Computational Geometry', '(value, mapping)', 'Transform a convex hull through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('computationalGeometryTransformLineSegment', 'Computational Geometry', '(value, mapping)', 'Transform a line segment through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('computationalGeometryTransformPointSet', 'Computational Geometry', '(value, mapping)', 'Transform a point set through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('computationalGeometryTransformPolygonMesh', 'Computational Geometry', '(value, mapping)', 'Transform a polygon mesh through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('computationalGeometryTransformSpatialQuery', 'Computational Geometry', '(value, mapping)', 'Transform a spatial query through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('computationalGeometryValidateConvexHull', 'Computational Geometry', '(value)', 'Validate the convex hull representation and domain rules for Computational Geometry.', 'professional_function_catalog.md'), + ('computationalGeometryValidateLineSegment', 'Computational Geometry', '(value)', 'Validate the line segment representation and domain rules for Computational Geometry.', 'professional_function_catalog.md'), + ('computationalGeometryValidatePointSet', 'Computational Geometry', '(value)', 'Validate the point set representation and domain rules for Computational Geometry.', 'professional_function_catalog.md'), + ('computationalGeometryValidatePolygonMesh', 'Computational Geometry', '(value)', 'Validate the polygon mesh representation and domain rules for Computational Geometry.', 'professional_function_catalog.md'), + ('computationalGeometryValidateSpatialQuery', 'Computational Geometry', '(value)', 'Validate the spatial query representation and domain rules for Computational Geometry.', 'professional_function_catalog.md'), + ('convexHull', 'Computational Geometry', '(points)', 'Planned roadmap function for Computational Geometry from upcoming.md.', 'upcoming.md'), + ('orientation', 'Computational Geometry', '(p, q, r)', 'Planned roadmap function for Computational Geometry from upcoming.md.', 'upcoming.md'), + ('pointInPolygon', 'Computational Geometry', '(point, polygon)', 'Planned roadmap function for Computational Geometry from upcoming.md.', 'upcoming.md'), + ('polygonCentroid', 'Computational Geometry', '(points)', 'Planned roadmap function for Computational Geometry from upcoming.md.', 'upcoming.md'), + ('segmentsIntersect', 'Computational Geometry', '(a, b, c, d)', 'Planned roadmap function for Computational Geometry from upcoming.md.', 'upcoming.md'), + ('triangulateConvexPolygon', 'Computational Geometry', '(points)', 'Planned roadmap function for Computational Geometry from upcoming.md.', 'upcoming.md'), + ('approxEqual', 'Constants', '(a, b, tolerance=1e-9)', 'Planned roadmap function for Constants from upcoming.md.', 'upcoming.md'), + ('constantsApproximateConstantIdentity', 'Constants', '(value, tolerance=1e-9)', 'Approximate a constant identity with explicit tolerance controls.', 'professional_function_catalog.md'), + ('constantsApproximateConstantRegistry', 'Constants', '(value, tolerance=1e-9)', 'Approximate a constant registry with explicit tolerance controls.', 'professional_function_catalog.md'), + ('constantsApproximateNamedConstant', 'Constants', '(value, tolerance=1e-9)', 'Approximate a named constant with explicit tolerance controls.', 'professional_function_catalog.md'), + ('constantsApproximateNumericApproximation', 'Constants', '(value, tolerance=1e-9)', 'Approximate a numeric approximation with explicit tolerance controls.', 'professional_function_catalog.md'), + ('constantsApproximatePrecisionProfile', 'Constants', '(value, tolerance=1e-9)', 'Approximate a precision profile with explicit tolerance controls.', 'professional_function_catalog.md'), + ('constantsCanonicalizeConstantIdentity', 'Constants', '(value)', 'Canonicalize a constant identity so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('constantsCanonicalizeConstantRegistry', 'Constants', '(value)', 'Canonicalize a constant registry so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('constantsCanonicalizeNamedConstant', 'Constants', '(value)', 'Canonicalize a named constant so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('constantsCanonicalizeNumericApproximation', 'Constants', '(value)', 'Canonicalize a numeric approximation so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('constantsCanonicalizePrecisionProfile', 'Constants', '(value)', 'Canonicalize a precision profile so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('constantsClassifyConstantIdentity', 'Constants', '(value)', 'Classify a constant identity by its standard Constants invariants.', 'professional_function_catalog.md'), + ('constantsClassifyConstantRegistry', 'Constants', '(value)', 'Classify a constant registry by its standard Constants invariants.', 'professional_function_catalog.md'), + ('constantsClassifyNamedConstant', 'Constants', '(value)', 'Classify a named constant by its standard Constants invariants.', 'professional_function_catalog.md'), + ('constantsClassifyNumericApproximation', 'Constants', '(value)', 'Classify a numeric approximation by its standard Constants invariants.', 'professional_function_catalog.md'), + ('constantsClassifyPrecisionProfile', 'Constants', '(value)', 'Classify a precision profile by its standard Constants invariants.', 'professional_function_catalog.md'), + ('constantsCombineConstantIdentity', 'Constants', '(left, right)', 'Combine two constant identity values with the natural operation for Constants.', 'professional_function_catalog.md'), + ('constantsCombineConstantRegistry', 'Constants', '(left, right)', 'Combine two constant registry values with the natural operation for Constants.', 'professional_function_catalog.md'), + ('constantsCombineNamedConstant', 'Constants', '(left, right)', 'Combine two named constant values with the natural operation for Constants.', 'professional_function_catalog.md'), + ('constantsCombineNumericApproximation', 'Constants', '(left, right)', 'Combine two numeric approximation values with the natural operation for Constants.', 'professional_function_catalog.md'), + ('constantsCombinePrecisionProfile', 'Constants', '(left, right)', 'Combine two precision profile values with the natural operation for Constants.', 'professional_function_catalog.md'), + ('constantsCompareConstantIdentity', 'Constants', '(left, right)', 'Compare two constant identity values under the conventions of Constants.', 'professional_function_catalog.md'), + ('constantsCompareConstantRegistry', 'Constants', '(left, right)', 'Compare two constant registry values under the conventions of Constants.', 'professional_function_catalog.md'), + ('constantsCompareNamedConstant', 'Constants', '(left, right)', 'Compare two named constant values under the conventions of Constants.', 'professional_function_catalog.md'), + ('constantsCompareNumericApproximation', 'Constants', '(left, right)', 'Compare two numeric approximation values under the conventions of Constants.', 'professional_function_catalog.md'), + ('constantsComparePrecisionProfile', 'Constants', '(left, right)', 'Compare two precision profile values under the conventions of Constants.', 'professional_function_catalog.md'), + ('constantsComputeConstantIdentity', 'Constants', '(value)', 'Compute the central numerical or symbolic data of a constant identity.', 'professional_function_catalog.md'), + ('constantsComputeConstantRegistry', 'Constants', '(value)', 'Compute the central numerical or symbolic data of a constant registry.', 'professional_function_catalog.md'), + ('constantsComputeNamedConstant', 'Constants', '(value)', 'Compute the central numerical or symbolic data of a named constant.', 'professional_function_catalog.md'), + ('constantsComputeNumericApproximation', 'Constants', '(value)', 'Compute the central numerical or symbolic data of a numeric approximation.', 'professional_function_catalog.md'), + ('constantsComputePrecisionProfile', 'Constants', '(value)', 'Compute the central numerical or symbolic data of a precision profile.', 'professional_function_catalog.md'), + ('constantsConstructConstantIdentity', 'Constants', '(*args)', 'Construct a constant identity from explicit inputs for Constants.', 'professional_function_catalog.md'), + ('constantsConstructConstantRegistry', 'Constants', '(*args)', 'Construct a constant registry from explicit inputs for Constants.', 'professional_function_catalog.md'), + ('constantsConstructNamedConstant', 'Constants', '(*args)', 'Construct a named constant from explicit inputs for Constants.', 'professional_function_catalog.md'), + ('constantsConstructNumericApproximation', 'Constants', '(*args)', 'Construct a numeric approximation from explicit inputs for Constants.', 'professional_function_catalog.md'), + ('constantsConstructPrecisionProfile', 'Constants', '(*args)', 'Construct a precision profile from explicit inputs for Constants.', 'professional_function_catalog.md'), + ('constantsDecomposeConstantIdentity', 'Constants', '(value)', 'Decompose a constant identity into simpler or canonical components.', 'professional_function_catalog.md'), + ('constantsDecomposeConstantRegistry', 'Constants', '(value)', 'Decompose a constant registry into simpler or canonical components.', 'professional_function_catalog.md'), + ('constantsDecomposeNamedConstant', 'Constants', '(value)', 'Decompose a named constant into simpler or canonical components.', 'professional_function_catalog.md'), + ('constantsDecomposeNumericApproximation', 'Constants', '(value)', 'Decompose a numeric approximation into simpler or canonical components.', 'professional_function_catalog.md'), + ('constantsDecomposePrecisionProfile', 'Constants', '(value)', 'Decompose a precision profile into simpler or canonical components.', 'professional_function_catalog.md'), + ('constantsDocumentConstantIdentity', 'Constants', '(value)', 'Return a structured explanation of a constant identity and related assumptions.', 'professional_function_catalog.md'), + ('constantsDocumentConstantRegistry', 'Constants', '(value)', 'Return a structured explanation of a constant registry and related assumptions.', 'professional_function_catalog.md'), + ('constantsDocumentNamedConstant', 'Constants', '(value)', 'Return a structured explanation of a named constant and related assumptions.', 'professional_function_catalog.md'), + ('constantsDocumentNumericApproximation', 'Constants', '(value)', 'Return a structured explanation of a numeric approximation and related assumptions.', 'professional_function_catalog.md'), + ('constantsDocumentPrecisionProfile', 'Constants', '(value)', 'Return a structured explanation of a precision profile and related assumptions.', 'professional_function_catalog.md'), + ('constantsEnumerateConstantIdentity', 'Constants', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a constant identity.', 'professional_function_catalog.md'), + ('constantsEnumerateConstantRegistry', 'Constants', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a constant registry.', 'professional_function_catalog.md'), + ('constantsEnumerateNamedConstant', 'Constants', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a named constant.', 'professional_function_catalog.md'), + ('constantsEnumerateNumericApproximation', 'Constants', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a numeric approximation.', 'professional_function_catalog.md'), + ('constantsEnumeratePrecisionProfile', 'Constants', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a precision profile.', 'professional_function_catalog.md'), + ('constantsEstimateConstantIdentity', 'Constants', '(value, samples=None)', 'Estimate a constant identity property from finite samples or approximations.', 'professional_function_catalog.md'), + ('constantsEstimateConstantRegistry', 'Constants', '(value, samples=None)', 'Estimate a constant registry property from finite samples or approximations.', 'professional_function_catalog.md'), + ('constantsEstimateNamedConstant', 'Constants', '(value, samples=None)', 'Estimate a named constant property from finite samples or approximations.', 'professional_function_catalog.md'), + ('constantsEstimateNumericApproximation', 'Constants', '(value, samples=None)', 'Estimate a numeric approximation property from finite samples or approximations.', 'professional_function_catalog.md'), + ('constantsEstimatePrecisionProfile', 'Constants', '(value, samples=None)', 'Estimate a precision profile property from finite samples or approximations.', 'professional_function_catalog.md'), + ('constantsEvaluateConstantIdentity', 'Constants', '(value, point=None)', 'Evaluate a constant identity at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('constantsEvaluateConstantRegistry', 'Constants', '(value, point=None)', 'Evaluate a constant registry at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('constantsEvaluateNamedConstant', 'Constants', '(value, point=None)', 'Evaluate a named constant at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('constantsEvaluateNumericApproximation', 'Constants', '(value, point=None)', 'Evaluate a numeric approximation at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('constantsEvaluatePrecisionProfile', 'Constants', '(value, point=None)', 'Evaluate a precision profile at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('constantsFormatConstantIdentity', 'Constants', '(value)', 'Format a constant identity for deterministic user-facing output.', 'professional_function_catalog.md'), + ('constantsFormatConstantRegistry', 'Constants', '(value)', 'Format a constant registry for deterministic user-facing output.', 'professional_function_catalog.md'), + ('constantsFormatNamedConstant', 'Constants', '(value)', 'Format a named constant for deterministic user-facing output.', 'professional_function_catalog.md'), + ('constantsFormatNumericApproximation', 'Constants', '(value)', 'Format a numeric approximation for deterministic user-facing output.', 'professional_function_catalog.md'), + ('constantsFormatPrecisionProfile', 'Constants', '(value)', 'Format a precision profile for deterministic user-facing output.', 'professional_function_catalog.md'), + ('constantsGenerateExampleConstantIdentity', 'Constants', '(size=3)', 'Generate a small documented example of a constant identity.', 'professional_function_catalog.md'), + ('constantsGenerateExampleConstantRegistry', 'Constants', '(size=3)', 'Generate a small documented example of a constant registry.', 'professional_function_catalog.md'), + ('constantsGenerateExampleNamedConstant', 'Constants', '(size=3)', 'Generate a small documented example of a named constant.', 'professional_function_catalog.md'), + ('constantsGenerateExampleNumericApproximation', 'Constants', '(size=3)', 'Generate a small documented example of a numeric approximation.', 'professional_function_catalog.md'), + ('constantsGenerateExamplePrecisionProfile', 'Constants', '(size=3)', 'Generate a small documented example of a precision profile.', 'professional_function_catalog.md'), + ('constantsNormalizeConstantIdentity', 'Constants', '(value)', 'Normalize a constant identity into the standard Constants representation.', 'professional_function_catalog.md'), + ('constantsNormalizeConstantRegistry', 'Constants', '(value)', 'Normalize a constant registry into the standard Constants representation.', 'professional_function_catalog.md'), + ('constantsNormalizeNamedConstant', 'Constants', '(value)', 'Normalize a named constant into the standard Constants representation.', 'professional_function_catalog.md'), + ('constantsNormalizeNumericApproximation', 'Constants', '(value)', 'Normalize a numeric approximation into the standard Constants representation.', 'professional_function_catalog.md'), + ('constantsNormalizePrecisionProfile', 'Constants', '(value)', 'Normalize a precision profile into the standard Constants representation.', 'professional_function_catalog.md'), + ('constantsParseConstantIdentity', 'Constants', '(text)', 'Parse a text or structured value into a constant identity.', 'professional_function_catalog.md'), + ('constantsParseConstantRegistry', 'Constants', '(text)', 'Parse a text or structured value into a constant registry.', 'professional_function_catalog.md'), + ('constantsParseNamedConstant', 'Constants', '(text)', 'Parse a text or structured value into a named constant.', 'professional_function_catalog.md'), + ('constantsParseNumericApproximation', 'Constants', '(text)', 'Parse a text or structured value into a numeric approximation.', 'professional_function_catalog.md'), + ('constantsParsePrecisionProfile', 'Constants', '(text)', 'Parse a text or structured value into a precision profile.', 'professional_function_catalog.md'), + ('constantsSimplifyConstantIdentity', 'Constants', '(value)', 'Simplify a constant identity without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('constantsSimplifyConstantRegistry', 'Constants', '(value)', 'Simplify a constant registry without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('constantsSimplifyNamedConstant', 'Constants', '(value)', 'Simplify a named constant without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('constantsSimplifyNumericApproximation', 'Constants', '(value)', 'Simplify a numeric approximation without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('constantsSimplifyPrecisionProfile', 'Constants', '(value)', 'Simplify a precision profile without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('constantsTestEquivalenceConstantIdentity', 'Constants', '(left, right)', 'Test whether two constant identity values are equivalent in Constants.', 'professional_function_catalog.md'), + ('constantsTestEquivalenceConstantRegistry', 'Constants', '(left, right)', 'Test whether two constant registry values are equivalent in Constants.', 'professional_function_catalog.md'), + ('constantsTestEquivalenceNamedConstant', 'Constants', '(left, right)', 'Test whether two named constant values are equivalent in Constants.', 'professional_function_catalog.md'), + ('constantsTestEquivalenceNumericApproximation', 'Constants', '(left, right)', 'Test whether two numeric approximation values are equivalent in Constants.', 'professional_function_catalog.md'), + ('constantsTestEquivalencePrecisionProfile', 'Constants', '(left, right)', 'Test whether two precision profile values are equivalent in Constants.', 'professional_function_catalog.md'), + ('constantsTransformConstantIdentity', 'Constants', '(value, mapping)', 'Transform a constant identity through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('constantsTransformConstantRegistry', 'Constants', '(value, mapping)', 'Transform a constant registry through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('constantsTransformNamedConstant', 'Constants', '(value, mapping)', 'Transform a named constant through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('constantsTransformNumericApproximation', 'Constants', '(value, mapping)', 'Transform a numeric approximation through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('constantsTransformPrecisionProfile', 'Constants', '(value, mapping)', 'Transform a precision profile through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('constantsValidateConstantIdentity', 'Constants', '(value)', 'Validate the constant identity representation and domain rules for Constants.', 'professional_function_catalog.md'), + ('constantsValidateConstantRegistry', 'Constants', '(value)', 'Validate the constant registry representation and domain rules for Constants.', 'professional_function_catalog.md'), + ('constantsValidateNamedConstant', 'Constants', '(value)', 'Validate the named constant representation and domain rules for Constants.', 'professional_function_catalog.md'), + ('constantsValidateNumericApproximation', 'Constants', '(value)', 'Validate the numeric approximation representation and domain rules for Constants.', 'professional_function_catalog.md'), + ('constantsValidatePrecisionProfile', 'Constants', '(value)', 'Validate the precision profile representation and domain rules for Constants.', 'professional_function_catalog.md'), + ('controllabilityMatrix', 'Control Theory', '(A, B)', 'Planned roadmap function for Control Theory from upcoming.md.', 'upcoming.md'), + ('controlTheoryApproximateControlInput', 'Control Theory', '(value, tolerance=1e-9)', 'Approximate a control input with explicit tolerance controls.', 'professional_function_catalog.md'), + ('controlTheoryApproximateControllabilityMatrix', 'Control Theory', '(value, tolerance=1e-9)', 'Approximate a controllability matrix with explicit tolerance controls.', 'professional_function_catalog.md'), + ('controlTheoryApproximateFeedbackLaw', 'Control Theory', '(value, tolerance=1e-9)', 'Approximate a feedback law with explicit tolerance controls.', 'professional_function_catalog.md'), + ('controlTheoryApproximateObservabilityMatrix', 'Control Theory', '(value, tolerance=1e-9)', 'Approximate a observability matrix with explicit tolerance controls.', 'professional_function_catalog.md'), + ('controlTheoryApproximateStateSpaceModel', 'Control Theory', '(value, tolerance=1e-9)', 'Approximate a state space model with explicit tolerance controls.', 'professional_function_catalog.md'), + ('controlTheoryCanonicalizeControlInput', 'Control Theory', '(value)', 'Canonicalize a control input so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('controlTheoryCanonicalizeControllabilityMatrix', 'Control Theory', '(value)', 'Canonicalize a controllability matrix so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('controlTheoryCanonicalizeFeedbackLaw', 'Control Theory', '(value)', 'Canonicalize a feedback law so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('controlTheoryCanonicalizeObservabilityMatrix', 'Control Theory', '(value)', 'Canonicalize a observability matrix so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('controlTheoryCanonicalizeStateSpaceModel', 'Control Theory', '(value)', 'Canonicalize a state space model so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('controlTheoryClassifyControlInput', 'Control Theory', '(value)', 'Classify a control input by its standard Control Theory invariants.', 'professional_function_catalog.md'), + ('controlTheoryClassifyControllabilityMatrix', 'Control Theory', '(value)', 'Classify a controllability matrix by its standard Control Theory invariants.', 'professional_function_catalog.md'), + ('controlTheoryClassifyFeedbackLaw', 'Control Theory', '(value)', 'Classify a feedback law by its standard Control Theory invariants.', 'professional_function_catalog.md'), + ('controlTheoryClassifyObservabilityMatrix', 'Control Theory', '(value)', 'Classify a observability matrix by its standard Control Theory invariants.', 'professional_function_catalog.md'), + ('controlTheoryClassifyStateSpaceModel', 'Control Theory', '(value)', 'Classify a state space model by its standard Control Theory invariants.', 'professional_function_catalog.md'), + ('controlTheoryCombineControlInput', 'Control Theory', '(left, right)', 'Combine two control input values with the natural operation for Control Theory.', 'professional_function_catalog.md'), + ('controlTheoryCombineControllabilityMatrix', 'Control Theory', '(left, right)', 'Combine two controllability matrix values with the natural operation for Control Theory.', 'professional_function_catalog.md'), + ('controlTheoryCombineFeedbackLaw', 'Control Theory', '(left, right)', 'Combine two feedback law values with the natural operation for Control Theory.', 'professional_function_catalog.md'), + ('controlTheoryCombineObservabilityMatrix', 'Control Theory', '(left, right)', 'Combine two observability matrix values with the natural operation for Control Theory.', 'professional_function_catalog.md'), + ('controlTheoryCombineStateSpaceModel', 'Control Theory', '(left, right)', 'Combine two state space model values with the natural operation for Control Theory.', 'professional_function_catalog.md'), + ('controlTheoryCompareControlInput', 'Control Theory', '(left, right)', 'Compare two control input values under the conventions of Control Theory.', 'professional_function_catalog.md'), + ('controlTheoryCompareControllabilityMatrix', 'Control Theory', '(left, right)', 'Compare two controllability matrix values under the conventions of Control Theory.', 'professional_function_catalog.md'), + ('controlTheoryCompareFeedbackLaw', 'Control Theory', '(left, right)', 'Compare two feedback law values under the conventions of Control Theory.', 'professional_function_catalog.md'), + ('controlTheoryCompareObservabilityMatrix', 'Control Theory', '(left, right)', 'Compare two observability matrix values under the conventions of Control Theory.', 'professional_function_catalog.md'), + ('controlTheoryCompareStateSpaceModel', 'Control Theory', '(left, right)', 'Compare two state space model values under the conventions of Control Theory.', 'professional_function_catalog.md'), + ('controlTheoryComputeControlInput', 'Control Theory', '(value)', 'Compute the central numerical or symbolic data of a control input.', 'professional_function_catalog.md'), + ('controlTheoryComputeControllabilityMatrix', 'Control Theory', '(value)', 'Compute the central numerical or symbolic data of a controllability matrix.', 'professional_function_catalog.md'), + ('controlTheoryComputeFeedbackLaw', 'Control Theory', '(value)', 'Compute the central numerical or symbolic data of a feedback law.', 'professional_function_catalog.md'), + ('controlTheoryComputeObservabilityMatrix', 'Control Theory', '(value)', 'Compute the central numerical or symbolic data of a observability matrix.', 'professional_function_catalog.md'), + ('controlTheoryComputeStateSpaceModel', 'Control Theory', '(value)', 'Compute the central numerical or symbolic data of a state space model.', 'professional_function_catalog.md'), + ('controlTheoryConstructControlInput', 'Control Theory', '(*args)', 'Construct a control input from explicit inputs for Control Theory.', 'professional_function_catalog.md'), + ('controlTheoryConstructControllabilityMatrix', 'Control Theory', '(*args)', 'Construct a controllability matrix from explicit inputs for Control Theory.', 'professional_function_catalog.md'), + ('controlTheoryConstructFeedbackLaw', 'Control Theory', '(*args)', 'Construct a feedback law from explicit inputs for Control Theory.', 'professional_function_catalog.md'), + ('controlTheoryConstructObservabilityMatrix', 'Control Theory', '(*args)', 'Construct a observability matrix from explicit inputs for Control Theory.', 'professional_function_catalog.md'), + ('controlTheoryConstructStateSpaceModel', 'Control Theory', '(*args)', 'Construct a state space model from explicit inputs for Control Theory.', 'professional_function_catalog.md'), + ('controlTheoryDecomposeControlInput', 'Control Theory', '(value)', 'Decompose a control input into simpler or canonical components.', 'professional_function_catalog.md'), + ('controlTheoryDecomposeControllabilityMatrix', 'Control Theory', '(value)', 'Decompose a controllability matrix into simpler or canonical components.', 'professional_function_catalog.md'), + ('controlTheoryDecomposeFeedbackLaw', 'Control Theory', '(value)', 'Decompose a feedback law into simpler or canonical components.', 'professional_function_catalog.md'), + ('controlTheoryDecomposeObservabilityMatrix', 'Control Theory', '(value)', 'Decompose a observability matrix into simpler or canonical components.', 'professional_function_catalog.md'), + ('controlTheoryDecomposeStateSpaceModel', 'Control Theory', '(value)', 'Decompose a state space model into simpler or canonical components.', 'professional_function_catalog.md'), + ('controlTheoryDocumentControlInput', 'Control Theory', '(value)', 'Return a structured explanation of a control input and related assumptions.', 'professional_function_catalog.md'), + ('controlTheoryDocumentControllabilityMatrix', 'Control Theory', '(value)', 'Return a structured explanation of a controllability matrix and related assumptions.', 'professional_function_catalog.md'), + ('controlTheoryDocumentFeedbackLaw', 'Control Theory', '(value)', 'Return a structured explanation of a feedback law and related assumptions.', 'professional_function_catalog.md'), + ('controlTheoryDocumentObservabilityMatrix', 'Control Theory', '(value)', 'Return a structured explanation of a observability matrix and related assumptions.', 'professional_function_catalog.md'), + ('controlTheoryDocumentStateSpaceModel', 'Control Theory', '(value)', 'Return a structured explanation of a state space model and related assumptions.', 'professional_function_catalog.md'), + ('controlTheoryEnumerateControlInput', 'Control Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a control input.', 'professional_function_catalog.md'), + ('controlTheoryEnumerateControllabilityMatrix', 'Control Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a controllability matrix.', 'professional_function_catalog.md'), + ('controlTheoryEnumerateFeedbackLaw', 'Control Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a feedback law.', 'professional_function_catalog.md'), + ('controlTheoryEnumerateObservabilityMatrix', 'Control Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a observability matrix.', 'professional_function_catalog.md'), + ('controlTheoryEnumerateStateSpaceModel', 'Control Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a state space model.', 'professional_function_catalog.md'), + ('controlTheoryEstimateControlInput', 'Control Theory', '(value, samples=None)', 'Estimate a control input property from finite samples or approximations.', 'professional_function_catalog.md'), + ('controlTheoryEstimateControllabilityMatrix', 'Control Theory', '(value, samples=None)', 'Estimate a controllability matrix property from finite samples or approximations.', 'professional_function_catalog.md'), + ('controlTheoryEstimateFeedbackLaw', 'Control Theory', '(value, samples=None)', 'Estimate a feedback law property from finite samples or approximations.', 'professional_function_catalog.md'), + ('controlTheoryEstimateObservabilityMatrix', 'Control Theory', '(value, samples=None)', 'Estimate a observability matrix property from finite samples or approximations.', 'professional_function_catalog.md'), + ('controlTheoryEstimateStateSpaceModel', 'Control Theory', '(value, samples=None)', 'Estimate a state space model property from finite samples or approximations.', 'professional_function_catalog.md'), + ('controlTheoryEvaluateControlInput', 'Control Theory', '(value, point=None)', 'Evaluate a control input at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('controlTheoryEvaluateControllabilityMatrix', 'Control Theory', '(value, point=None)', 'Evaluate a controllability matrix at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('controlTheoryEvaluateFeedbackLaw', 'Control Theory', '(value, point=None)', 'Evaluate a feedback law at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('controlTheoryEvaluateObservabilityMatrix', 'Control Theory', '(value, point=None)', 'Evaluate a observability matrix at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('controlTheoryEvaluateStateSpaceModel', 'Control Theory', '(value, point=None)', 'Evaluate a state space model at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('controlTheoryFormatControlInput', 'Control Theory', '(value)', 'Format a control input for deterministic user-facing output.', 'professional_function_catalog.md'), + ('controlTheoryFormatControllabilityMatrix', 'Control Theory', '(value)', 'Format a controllability matrix for deterministic user-facing output.', 'professional_function_catalog.md'), + ('controlTheoryFormatFeedbackLaw', 'Control Theory', '(value)', 'Format a feedback law for deterministic user-facing output.', 'professional_function_catalog.md'), + ('controlTheoryFormatObservabilityMatrix', 'Control Theory', '(value)', 'Format a observability matrix for deterministic user-facing output.', 'professional_function_catalog.md'), + ('controlTheoryFormatStateSpaceModel', 'Control Theory', '(value)', 'Format a state space model for deterministic user-facing output.', 'professional_function_catalog.md'), + ('controlTheoryGenerateExampleControlInput', 'Control Theory', '(size=3)', 'Generate a small documented example of a control input.', 'professional_function_catalog.md'), + ('controlTheoryGenerateExampleControllabilityMatrix', 'Control Theory', '(size=3)', 'Generate a small documented example of a controllability matrix.', 'professional_function_catalog.md'), + ('controlTheoryGenerateExampleFeedbackLaw', 'Control Theory', '(size=3)', 'Generate a small documented example of a feedback law.', 'professional_function_catalog.md'), + ('controlTheoryGenerateExampleObservabilityMatrix', 'Control Theory', '(size=3)', 'Generate a small documented example of a observability matrix.', 'professional_function_catalog.md'), + ('controlTheoryGenerateExampleStateSpaceModel', 'Control Theory', '(size=3)', 'Generate a small documented example of a state space model.', 'professional_function_catalog.md'), + ('controlTheoryNormalizeControlInput', 'Control Theory', '(value)', 'Normalize a control input into the standard Control Theory representation.', 'professional_function_catalog.md'), + ('controlTheoryNormalizeControllabilityMatrix', 'Control Theory', '(value)', 'Normalize a controllability matrix into the standard Control Theory representation.', 'professional_function_catalog.md'), + ('controlTheoryNormalizeFeedbackLaw', 'Control Theory', '(value)', 'Normalize a feedback law into the standard Control Theory representation.', 'professional_function_catalog.md'), + ('controlTheoryNormalizeObservabilityMatrix', 'Control Theory', '(value)', 'Normalize a observability matrix into the standard Control Theory representation.', 'professional_function_catalog.md'), + ('controlTheoryNormalizeStateSpaceModel', 'Control Theory', '(value)', 'Normalize a state space model into the standard Control Theory representation.', 'professional_function_catalog.md'), + ('controlTheoryParseControlInput', 'Control Theory', '(text)', 'Parse a text or structured value into a control input.', 'professional_function_catalog.md'), + ('controlTheoryParseControllabilityMatrix', 'Control Theory', '(text)', 'Parse a text or structured value into a controllability matrix.', 'professional_function_catalog.md'), + ('controlTheoryParseFeedbackLaw', 'Control Theory', '(text)', 'Parse a text or structured value into a feedback law.', 'professional_function_catalog.md'), + ('controlTheoryParseObservabilityMatrix', 'Control Theory', '(text)', 'Parse a text or structured value into a observability matrix.', 'professional_function_catalog.md'), + ('controlTheoryParseStateSpaceModel', 'Control Theory', '(text)', 'Parse a text or structured value into a state space model.', 'professional_function_catalog.md'), + ('controlTheorySimplifyControlInput', 'Control Theory', '(value)', 'Simplify a control input without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('controlTheorySimplifyControllabilityMatrix', 'Control Theory', '(value)', 'Simplify a controllability matrix without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('controlTheorySimplifyFeedbackLaw', 'Control Theory', '(value)', 'Simplify a feedback law without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('controlTheorySimplifyObservabilityMatrix', 'Control Theory', '(value)', 'Simplify a observability matrix without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('controlTheorySimplifyStateSpaceModel', 'Control Theory', '(value)', 'Simplify a state space model without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('controlTheoryTestEquivalenceControlInput', 'Control Theory', '(left, right)', 'Test whether two control input values are equivalent in Control Theory.', 'professional_function_catalog.md'), + ('controlTheoryTestEquivalenceControllabilityMatrix', 'Control Theory', '(left, right)', 'Test whether two controllability matrix values are equivalent in Control Theory.', 'professional_function_catalog.md'), + ('controlTheoryTestEquivalenceFeedbackLaw', 'Control Theory', '(left, right)', 'Test whether two feedback law values are equivalent in Control Theory.', 'professional_function_catalog.md'), + ('controlTheoryTestEquivalenceObservabilityMatrix', 'Control Theory', '(left, right)', 'Test whether two observability matrix values are equivalent in Control Theory.', 'professional_function_catalog.md'), + ('controlTheoryTestEquivalenceStateSpaceModel', 'Control Theory', '(left, right)', 'Test whether two state space model values are equivalent in Control Theory.', 'professional_function_catalog.md'), + ('controlTheoryTransformControlInput', 'Control Theory', '(value, mapping)', 'Transform a control input through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('controlTheoryTransformControllabilityMatrix', 'Control Theory', '(value, mapping)', 'Transform a controllability matrix through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('controlTheoryTransformFeedbackLaw', 'Control Theory', '(value, mapping)', 'Transform a feedback law through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('controlTheoryTransformObservabilityMatrix', 'Control Theory', '(value, mapping)', 'Transform a observability matrix through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('controlTheoryTransformStateSpaceModel', 'Control Theory', '(value, mapping)', 'Transform a state space model through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('controlTheoryValidateControlInput', 'Control Theory', '(value)', 'Validate the control input representation and domain rules for Control Theory.', 'professional_function_catalog.md'), + ('controlTheoryValidateControllabilityMatrix', 'Control Theory', '(value)', 'Validate the controllability matrix representation and domain rules for Control Theory.', 'professional_function_catalog.md'), + ('controlTheoryValidateFeedbackLaw', 'Control Theory', '(value)', 'Validate the feedback law representation and domain rules for Control Theory.', 'professional_function_catalog.md'), + ('controlTheoryValidateObservabilityMatrix', 'Control Theory', '(value)', 'Validate the observability matrix representation and domain rules for Control Theory.', 'professional_function_catalog.md'), + ('controlTheoryValidateStateSpaceModel', 'Control Theory', '(value)', 'Validate the state space model representation and domain rules for Control Theory.', 'professional_function_catalog.md'), + ('feedbackGainStep', 'Control Theory', '(A, B, K)', 'Planned roadmap function for Control Theory from upcoming.md.', 'upcoming.md'), + ('isControllable', 'Control Theory', '(A, B)', 'Planned roadmap function for Control Theory from upcoming.md.', 'upcoming.md'), + ('isObservable', 'Control Theory', '(A, C)', 'Planned roadmap function for Control Theory from upcoming.md.', 'upcoming.md'), + ('observabilityMatrix', 'Control Theory', '(A, C)', 'Planned roadmap function for Control Theory from upcoming.md.', 'upcoming.md'), + ('pidStep', 'Control Theory', '(error, previousError, integral, kp, ki, kd, dt)', 'Planned roadmap function for Control Theory from upcoming.md.', 'upcoming.md'), + ('simulateLinearSystem', 'Control Theory', '(A, B, x0, inputs)', 'Planned roadmap function for Control Theory from upcoming.md.', 'upcoming.md'), + ('stateStep', 'Control Theory', '(A, B, x, u)', 'Planned roadmap function for Control Theory from upcoming.md.', 'upcoming.md'), + ('convexAnalysisApproximateConvexFunction', 'Convex Analysis', '(value, tolerance=1e-9)', 'Approximate a convex function with explicit tolerance controls.', 'professional_function_catalog.md'), + ('convexAnalysisApproximateConvexSet', 'Convex Analysis', '(value, tolerance=1e-9)', 'Approximate a convex set with explicit tolerance controls.', 'professional_function_catalog.md'), + ('convexAnalysisApproximateProjection', 'Convex Analysis', '(value, tolerance=1e-9)', 'Approximate a projection with explicit tolerance controls.', 'professional_function_catalog.md'), + ('convexAnalysisApproximateSubgradient', 'Convex Analysis', '(value, tolerance=1e-9)', 'Approximate a subgradient with explicit tolerance controls.', 'professional_function_catalog.md'), + ('convexAnalysisApproximateSupportFunction', 'Convex Analysis', '(value, tolerance=1e-9)', 'Approximate a support function with explicit tolerance controls.', 'professional_function_catalog.md'), + ('convexAnalysisCanonicalizeConvexFunction', 'Convex Analysis', '(value)', 'Canonicalize a convex function so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('convexAnalysisCanonicalizeConvexSet', 'Convex Analysis', '(value)', 'Canonicalize a convex set so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('convexAnalysisCanonicalizeProjection', 'Convex Analysis', '(value)', 'Canonicalize a projection so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('convexAnalysisCanonicalizeSubgradient', 'Convex Analysis', '(value)', 'Canonicalize a subgradient so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('convexAnalysisCanonicalizeSupportFunction', 'Convex Analysis', '(value)', 'Canonicalize a support function so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('convexAnalysisClassifyConvexFunction', 'Convex Analysis', '(value)', 'Classify a convex function by its standard Convex Analysis invariants.', 'professional_function_catalog.md'), + ('convexAnalysisClassifyConvexSet', 'Convex Analysis', '(value)', 'Classify a convex set by its standard Convex Analysis invariants.', 'professional_function_catalog.md'), + ('convexAnalysisClassifyProjection', 'Convex Analysis', '(value)', 'Classify a projection by its standard Convex Analysis invariants.', 'professional_function_catalog.md'), + ('convexAnalysisClassifySubgradient', 'Convex Analysis', '(value)', 'Classify a subgradient by its standard Convex Analysis invariants.', 'professional_function_catalog.md'), + ('convexAnalysisClassifySupportFunction', 'Convex Analysis', '(value)', 'Classify a support function by its standard Convex Analysis invariants.', 'professional_function_catalog.md'), + ('convexAnalysisCombineConvexFunction', 'Convex Analysis', '(left, right)', 'Combine two convex function values with the natural operation for Convex Analysis.', 'professional_function_catalog.md'), + ('convexAnalysisCombineConvexSet', 'Convex Analysis', '(left, right)', 'Combine two convex set values with the natural operation for Convex Analysis.', 'professional_function_catalog.md'), + ('convexAnalysisCombineProjection', 'Convex Analysis', '(left, right)', 'Combine two projection values with the natural operation for Convex Analysis.', 'professional_function_catalog.md'), + ('convexAnalysisCombineSubgradient', 'Convex Analysis', '(left, right)', 'Combine two subgradient values with the natural operation for Convex Analysis.', 'professional_function_catalog.md'), + ('convexAnalysisCombineSupportFunction', 'Convex Analysis', '(left, right)', 'Combine two support function values with the natural operation for Convex Analysis.', 'professional_function_catalog.md'), + ('convexAnalysisCompareConvexFunction', 'Convex Analysis', '(left, right)', 'Compare two convex function values under the conventions of Convex Analysis.', 'professional_function_catalog.md'), + ('convexAnalysisCompareConvexSet', 'Convex Analysis', '(left, right)', 'Compare two convex set values under the conventions of Convex Analysis.', 'professional_function_catalog.md'), + ('convexAnalysisCompareProjection', 'Convex Analysis', '(left, right)', 'Compare two projection values under the conventions of Convex Analysis.', 'professional_function_catalog.md'), + ('convexAnalysisCompareSubgradient', 'Convex Analysis', '(left, right)', 'Compare two subgradient values under the conventions of Convex Analysis.', 'professional_function_catalog.md'), + ('convexAnalysisCompareSupportFunction', 'Convex Analysis', '(left, right)', 'Compare two support function values under the conventions of Convex Analysis.', 'professional_function_catalog.md'), + ('convexAnalysisComputeConvexFunction', 'Convex Analysis', '(value)', 'Compute the central numerical or symbolic data of a convex function.', 'professional_function_catalog.md'), + ('convexAnalysisComputeConvexSet', 'Convex Analysis', '(value)', 'Compute the central numerical or symbolic data of a convex set.', 'professional_function_catalog.md'), + ('convexAnalysisComputeProjection', 'Convex Analysis', '(value)', 'Compute the central numerical or symbolic data of a projection.', 'professional_function_catalog.md'), + ('convexAnalysisComputeSubgradient', 'Convex Analysis', '(value)', 'Compute the central numerical or symbolic data of a subgradient.', 'professional_function_catalog.md'), + ('convexAnalysisComputeSupportFunction', 'Convex Analysis', '(value)', 'Compute the central numerical or symbolic data of a support function.', 'professional_function_catalog.md'), + ('convexAnalysisConstructConvexFunction', 'Convex Analysis', '(*args)', 'Construct a convex function from explicit inputs for Convex Analysis.', 'professional_function_catalog.md'), + ('convexAnalysisConstructConvexSet', 'Convex Analysis', '(*args)', 'Construct a convex set from explicit inputs for Convex Analysis.', 'professional_function_catalog.md'), + ('convexAnalysisConstructProjection', 'Convex Analysis', '(*args)', 'Construct a projection from explicit inputs for Convex Analysis.', 'professional_function_catalog.md'), + ('convexAnalysisConstructSubgradient', 'Convex Analysis', '(*args)', 'Construct a subgradient from explicit inputs for Convex Analysis.', 'professional_function_catalog.md'), + ('convexAnalysisConstructSupportFunction', 'Convex Analysis', '(*args)', 'Construct a support function from explicit inputs for Convex Analysis.', 'professional_function_catalog.md'), + ('convexAnalysisDecomposeConvexFunction', 'Convex Analysis', '(value)', 'Decompose a convex function into simpler or canonical components.', 'professional_function_catalog.md'), + ('convexAnalysisDecomposeConvexSet', 'Convex Analysis', '(value)', 'Decompose a convex set into simpler or canonical components.', 'professional_function_catalog.md'), + ('convexAnalysisDecomposeProjection', 'Convex Analysis', '(value)', 'Decompose a projection into simpler or canonical components.', 'professional_function_catalog.md'), + ('convexAnalysisDecomposeSubgradient', 'Convex Analysis', '(value)', 'Decompose a subgradient into simpler or canonical components.', 'professional_function_catalog.md'), + ('convexAnalysisDecomposeSupportFunction', 'Convex Analysis', '(value)', 'Decompose a support function into simpler or canonical components.', 'professional_function_catalog.md'), + ('convexAnalysisDocumentConvexFunction', 'Convex Analysis', '(value)', 'Return a structured explanation of a convex function and related assumptions.', 'professional_function_catalog.md'), + ('convexAnalysisDocumentConvexSet', 'Convex Analysis', '(value)', 'Return a structured explanation of a convex set and related assumptions.', 'professional_function_catalog.md'), + ('convexAnalysisDocumentProjection', 'Convex Analysis', '(value)', 'Return a structured explanation of a projection and related assumptions.', 'professional_function_catalog.md'), + ('convexAnalysisDocumentSubgradient', 'Convex Analysis', '(value)', 'Return a structured explanation of a subgradient and related assumptions.', 'professional_function_catalog.md'), + ('convexAnalysisDocumentSupportFunction', 'Convex Analysis', '(value)', 'Return a structured explanation of a support function and related assumptions.', 'professional_function_catalog.md'), + ('convexAnalysisEnumerateConvexFunction', 'Convex Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a convex function.', 'professional_function_catalog.md'), + ('convexAnalysisEnumerateConvexSet', 'Convex Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a convex set.', 'professional_function_catalog.md'), + ('convexAnalysisEnumerateProjection', 'Convex Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a projection.', 'professional_function_catalog.md'), + ('convexAnalysisEnumerateSubgradient', 'Convex Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a subgradient.', 'professional_function_catalog.md'), + ('convexAnalysisEnumerateSupportFunction', 'Convex Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a support function.', 'professional_function_catalog.md'), + ('convexAnalysisEstimateConvexFunction', 'Convex Analysis', '(value, samples=None)', 'Estimate a convex function property from finite samples or approximations.', 'professional_function_catalog.md'), + ('convexAnalysisEstimateConvexSet', 'Convex Analysis', '(value, samples=None)', 'Estimate a convex set property from finite samples or approximations.', 'professional_function_catalog.md'), + ('convexAnalysisEstimateProjection', 'Convex Analysis', '(value, samples=None)', 'Estimate a projection property from finite samples or approximations.', 'professional_function_catalog.md'), + ('convexAnalysisEstimateSubgradient', 'Convex Analysis', '(value, samples=None)', 'Estimate a subgradient property from finite samples or approximations.', 'professional_function_catalog.md'), + ('convexAnalysisEstimateSupportFunction', 'Convex Analysis', '(value, samples=None)', 'Estimate a support function property from finite samples or approximations.', 'professional_function_catalog.md'), + ('convexAnalysisEvaluateConvexFunction', 'Convex Analysis', '(value, point=None)', 'Evaluate a convex function at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('convexAnalysisEvaluateConvexSet', 'Convex Analysis', '(value, point=None)', 'Evaluate a convex set at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('convexAnalysisEvaluateProjection', 'Convex Analysis', '(value, point=None)', 'Evaluate a projection at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('convexAnalysisEvaluateSubgradient', 'Convex Analysis', '(value, point=None)', 'Evaluate a subgradient at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('convexAnalysisEvaluateSupportFunction', 'Convex Analysis', '(value, point=None)', 'Evaluate a support function at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('convexAnalysisFormatConvexFunction', 'Convex Analysis', '(value)', 'Format a convex function for deterministic user-facing output.', 'professional_function_catalog.md'), + ('convexAnalysisFormatConvexSet', 'Convex Analysis', '(value)', 'Format a convex set for deterministic user-facing output.', 'professional_function_catalog.md'), + ('convexAnalysisFormatProjection', 'Convex Analysis', '(value)', 'Format a projection for deterministic user-facing output.', 'professional_function_catalog.md'), + ('convexAnalysisFormatSubgradient', 'Convex Analysis', '(value)', 'Format a subgradient for deterministic user-facing output.', 'professional_function_catalog.md'), + ('convexAnalysisFormatSupportFunction', 'Convex Analysis', '(value)', 'Format a support function for deterministic user-facing output.', 'professional_function_catalog.md'), + ('convexAnalysisGenerateExampleConvexFunction', 'Convex Analysis', '(size=3)', 'Generate a small documented example of a convex function.', 'professional_function_catalog.md'), + ('convexAnalysisGenerateExampleConvexSet', 'Convex Analysis', '(size=3)', 'Generate a small documented example of a convex set.', 'professional_function_catalog.md'), + ('convexAnalysisGenerateExampleProjection', 'Convex Analysis', '(size=3)', 'Generate a small documented example of a projection.', 'professional_function_catalog.md'), + ('convexAnalysisGenerateExampleSubgradient', 'Convex Analysis', '(size=3)', 'Generate a small documented example of a subgradient.', 'professional_function_catalog.md'), + ('convexAnalysisGenerateExampleSupportFunction', 'Convex Analysis', '(size=3)', 'Generate a small documented example of a support function.', 'professional_function_catalog.md'), + ('convexAnalysisNormalizeConvexFunction', 'Convex Analysis', '(value)', 'Normalize a convex function into the standard Convex Analysis representation.', 'professional_function_catalog.md'), + ('convexAnalysisNormalizeConvexSet', 'Convex Analysis', '(value)', 'Normalize a convex set into the standard Convex Analysis representation.', 'professional_function_catalog.md'), + ('convexAnalysisNormalizeProjection', 'Convex Analysis', '(value)', 'Normalize a projection into the standard Convex Analysis representation.', 'professional_function_catalog.md'), + ('convexAnalysisNormalizeSubgradient', 'Convex Analysis', '(value)', 'Normalize a subgradient into the standard Convex Analysis representation.', 'professional_function_catalog.md'), + ('convexAnalysisNormalizeSupportFunction', 'Convex Analysis', '(value)', 'Normalize a support function into the standard Convex Analysis representation.', 'professional_function_catalog.md'), + ('convexAnalysisParseConvexFunction', 'Convex Analysis', '(text)', 'Parse a text or structured value into a convex function.', 'professional_function_catalog.md'), + ('convexAnalysisParseConvexSet', 'Convex Analysis', '(text)', 'Parse a text or structured value into a convex set.', 'professional_function_catalog.md'), + ('convexAnalysisParseProjection', 'Convex Analysis', '(text)', 'Parse a text or structured value into a projection.', 'professional_function_catalog.md'), + ('convexAnalysisParseSubgradient', 'Convex Analysis', '(text)', 'Parse a text or structured value into a subgradient.', 'professional_function_catalog.md'), + ('convexAnalysisParseSupportFunction', 'Convex Analysis', '(text)', 'Parse a text or structured value into a support function.', 'professional_function_catalog.md'), + ('convexAnalysisSimplifyConvexFunction', 'Convex Analysis', '(value)', 'Simplify a convex function without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('convexAnalysisSimplifyConvexSet', 'Convex Analysis', '(value)', 'Simplify a convex set without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('convexAnalysisSimplifyProjection', 'Convex Analysis', '(value)', 'Simplify a projection without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('convexAnalysisSimplifySubgradient', 'Convex Analysis', '(value)', 'Simplify a subgradient without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('convexAnalysisSimplifySupportFunction', 'Convex Analysis', '(value)', 'Simplify a support function without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('convexAnalysisTestEquivalenceConvexFunction', 'Convex Analysis', '(left, right)', 'Test whether two convex function values are equivalent in Convex Analysis.', 'professional_function_catalog.md'), + ('convexAnalysisTestEquivalenceConvexSet', 'Convex Analysis', '(left, right)', 'Test whether two convex set values are equivalent in Convex Analysis.', 'professional_function_catalog.md'), + ('convexAnalysisTestEquivalenceProjection', 'Convex Analysis', '(left, right)', 'Test whether two projection values are equivalent in Convex Analysis.', 'professional_function_catalog.md'), + ('convexAnalysisTestEquivalenceSubgradient', 'Convex Analysis', '(left, right)', 'Test whether two subgradient values are equivalent in Convex Analysis.', 'professional_function_catalog.md'), + ('convexAnalysisTestEquivalenceSupportFunction', 'Convex Analysis', '(left, right)', 'Test whether two support function values are equivalent in Convex Analysis.', 'professional_function_catalog.md'), + ('convexAnalysisTransformConvexFunction', 'Convex Analysis', '(value, mapping)', 'Transform a convex function through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('convexAnalysisTransformConvexSet', 'Convex Analysis', '(value, mapping)', 'Transform a convex set through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('convexAnalysisTransformProjection', 'Convex Analysis', '(value, mapping)', 'Transform a projection through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('convexAnalysisTransformSubgradient', 'Convex Analysis', '(value, mapping)', 'Transform a subgradient through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('convexAnalysisTransformSupportFunction', 'Convex Analysis', '(value, mapping)', 'Transform a support function through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('convexAnalysisValidateConvexFunction', 'Convex Analysis', '(value)', 'Validate the convex function representation and domain rules for Convex Analysis.', 'professional_function_catalog.md'), + ('convexAnalysisValidateConvexSet', 'Convex Analysis', '(value)', 'Validate the convex set representation and domain rules for Convex Analysis.', 'professional_function_catalog.md'), + ('convexAnalysisValidateProjection', 'Convex Analysis', '(value)', 'Validate the projection representation and domain rules for Convex Analysis.', 'professional_function_catalog.md'), + ('convexAnalysisValidateSubgradient', 'Convex Analysis', '(value)', 'Validate the subgradient representation and domain rules for Convex Analysis.', 'professional_function_catalog.md'), + ('convexAnalysisValidateSupportFunction', 'Convex Analysis', '(value)', 'Validate the support function representation and domain rules for Convex Analysis.', 'professional_function_catalog.md'), + ('convexCombination', 'Convex Analysis', '(points, weights)', 'Planned roadmap function for Convex Analysis from upcoming.md.', 'upcoming.md'), + ('isConvexFunctionOnSamples', 'Convex Analysis', '(values)', 'Planned roadmap function for Convex Analysis from upcoming.md.', 'upcoming.md'), + ('isConvexSet', 'Convex Analysis', '(points, membershipFunction, samples)', 'Planned roadmap function for Convex Analysis from upcoming.md.', 'upcoming.md'), + ('jensensInequalityCheck', 'Convex Analysis', '(f, points, weights)', 'Planned roadmap function for Convex Analysis from upcoming.md.', 'upcoming.md'), + ('projectionOntoInterval', 'Convex Analysis', '(x, lower, upper)', 'Planned roadmap function for Convex Analysis from upcoming.md.', 'upcoming.md'), + ('projectionOntoSimplex', 'Convex Analysis', '(vector)', 'Planned roadmap function for Convex Analysis from upcoming.md.', 'upcoming.md'), + ('subgradientAbsoluteValue', 'Convex Analysis', '(x)', 'Planned roadmap function for Convex Analysis from upcoming.md.', 'upcoming.md'), + ('supportFunction', 'Convex Analysis', '(points, direction)', 'Planned roadmap function for Convex Analysis from upcoming.md.', 'upcoming.md'), + ('bellNumber', 'Counting', '(n)', 'Planned roadmap function for Counting from upcoming.md.', 'upcoming.md'), + ('binomialCoefficient', 'Counting', '(n, k)', 'Planned roadmap function for Counting from upcoming.md.', 'upcoming.md'), + ('catalanNumber', 'Counting', '(n)', 'Planned roadmap function for Counting from upcoming.md.', 'upcoming.md'), + ('countingApproximateArrangementModel', 'Counting', '(value, tolerance=1e-9)', 'Approximate a arrangement model with explicit tolerance controls.', 'professional_function_catalog.md'), + ('countingApproximateCombinatorialIdentity', 'Counting', '(value, tolerance=1e-9)', 'Approximate a combinatorial identity with explicit tolerance controls.', 'professional_function_catalog.md'), + ('countingApproximatePartitionCount', 'Counting', '(value, tolerance=1e-9)', 'Approximate a partition count with explicit tolerance controls.', 'professional_function_catalog.md'), + ('countingApproximateRecurrenceCount', 'Counting', '(value, tolerance=1e-9)', 'Approximate a recurrence count with explicit tolerance controls.', 'professional_function_catalog.md'), + ('countingApproximateSelectionModel', 'Counting', '(value, tolerance=1e-9)', 'Approximate a selection model with explicit tolerance controls.', 'professional_function_catalog.md'), + ('countingCanonicalizeArrangementModel', 'Counting', '(value)', 'Canonicalize a arrangement model so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('countingCanonicalizeCombinatorialIdentity', 'Counting', '(value)', 'Canonicalize a combinatorial identity so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('countingCanonicalizePartitionCount', 'Counting', '(value)', 'Canonicalize a partition count so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('countingCanonicalizeRecurrenceCount', 'Counting', '(value)', 'Canonicalize a recurrence count so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('countingCanonicalizeSelectionModel', 'Counting', '(value)', 'Canonicalize a selection model so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('countingClassifyArrangementModel', 'Counting', '(value)', 'Classify a arrangement model by its standard Counting invariants.', 'professional_function_catalog.md'), + ('countingClassifyCombinatorialIdentity', 'Counting', '(value)', 'Classify a combinatorial identity by its standard Counting invariants.', 'professional_function_catalog.md'), + ('countingClassifyPartitionCount', 'Counting', '(value)', 'Classify a partition count by its standard Counting invariants.', 'professional_function_catalog.md'), + ('countingClassifyRecurrenceCount', 'Counting', '(value)', 'Classify a recurrence count by its standard Counting invariants.', 'professional_function_catalog.md'), + ('countingClassifySelectionModel', 'Counting', '(value)', 'Classify a selection model by its standard Counting invariants.', 'professional_function_catalog.md'), + ('countingCombineArrangementModel', 'Counting', '(left, right)', 'Combine two arrangement model values with the natural operation for Counting.', 'professional_function_catalog.md'), + ('countingCombineCombinatorialIdentity', 'Counting', '(left, right)', 'Combine two combinatorial identity values with the natural operation for Counting.', 'professional_function_catalog.md'), + ('countingCombinePartitionCount', 'Counting', '(left, right)', 'Combine two partition count values with the natural operation for Counting.', 'professional_function_catalog.md'), + ('countingCombineRecurrenceCount', 'Counting', '(left, right)', 'Combine two recurrence count values with the natural operation for Counting.', 'professional_function_catalog.md'), + ('countingCombineSelectionModel', 'Counting', '(left, right)', 'Combine two selection model values with the natural operation for Counting.', 'professional_function_catalog.md'), + ('countingCompareArrangementModel', 'Counting', '(left, right)', 'Compare two arrangement model values under the conventions of Counting.', 'professional_function_catalog.md'), + ('countingCompareCombinatorialIdentity', 'Counting', '(left, right)', 'Compare two combinatorial identity values under the conventions of Counting.', 'professional_function_catalog.md'), + ('countingComparePartitionCount', 'Counting', '(left, right)', 'Compare two partition count values under the conventions of Counting.', 'professional_function_catalog.md'), + ('countingCompareRecurrenceCount', 'Counting', '(left, right)', 'Compare two recurrence count values under the conventions of Counting.', 'professional_function_catalog.md'), + ('countingCompareSelectionModel', 'Counting', '(left, right)', 'Compare two selection model values under the conventions of Counting.', 'professional_function_catalog.md'), + ('countingComputeArrangementModel', 'Counting', '(value)', 'Compute the central numerical or symbolic data of a arrangement model.', 'professional_function_catalog.md'), + ('countingComputeCombinatorialIdentity', 'Counting', '(value)', 'Compute the central numerical or symbolic data of a combinatorial identity.', 'professional_function_catalog.md'), + ('countingComputePartitionCount', 'Counting', '(value)', 'Compute the central numerical or symbolic data of a partition count.', 'professional_function_catalog.md'), + ('countingComputeRecurrenceCount', 'Counting', '(value)', 'Compute the central numerical or symbolic data of a recurrence count.', 'professional_function_catalog.md'), + ('countingComputeSelectionModel', 'Counting', '(value)', 'Compute the central numerical or symbolic data of a selection model.', 'professional_function_catalog.md'), + ('countingConstructArrangementModel', 'Counting', '(*args)', 'Construct a arrangement model from explicit inputs for Counting.', 'professional_function_catalog.md'), + ('countingConstructCombinatorialIdentity', 'Counting', '(*args)', 'Construct a combinatorial identity from explicit inputs for Counting.', 'professional_function_catalog.md'), + ('countingConstructPartitionCount', 'Counting', '(*args)', 'Construct a partition count from explicit inputs for Counting.', 'professional_function_catalog.md'), + ('countingConstructRecurrenceCount', 'Counting', '(*args)', 'Construct a recurrence count from explicit inputs for Counting.', 'professional_function_catalog.md'), + ('countingConstructSelectionModel', 'Counting', '(*args)', 'Construct a selection model from explicit inputs for Counting.', 'professional_function_catalog.md'), + ('countingDecomposeArrangementModel', 'Counting', '(value)', 'Decompose a arrangement model into simpler or canonical components.', 'professional_function_catalog.md'), + ('countingDecomposeCombinatorialIdentity', 'Counting', '(value)', 'Decompose a combinatorial identity into simpler or canonical components.', 'professional_function_catalog.md'), + ('countingDecomposePartitionCount', 'Counting', '(value)', 'Decompose a partition count into simpler or canonical components.', 'professional_function_catalog.md'), + ('countingDecomposeRecurrenceCount', 'Counting', '(value)', 'Decompose a recurrence count into simpler or canonical components.', 'professional_function_catalog.md'), + ('countingDecomposeSelectionModel', 'Counting', '(value)', 'Decompose a selection model into simpler or canonical components.', 'professional_function_catalog.md'), + ('countingDocumentArrangementModel', 'Counting', '(value)', 'Return a structured explanation of a arrangement model and related assumptions.', 'professional_function_catalog.md'), + ('countingDocumentCombinatorialIdentity', 'Counting', '(value)', 'Return a structured explanation of a combinatorial identity and related assumptions.', 'professional_function_catalog.md'), + ('countingDocumentPartitionCount', 'Counting', '(value)', 'Return a structured explanation of a partition count and related assumptions.', 'professional_function_catalog.md'), + ('countingDocumentRecurrenceCount', 'Counting', '(value)', 'Return a structured explanation of a recurrence count and related assumptions.', 'professional_function_catalog.md'), + ('countingDocumentSelectionModel', 'Counting', '(value)', 'Return a structured explanation of a selection model and related assumptions.', 'professional_function_catalog.md'), + ('countingEnumerateArrangementModel', 'Counting', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a arrangement model.', 'professional_function_catalog.md'), + ('countingEnumerateCombinatorialIdentity', 'Counting', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a combinatorial identity.', 'professional_function_catalog.md'), + ('countingEnumeratePartitionCount', 'Counting', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a partition count.', 'professional_function_catalog.md'), + ('countingEnumerateRecurrenceCount', 'Counting', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a recurrence count.', 'professional_function_catalog.md'), + ('countingEnumerateSelectionModel', 'Counting', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a selection model.', 'professional_function_catalog.md'), + ('countingEstimateArrangementModel', 'Counting', '(value, samples=None)', 'Estimate a arrangement model property from finite samples or approximations.', 'professional_function_catalog.md'), + ('countingEstimateCombinatorialIdentity', 'Counting', '(value, samples=None)', 'Estimate a combinatorial identity property from finite samples or approximations.', 'professional_function_catalog.md'), + ('countingEstimatePartitionCount', 'Counting', '(value, samples=None)', 'Estimate a partition count property from finite samples or approximations.', 'professional_function_catalog.md'), + ('countingEstimateRecurrenceCount', 'Counting', '(value, samples=None)', 'Estimate a recurrence count property from finite samples or approximations.', 'professional_function_catalog.md'), + ('countingEstimateSelectionModel', 'Counting', '(value, samples=None)', 'Estimate a selection model property from finite samples or approximations.', 'professional_function_catalog.md'), + ('countingEvaluateArrangementModel', 'Counting', '(value, point=None)', 'Evaluate a arrangement model at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('countingEvaluateCombinatorialIdentity', 'Counting', '(value, point=None)', 'Evaluate a combinatorial identity at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('countingEvaluatePartitionCount', 'Counting', '(value, point=None)', 'Evaluate a partition count at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('countingEvaluateRecurrenceCount', 'Counting', '(value, point=None)', 'Evaluate a recurrence count at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('countingEvaluateSelectionModel', 'Counting', '(value, point=None)', 'Evaluate a selection model at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('countingFormatArrangementModel', 'Counting', '(value)', 'Format a arrangement model for deterministic user-facing output.', 'professional_function_catalog.md'), + ('countingFormatCombinatorialIdentity', 'Counting', '(value)', 'Format a combinatorial identity for deterministic user-facing output.', 'professional_function_catalog.md'), + ('countingFormatPartitionCount', 'Counting', '(value)', 'Format a partition count for deterministic user-facing output.', 'professional_function_catalog.md'), + ('countingFormatRecurrenceCount', 'Counting', '(value)', 'Format a recurrence count for deterministic user-facing output.', 'professional_function_catalog.md'), + ('countingFormatSelectionModel', 'Counting', '(value)', 'Format a selection model for deterministic user-facing output.', 'professional_function_catalog.md'), + ('countingGenerateExampleArrangementModel', 'Counting', '(size=3)', 'Generate a small documented example of a arrangement model.', 'professional_function_catalog.md'), + ('countingGenerateExampleCombinatorialIdentity', 'Counting', '(size=3)', 'Generate a small documented example of a combinatorial identity.', 'professional_function_catalog.md'), + ('countingGenerateExamplePartitionCount', 'Counting', '(size=3)', 'Generate a small documented example of a partition count.', 'professional_function_catalog.md'), + ('countingGenerateExampleRecurrenceCount', 'Counting', '(size=3)', 'Generate a small documented example of a recurrence count.', 'professional_function_catalog.md'), + ('countingGenerateExampleSelectionModel', 'Counting', '(size=3)', 'Generate a small documented example of a selection model.', 'professional_function_catalog.md'), + ('countingNormalizeArrangementModel', 'Counting', '(value)', 'Normalize a arrangement model into the standard Counting representation.', 'professional_function_catalog.md'), + ('countingNormalizeCombinatorialIdentity', 'Counting', '(value)', 'Normalize a combinatorial identity into the standard Counting representation.', 'professional_function_catalog.md'), + ('countingNormalizePartitionCount', 'Counting', '(value)', 'Normalize a partition count into the standard Counting representation.', 'professional_function_catalog.md'), + ('countingNormalizeRecurrenceCount', 'Counting', '(value)', 'Normalize a recurrence count into the standard Counting representation.', 'professional_function_catalog.md'), + ('countingNormalizeSelectionModel', 'Counting', '(value)', 'Normalize a selection model into the standard Counting representation.', 'professional_function_catalog.md'), + ('countingParseArrangementModel', 'Counting', '(text)', 'Parse a text or structured value into a arrangement model.', 'professional_function_catalog.md'), + ('countingParseCombinatorialIdentity', 'Counting', '(text)', 'Parse a text or structured value into a combinatorial identity.', 'professional_function_catalog.md'), + ('countingParsePartitionCount', 'Counting', '(text)', 'Parse a text or structured value into a partition count.', 'professional_function_catalog.md'), + ('countingParseRecurrenceCount', 'Counting', '(text)', 'Parse a text or structured value into a recurrence count.', 'professional_function_catalog.md'), + ('countingParseSelectionModel', 'Counting', '(text)', 'Parse a text or structured value into a selection model.', 'professional_function_catalog.md'), + ('countingSimplifyArrangementModel', 'Counting', '(value)', 'Simplify a arrangement model without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('countingSimplifyCombinatorialIdentity', 'Counting', '(value)', 'Simplify a combinatorial identity without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('countingSimplifyPartitionCount', 'Counting', '(value)', 'Simplify a partition count without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('countingSimplifyRecurrenceCount', 'Counting', '(value)', 'Simplify a recurrence count without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('countingSimplifySelectionModel', 'Counting', '(value)', 'Simplify a selection model without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('countingTestEquivalenceArrangementModel', 'Counting', '(left, right)', 'Test whether two arrangement model values are equivalent in Counting.', 'professional_function_catalog.md'), + ('countingTestEquivalenceCombinatorialIdentity', 'Counting', '(left, right)', 'Test whether two combinatorial identity values are equivalent in Counting.', 'professional_function_catalog.md'), + ('countingTestEquivalencePartitionCount', 'Counting', '(left, right)', 'Test whether two partition count values are equivalent in Counting.', 'professional_function_catalog.md'), + ('countingTestEquivalenceRecurrenceCount', 'Counting', '(left, right)', 'Test whether two recurrence count values are equivalent in Counting.', 'professional_function_catalog.md'), + ('countingTestEquivalenceSelectionModel', 'Counting', '(left, right)', 'Test whether two selection model values are equivalent in Counting.', 'professional_function_catalog.md'), + ('countingTransformArrangementModel', 'Counting', '(value, mapping)', 'Transform a arrangement model through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('countingTransformCombinatorialIdentity', 'Counting', '(value, mapping)', 'Transform a combinatorial identity through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('countingTransformPartitionCount', 'Counting', '(value, mapping)', 'Transform a partition count through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('countingTransformRecurrenceCount', 'Counting', '(value, mapping)', 'Transform a recurrence count through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('countingTransformSelectionModel', 'Counting', '(value, mapping)', 'Transform a selection model through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('countingValidateArrangementModel', 'Counting', '(value)', 'Validate the arrangement model representation and domain rules for Counting.', 'professional_function_catalog.md'), + ('countingValidateCombinatorialIdentity', 'Counting', '(value)', 'Validate the combinatorial identity representation and domain rules for Counting.', 'professional_function_catalog.md'), + ('countingValidatePartitionCount', 'Counting', '(value)', 'Validate the partition count representation and domain rules for Counting.', 'professional_function_catalog.md'), + ('countingValidateRecurrenceCount', 'Counting', '(value)', 'Validate the recurrence count representation and domain rules for Counting.', 'professional_function_catalog.md'), + ('countingValidateSelectionModel', 'Counting', '(value)', 'Validate the selection model representation and domain rules for Counting.', 'professional_function_catalog.md'), + ('inclusionExclusion', 'Counting', '(sizes, intersections)', 'Planned roadmap function for Counting from upcoming.md.', 'upcoming.md'), + ('integerPartitions', 'Counting', '(n)', 'Planned roadmap function for Counting from upcoming.md.', 'upcoming.md'), + ('multisetCombinations', 'Counting', '(n, k)', 'Planned roadmap function for Counting from upcoming.md.', 'upcoming.md'), + ('stirlingSecondKind', 'Counting', '(n, k)', 'Planned roadmap function for Counting from upcoming.md.', 'upcoming.md'), + ('affineCipherDecrypt', 'Cryptography', '(text, a, b)', 'Planned roadmap function for Cryptography from upcoming.md.', 'upcoming.md'), + ('affineCipherEncrypt', 'Cryptography', '(text, a, b)', 'Planned roadmap function for Cryptography from upcoming.md.', 'upcoming.md'), + ('caesarCipher', 'Cryptography', '(text, shift)', 'Planned roadmap function for Cryptography from upcoming.md.', 'upcoming.md'), + ('cryptographyApproximateCipher', 'Cryptography', '(value, tolerance=1e-9)', 'Approximate a cipher with explicit tolerance controls.', 'professional_function_catalog.md'), + ('cryptographyApproximateEducationalAttack', 'Cryptography', '(value, tolerance=1e-9)', 'Approximate a educational attack with explicit tolerance controls.', 'professional_function_catalog.md'), + ('cryptographyApproximateKeyPair', 'Cryptography', '(value, tolerance=1e-9)', 'Approximate a key pair with explicit tolerance controls.', 'professional_function_catalog.md'), + ('cryptographyApproximateModularPrimitive', 'Cryptography', '(value, tolerance=1e-9)', 'Approximate a modular primitive with explicit tolerance controls.', 'professional_function_catalog.md'), + ('cryptographyApproximateProtocolStep', 'Cryptography', '(value, tolerance=1e-9)', 'Approximate a protocol step with explicit tolerance controls.', 'professional_function_catalog.md'), + ('cryptographyCanonicalizeCipher', 'Cryptography', '(value)', 'Canonicalize a cipher so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('cryptographyCanonicalizeEducationalAttack', 'Cryptography', '(value)', 'Canonicalize a educational attack so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('cryptographyCanonicalizeKeyPair', 'Cryptography', '(value)', 'Canonicalize a key pair so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('cryptographyCanonicalizeModularPrimitive', 'Cryptography', '(value)', 'Canonicalize a modular primitive so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('cryptographyCanonicalizeProtocolStep', 'Cryptography', '(value)', 'Canonicalize a protocol step so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('cryptographyClassifyCipher', 'Cryptography', '(value)', 'Classify a cipher by its standard Cryptography invariants.', 'professional_function_catalog.md'), + ('cryptographyClassifyEducationalAttack', 'Cryptography', '(value)', 'Classify a educational attack by its standard Cryptography invariants.', 'professional_function_catalog.md'), + ('cryptographyClassifyKeyPair', 'Cryptography', '(value)', 'Classify a key pair by its standard Cryptography invariants.', 'professional_function_catalog.md'), + ('cryptographyClassifyModularPrimitive', 'Cryptography', '(value)', 'Classify a modular primitive by its standard Cryptography invariants.', 'professional_function_catalog.md'), + ('cryptographyClassifyProtocolStep', 'Cryptography', '(value)', 'Classify a protocol step by its standard Cryptography invariants.', 'professional_function_catalog.md'), + ('cryptographyCombineCipher', 'Cryptography', '(left, right)', 'Combine two cipher values with the natural operation for Cryptography.', 'professional_function_catalog.md'), + ('cryptographyCombineEducationalAttack', 'Cryptography', '(left, right)', 'Combine two educational attack values with the natural operation for Cryptography.', 'professional_function_catalog.md'), + ('cryptographyCombineKeyPair', 'Cryptography', '(left, right)', 'Combine two key pair values with the natural operation for Cryptography.', 'professional_function_catalog.md'), + ('cryptographyCombineModularPrimitive', 'Cryptography', '(left, right)', 'Combine two modular primitive values with the natural operation for Cryptography.', 'professional_function_catalog.md'), + ('cryptographyCombineProtocolStep', 'Cryptography', '(left, right)', 'Combine two protocol step values with the natural operation for Cryptography.', 'professional_function_catalog.md'), + ('cryptographyCompareCipher', 'Cryptography', '(left, right)', 'Compare two cipher values under the conventions of Cryptography.', 'professional_function_catalog.md'), + ('cryptographyCompareEducationalAttack', 'Cryptography', '(left, right)', 'Compare two educational attack values under the conventions of Cryptography.', 'professional_function_catalog.md'), + ('cryptographyCompareKeyPair', 'Cryptography', '(left, right)', 'Compare two key pair values under the conventions of Cryptography.', 'professional_function_catalog.md'), + ('cryptographyCompareModularPrimitive', 'Cryptography', '(left, right)', 'Compare two modular primitive values under the conventions of Cryptography.', 'professional_function_catalog.md'), + ('cryptographyCompareProtocolStep', 'Cryptography', '(left, right)', 'Compare two protocol step values under the conventions of Cryptography.', 'professional_function_catalog.md'), + ('cryptographyComputeCipher', 'Cryptography', '(value)', 'Compute the central numerical or symbolic data of a cipher.', 'professional_function_catalog.md'), + ('cryptographyComputeEducationalAttack', 'Cryptography', '(value)', 'Compute the central numerical or symbolic data of a educational attack.', 'professional_function_catalog.md'), + ('cryptographyComputeKeyPair', 'Cryptography', '(value)', 'Compute the central numerical or symbolic data of a key pair.', 'professional_function_catalog.md'), + ('cryptographyComputeModularPrimitive', 'Cryptography', '(value)', 'Compute the central numerical or symbolic data of a modular primitive.', 'professional_function_catalog.md'), + ('cryptographyComputeProtocolStep', 'Cryptography', '(value)', 'Compute the central numerical or symbolic data of a protocol step.', 'professional_function_catalog.md'), + ('cryptographyConstructCipher', 'Cryptography', '(*args)', 'Construct a cipher from explicit inputs for Cryptography.', 'professional_function_catalog.md'), + ('cryptographyConstructEducationalAttack', 'Cryptography', '(*args)', 'Construct a educational attack from explicit inputs for Cryptography.', 'professional_function_catalog.md'), + ('cryptographyConstructKeyPair', 'Cryptography', '(*args)', 'Construct a key pair from explicit inputs for Cryptography.', 'professional_function_catalog.md'), + ('cryptographyConstructModularPrimitive', 'Cryptography', '(*args)', 'Construct a modular primitive from explicit inputs for Cryptography.', 'professional_function_catalog.md'), + ('cryptographyConstructProtocolStep', 'Cryptography', '(*args)', 'Construct a protocol step from explicit inputs for Cryptography.', 'professional_function_catalog.md'), + ('cryptographyDecomposeCipher', 'Cryptography', '(value)', 'Decompose a cipher into simpler or canonical components.', 'professional_function_catalog.md'), + ('cryptographyDecomposeEducationalAttack', 'Cryptography', '(value)', 'Decompose a educational attack into simpler or canonical components.', 'professional_function_catalog.md'), + ('cryptographyDecomposeKeyPair', 'Cryptography', '(value)', 'Decompose a key pair into simpler or canonical components.', 'professional_function_catalog.md'), + ('cryptographyDecomposeModularPrimitive', 'Cryptography', '(value)', 'Decompose a modular primitive into simpler or canonical components.', 'professional_function_catalog.md'), + ('cryptographyDecomposeProtocolStep', 'Cryptography', '(value)', 'Decompose a protocol step into simpler or canonical components.', 'professional_function_catalog.md'), + ('cryptographyDocumentCipher', 'Cryptography', '(value)', 'Return a structured explanation of a cipher and related assumptions.', 'professional_function_catalog.md'), + ('cryptographyDocumentEducationalAttack', 'Cryptography', '(value)', 'Return a structured explanation of a educational attack and related assumptions.', 'professional_function_catalog.md'), + ('cryptographyDocumentKeyPair', 'Cryptography', '(value)', 'Return a structured explanation of a key pair and related assumptions.', 'professional_function_catalog.md'), + ('cryptographyDocumentModularPrimitive', 'Cryptography', '(value)', 'Return a structured explanation of a modular primitive and related assumptions.', 'professional_function_catalog.md'), + ('cryptographyDocumentProtocolStep', 'Cryptography', '(value)', 'Return a structured explanation of a protocol step and related assumptions.', 'professional_function_catalog.md'), + ('cryptographyEnumerateCipher', 'Cryptography', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a cipher.', 'professional_function_catalog.md'), + ('cryptographyEnumerateEducationalAttack', 'Cryptography', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a educational attack.', 'professional_function_catalog.md'), + ('cryptographyEnumerateKeyPair', 'Cryptography', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a key pair.', 'professional_function_catalog.md'), + ('cryptographyEnumerateModularPrimitive', 'Cryptography', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a modular primitive.', 'professional_function_catalog.md'), + ('cryptographyEnumerateProtocolStep', 'Cryptography', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a protocol step.', 'professional_function_catalog.md'), + ('cryptographyEstimateCipher', 'Cryptography', '(value, samples=None)', 'Estimate a cipher property from finite samples or approximations.', 'professional_function_catalog.md'), + ('cryptographyEstimateEducationalAttack', 'Cryptography', '(value, samples=None)', 'Estimate a educational attack property from finite samples or approximations.', 'professional_function_catalog.md'), + ('cryptographyEstimateKeyPair', 'Cryptography', '(value, samples=None)', 'Estimate a key pair property from finite samples or approximations.', 'professional_function_catalog.md'), + ('cryptographyEstimateModularPrimitive', 'Cryptography', '(value, samples=None)', 'Estimate a modular primitive property from finite samples or approximations.', 'professional_function_catalog.md'), + ('cryptographyEstimateProtocolStep', 'Cryptography', '(value, samples=None)', 'Estimate a protocol step property from finite samples or approximations.', 'professional_function_catalog.md'), + ('cryptographyEvaluateCipher', 'Cryptography', '(value, point=None)', 'Evaluate a cipher at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('cryptographyEvaluateEducationalAttack', 'Cryptography', '(value, point=None)', 'Evaluate a educational attack at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('cryptographyEvaluateKeyPair', 'Cryptography', '(value, point=None)', 'Evaluate a key pair at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('cryptographyEvaluateModularPrimitive', 'Cryptography', '(value, point=None)', 'Evaluate a modular primitive at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('cryptographyEvaluateProtocolStep', 'Cryptography', '(value, point=None)', 'Evaluate a protocol step at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('cryptographyFormatCipher', 'Cryptography', '(value)', 'Format a cipher for deterministic user-facing output.', 'professional_function_catalog.md'), + ('cryptographyFormatEducationalAttack', 'Cryptography', '(value)', 'Format a educational attack for deterministic user-facing output.', 'professional_function_catalog.md'), + ('cryptographyFormatKeyPair', 'Cryptography', '(value)', 'Format a key pair for deterministic user-facing output.', 'professional_function_catalog.md'), + ('cryptographyFormatModularPrimitive', 'Cryptography', '(value)', 'Format a modular primitive for deterministic user-facing output.', 'professional_function_catalog.md'), + ('cryptographyFormatProtocolStep', 'Cryptography', '(value)', 'Format a protocol step for deterministic user-facing output.', 'professional_function_catalog.md'), + ('cryptographyGenerateExampleCipher', 'Cryptography', '(size=3)', 'Generate a small documented example of a cipher.', 'professional_function_catalog.md'), + ('cryptographyGenerateExampleEducationalAttack', 'Cryptography', '(size=3)', 'Generate a small documented example of a educational attack.', 'professional_function_catalog.md'), + ('cryptographyGenerateExampleKeyPair', 'Cryptography', '(size=3)', 'Generate a small documented example of a key pair.', 'professional_function_catalog.md'), + ('cryptographyGenerateExampleModularPrimitive', 'Cryptography', '(size=3)', 'Generate a small documented example of a modular primitive.', 'professional_function_catalog.md'), + ('cryptographyGenerateExampleProtocolStep', 'Cryptography', '(size=3)', 'Generate a small documented example of a protocol step.', 'professional_function_catalog.md'), + ('cryptographyNormalizeCipher', 'Cryptography', '(value)', 'Normalize a cipher into the standard Cryptography representation.', 'professional_function_catalog.md'), + ('cryptographyNormalizeEducationalAttack', 'Cryptography', '(value)', 'Normalize a educational attack into the standard Cryptography representation.', 'professional_function_catalog.md'), + ('cryptographyNormalizeKeyPair', 'Cryptography', '(value)', 'Normalize a key pair into the standard Cryptography representation.', 'professional_function_catalog.md'), + ('cryptographyNormalizeModularPrimitive', 'Cryptography', '(value)', 'Normalize a modular primitive into the standard Cryptography representation.', 'professional_function_catalog.md'), + ('cryptographyNormalizeProtocolStep', 'Cryptography', '(value)', 'Normalize a protocol step into the standard Cryptography representation.', 'professional_function_catalog.md'), + ('cryptographyParseCipher', 'Cryptography', '(text)', 'Parse a text or structured value into a cipher.', 'professional_function_catalog.md'), + ('cryptographyParseEducationalAttack', 'Cryptography', '(text)', 'Parse a text or structured value into a educational attack.', 'professional_function_catalog.md'), + ('cryptographyParseKeyPair', 'Cryptography', '(text)', 'Parse a text or structured value into a key pair.', 'professional_function_catalog.md'), + ('cryptographyParseModularPrimitive', 'Cryptography', '(text)', 'Parse a text or structured value into a modular primitive.', 'professional_function_catalog.md'), + ('cryptographyParseProtocolStep', 'Cryptography', '(text)', 'Parse a text or structured value into a protocol step.', 'professional_function_catalog.md'), + ('cryptographySimplifyCipher', 'Cryptography', '(value)', 'Simplify a cipher without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('cryptographySimplifyEducationalAttack', 'Cryptography', '(value)', 'Simplify a educational attack without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('cryptographySimplifyKeyPair', 'Cryptography', '(value)', 'Simplify a key pair without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('cryptographySimplifyModularPrimitive', 'Cryptography', '(value)', 'Simplify a modular primitive without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('cryptographySimplifyProtocolStep', 'Cryptography', '(value)', 'Simplify a protocol step without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('cryptographyTestEquivalenceCipher', 'Cryptography', '(left, right)', 'Test whether two cipher values are equivalent in Cryptography.', 'professional_function_catalog.md'), + ('cryptographyTestEquivalenceEducationalAttack', 'Cryptography', '(left, right)', 'Test whether two educational attack values are equivalent in Cryptography.', 'professional_function_catalog.md'), + ('cryptographyTestEquivalenceKeyPair', 'Cryptography', '(left, right)', 'Test whether two key pair values are equivalent in Cryptography.', 'professional_function_catalog.md'), + ('cryptographyTestEquivalenceModularPrimitive', 'Cryptography', '(left, right)', 'Test whether two modular primitive values are equivalent in Cryptography.', 'professional_function_catalog.md'), + ('cryptographyTestEquivalenceProtocolStep', 'Cryptography', '(left, right)', 'Test whether two protocol step values are equivalent in Cryptography.', 'professional_function_catalog.md'), + ('cryptographyTransformCipher', 'Cryptography', '(value, mapping)', 'Transform a cipher through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('cryptographyTransformEducationalAttack', 'Cryptography', '(value, mapping)', 'Transform a educational attack through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('cryptographyTransformKeyPair', 'Cryptography', '(value, mapping)', 'Transform a key pair through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('cryptographyTransformModularPrimitive', 'Cryptography', '(value, mapping)', 'Transform a modular primitive through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('cryptographyTransformProtocolStep', 'Cryptography', '(value, mapping)', 'Transform a protocol step through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('cryptographyValidateCipher', 'Cryptography', '(value)', 'Validate the cipher representation and domain rules for Cryptography.', 'professional_function_catalog.md'), + ('cryptographyValidateEducationalAttack', 'Cryptography', '(value)', 'Validate the educational attack representation and domain rules for Cryptography.', 'professional_function_catalog.md'), + ('cryptographyValidateKeyPair', 'Cryptography', '(value)', 'Validate the key pair representation and domain rules for Cryptography.', 'professional_function_catalog.md'), + ('cryptographyValidateModularPrimitive', 'Cryptography', '(value)', 'Validate the modular primitive representation and domain rules for Cryptography.', 'professional_function_catalog.md'), + ('cryptographyValidateProtocolStep', 'Cryptography', '(value)', 'Validate the protocol step representation and domain rules for Cryptography.', 'professional_function_catalog.md'), + ('diffieHellmanPublic', 'Cryptography', '(g, private, p)', 'Planned roadmap function for Cryptography from upcoming.md.', 'upcoming.md'), + ('diffieHellmanShared', 'Cryptography', '(public, private, p)', 'Planned roadmap function for Cryptography from upcoming.md.', 'upcoming.md'), + ('rsaDecryptNumber', 'Cryptography', '(ciphertext, d, n)', 'Planned roadmap function for Cryptography from upcoming.md.', 'upcoming.md'), + ('rsaEncryptNumber', 'Cryptography', '(message, e, n)', 'Planned roadmap function for Cryptography from upcoming.md.', 'upcoming.md'), + ('rsaKeyCheck', 'Cryptography', '(p, q, e)', 'Planned roadmap function for Cryptography from upcoming.md.', 'upcoming.md'), + ('borelGeneratedFinite', 'Descriptive Set Theory', '(generators, universalSet)', 'Planned roadmap function for Descriptive Set Theory from upcoming.md.', 'upcoming.md'), + ('cantorPrefixTree', 'Descriptive Set Theory', '(depth)', 'Planned roadmap function for Descriptive Set Theory from upcoming.md.', 'upcoming.md'), + ('cylinderSet', 'Descriptive Set Theory', '(prefix, alphabet)', 'Planned roadmap function for Descriptive Set Theory from upcoming.md.', 'upcoming.md'), + ('descriptiveSetTheoryApproximateBorelCode', 'Descriptive Set Theory', '(value, tolerance=1e-9)', 'Approximate a Borel code with explicit tolerance controls.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryApproximateCylinderSet', 'Descriptive Set Theory', '(value, tolerance=1e-9)', 'Approximate a cylinder set with explicit tolerance controls.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryApproximateEquivalenceRelation', 'Descriptive Set Theory', '(value, tolerance=1e-9)', 'Approximate a equivalence relation with explicit tolerance controls.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryApproximatePrefixTree', 'Descriptive Set Theory', '(value, tolerance=1e-9)', 'Approximate a prefix tree with explicit tolerance controls.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryApproximateReduction', 'Descriptive Set Theory', '(value, tolerance=1e-9)', 'Approximate a reduction with explicit tolerance controls.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryCanonicalizeBorelCode', 'Descriptive Set Theory', '(value)', 'Canonicalize a Borel code so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryCanonicalizeCylinderSet', 'Descriptive Set Theory', '(value)', 'Canonicalize a cylinder set so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryCanonicalizeEquivalenceRelation', 'Descriptive Set Theory', '(value)', 'Canonicalize a equivalence relation so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryCanonicalizePrefixTree', 'Descriptive Set Theory', '(value)', 'Canonicalize a prefix tree so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryCanonicalizeReduction', 'Descriptive Set Theory', '(value)', 'Canonicalize a reduction so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryClassifyBorelCode', 'Descriptive Set Theory', '(value)', 'Classify a Borel code by its standard Descriptive Set Theory invariants.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryClassifyCylinderSet', 'Descriptive Set Theory', '(value)', 'Classify a cylinder set by its standard Descriptive Set Theory invariants.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryClassifyEquivalenceRelation', 'Descriptive Set Theory', '(value)', 'Classify a equivalence relation by its standard Descriptive Set Theory invariants.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryClassifyPrefixTree', 'Descriptive Set Theory', '(value)', 'Classify a prefix tree by its standard Descriptive Set Theory invariants.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryClassifyReduction', 'Descriptive Set Theory', '(value)', 'Classify a reduction by its standard Descriptive Set Theory invariants.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryCombineBorelCode', 'Descriptive Set Theory', '(left, right)', 'Combine two Borel code values with the natural operation for Descriptive Set Theory.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryCombineCylinderSet', 'Descriptive Set Theory', '(left, right)', 'Combine two cylinder set values with the natural operation for Descriptive Set Theory.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryCombineEquivalenceRelation', 'Descriptive Set Theory', '(left, right)', 'Combine two equivalence relation values with the natural operation for Descriptive Set Theory.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryCombinePrefixTree', 'Descriptive Set Theory', '(left, right)', 'Combine two prefix tree values with the natural operation for Descriptive Set Theory.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryCombineReduction', 'Descriptive Set Theory', '(left, right)', 'Combine two reduction values with the natural operation for Descriptive Set Theory.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryCompareBorelCode', 'Descriptive Set Theory', '(left, right)', 'Compare two Borel code values under the conventions of Descriptive Set Theory.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryCompareCylinderSet', 'Descriptive Set Theory', '(left, right)', 'Compare two cylinder set values under the conventions of Descriptive Set Theory.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryCompareEquivalenceRelation', 'Descriptive Set Theory', '(left, right)', 'Compare two equivalence relation values under the conventions of Descriptive Set Theory.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryComparePrefixTree', 'Descriptive Set Theory', '(left, right)', 'Compare two prefix tree values under the conventions of Descriptive Set Theory.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryCompareReduction', 'Descriptive Set Theory', '(left, right)', 'Compare two reduction values under the conventions of Descriptive Set Theory.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryComputeBorelCode', 'Descriptive Set Theory', '(value)', 'Compute the central numerical or symbolic data of a Borel code.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryComputeCylinderSet', 'Descriptive Set Theory', '(value)', 'Compute the central numerical or symbolic data of a cylinder set.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryComputeEquivalenceRelation', 'Descriptive Set Theory', '(value)', 'Compute the central numerical or symbolic data of a equivalence relation.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryComputePrefixTree', 'Descriptive Set Theory', '(value)', 'Compute the central numerical or symbolic data of a prefix tree.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryComputeReduction', 'Descriptive Set Theory', '(value)', 'Compute the central numerical or symbolic data of a reduction.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryConstructBorelCode', 'Descriptive Set Theory', '(*args)', 'Construct a Borel code from explicit inputs for Descriptive Set Theory.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryConstructCylinderSet', 'Descriptive Set Theory', '(*args)', 'Construct a cylinder set from explicit inputs for Descriptive Set Theory.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryConstructEquivalenceRelation', 'Descriptive Set Theory', '(*args)', 'Construct a equivalence relation from explicit inputs for Descriptive Set Theory.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryConstructPrefixTree', 'Descriptive Set Theory', '(*args)', 'Construct a prefix tree from explicit inputs for Descriptive Set Theory.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryConstructReduction', 'Descriptive Set Theory', '(*args)', 'Construct a reduction from explicit inputs for Descriptive Set Theory.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryDecomposeBorelCode', 'Descriptive Set Theory', '(value)', 'Decompose a Borel code into simpler or canonical components.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryDecomposeCylinderSet', 'Descriptive Set Theory', '(value)', 'Decompose a cylinder set into simpler or canonical components.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryDecomposeEquivalenceRelation', 'Descriptive Set Theory', '(value)', 'Decompose a equivalence relation into simpler or canonical components.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryDecomposePrefixTree', 'Descriptive Set Theory', '(value)', 'Decompose a prefix tree into simpler or canonical components.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryDecomposeReduction', 'Descriptive Set Theory', '(value)', 'Decompose a reduction into simpler or canonical components.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryDocumentBorelCode', 'Descriptive Set Theory', '(value)', 'Return a structured explanation of a Borel code and related assumptions.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryDocumentCylinderSet', 'Descriptive Set Theory', '(value)', 'Return a structured explanation of a cylinder set and related assumptions.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryDocumentEquivalenceRelation', 'Descriptive Set Theory', '(value)', 'Return a structured explanation of a equivalence relation and related assumptions.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryDocumentPrefixTree', 'Descriptive Set Theory', '(value)', 'Return a structured explanation of a prefix tree and related assumptions.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryDocumentReduction', 'Descriptive Set Theory', '(value)', 'Return a structured explanation of a reduction and related assumptions.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryEnumerateBorelCode', 'Descriptive Set Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a Borel code.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryEnumerateCylinderSet', 'Descriptive Set Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a cylinder set.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryEnumerateEquivalenceRelation', 'Descriptive Set Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a equivalence relation.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryEnumeratePrefixTree', 'Descriptive Set Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a prefix tree.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryEnumerateReduction', 'Descriptive Set Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a reduction.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryEstimateBorelCode', 'Descriptive Set Theory', '(value, samples=None)', 'Estimate a Borel code property from finite samples or approximations.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryEstimateCylinderSet', 'Descriptive Set Theory', '(value, samples=None)', 'Estimate a cylinder set property from finite samples or approximations.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryEstimateEquivalenceRelation', 'Descriptive Set Theory', '(value, samples=None)', 'Estimate a equivalence relation property from finite samples or approximations.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryEstimatePrefixTree', 'Descriptive Set Theory', '(value, samples=None)', 'Estimate a prefix tree property from finite samples or approximations.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryEstimateReduction', 'Descriptive Set Theory', '(value, samples=None)', 'Estimate a reduction property from finite samples or approximations.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryEvaluateBorelCode', 'Descriptive Set Theory', '(value, point=None)', 'Evaluate a Borel code at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryEvaluateCylinderSet', 'Descriptive Set Theory', '(value, point=None)', 'Evaluate a cylinder set at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryEvaluateEquivalenceRelation', 'Descriptive Set Theory', '(value, point=None)', 'Evaluate a equivalence relation at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryEvaluatePrefixTree', 'Descriptive Set Theory', '(value, point=None)', 'Evaluate a prefix tree at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryEvaluateReduction', 'Descriptive Set Theory', '(value, point=None)', 'Evaluate a reduction at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryFormatBorelCode', 'Descriptive Set Theory', '(value)', 'Format a Borel code for deterministic user-facing output.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryFormatCylinderSet', 'Descriptive Set Theory', '(value)', 'Format a cylinder set for deterministic user-facing output.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryFormatEquivalenceRelation', 'Descriptive Set Theory', '(value)', 'Format a equivalence relation for deterministic user-facing output.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryFormatPrefixTree', 'Descriptive Set Theory', '(value)', 'Format a prefix tree for deterministic user-facing output.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryFormatReduction', 'Descriptive Set Theory', '(value)', 'Format a reduction for deterministic user-facing output.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryGenerateExampleBorelCode', 'Descriptive Set Theory', '(size=3)', 'Generate a small documented example of a Borel code.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryGenerateExampleCylinderSet', 'Descriptive Set Theory', '(size=3)', 'Generate a small documented example of a cylinder set.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryGenerateExampleEquivalenceRelation', 'Descriptive Set Theory', '(size=3)', 'Generate a small documented example of a equivalence relation.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryGenerateExamplePrefixTree', 'Descriptive Set Theory', '(size=3)', 'Generate a small documented example of a prefix tree.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryGenerateExampleReduction', 'Descriptive Set Theory', '(size=3)', 'Generate a small documented example of a reduction.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryNormalizeBorelCode', 'Descriptive Set Theory', '(value)', 'Normalize a Borel code into the standard Descriptive Set Theory representation.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryNormalizeCylinderSet', 'Descriptive Set Theory', '(value)', 'Normalize a cylinder set into the standard Descriptive Set Theory representation.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryNormalizeEquivalenceRelation', 'Descriptive Set Theory', '(value)', 'Normalize a equivalence relation into the standard Descriptive Set Theory representation.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryNormalizePrefixTree', 'Descriptive Set Theory', '(value)', 'Normalize a prefix tree into the standard Descriptive Set Theory representation.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryNormalizeReduction', 'Descriptive Set Theory', '(value)', 'Normalize a reduction into the standard Descriptive Set Theory representation.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryParseBorelCode', 'Descriptive Set Theory', '(text)', 'Parse a text or structured value into a Borel code.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryParseCylinderSet', 'Descriptive Set Theory', '(text)', 'Parse a text or structured value into a cylinder set.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryParseEquivalenceRelation', 'Descriptive Set Theory', '(text)', 'Parse a text or structured value into a equivalence relation.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryParsePrefixTree', 'Descriptive Set Theory', '(text)', 'Parse a text or structured value into a prefix tree.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryParseReduction', 'Descriptive Set Theory', '(text)', 'Parse a text or structured value into a reduction.', 'professional_function_catalog.md'), + ('descriptiveSetTheorySimplifyBorelCode', 'Descriptive Set Theory', '(value)', 'Simplify a Borel code without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('descriptiveSetTheorySimplifyCylinderSet', 'Descriptive Set Theory', '(value)', 'Simplify a cylinder set without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('descriptiveSetTheorySimplifyEquivalenceRelation', 'Descriptive Set Theory', '(value)', 'Simplify a equivalence relation without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('descriptiveSetTheorySimplifyPrefixTree', 'Descriptive Set Theory', '(value)', 'Simplify a prefix tree without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('descriptiveSetTheorySimplifyReduction', 'Descriptive Set Theory', '(value)', 'Simplify a reduction without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryTestEquivalenceBorelCode', 'Descriptive Set Theory', '(left, right)', 'Test whether two Borel code values are equivalent in Descriptive Set Theory.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryTestEquivalenceCylinderSet', 'Descriptive Set Theory', '(left, right)', 'Test whether two cylinder set values are equivalent in Descriptive Set Theory.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryTestEquivalenceEquivalenceRelation', 'Descriptive Set Theory', '(left, right)', 'Test whether two equivalence relation values are equivalent in Descriptive Set Theory.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryTestEquivalencePrefixTree', 'Descriptive Set Theory', '(left, right)', 'Test whether two prefix tree values are equivalent in Descriptive Set Theory.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryTestEquivalenceReduction', 'Descriptive Set Theory', '(left, right)', 'Test whether two reduction values are equivalent in Descriptive Set Theory.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryTransformBorelCode', 'Descriptive Set Theory', '(value, mapping)', 'Transform a Borel code through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryTransformCylinderSet', 'Descriptive Set Theory', '(value, mapping)', 'Transform a cylinder set through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryTransformEquivalenceRelation', 'Descriptive Set Theory', '(value, mapping)', 'Transform a equivalence relation through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryTransformPrefixTree', 'Descriptive Set Theory', '(value, mapping)', 'Transform a prefix tree through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryTransformReduction', 'Descriptive Set Theory', '(value, mapping)', 'Transform a reduction through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryValidateBorelCode', 'Descriptive Set Theory', '(value)', 'Validate the Borel code representation and domain rules for Descriptive Set Theory.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryValidateCylinderSet', 'Descriptive Set Theory', '(value)', 'Validate the cylinder set representation and domain rules for Descriptive Set Theory.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryValidateEquivalenceRelation', 'Descriptive Set Theory', '(value)', 'Validate the equivalence relation representation and domain rules for Descriptive Set Theory.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryValidatePrefixTree', 'Descriptive Set Theory', '(value)', 'Validate the prefix tree representation and domain rules for Descriptive Set Theory.', 'professional_function_catalog.md'), + ('descriptiveSetTheoryValidateReduction', 'Descriptive Set Theory', '(value)', 'Validate the reduction representation and domain rules for Descriptive Set Theory.', 'professional_function_catalog.md'), + ('equivalenceClasses', 'Descriptive Set Theory', '(relation, elements)', 'Planned roadmap function for Descriptive Set Theory from upcoming.md.', 'upcoming.md'), + ('isBorelFinite', 'Descriptive Set Theory', '(setValue, generatedCollection)', 'Planned roadmap function for Descriptive Set Theory from upcoming.md.', 'upcoming.md'), + ('reductionBetweenRelations', 'Descriptive Set Theory', '(relationA, relationB, mapping)', 'Planned roadmap function for Descriptive Set Theory from upcoming.md.', 'upcoming.md'), + ('smoothEquivalenceRelationFinite', 'Descriptive Set Theory', '(relation, elements)', 'Planned roadmap function for Descriptive Set Theory from upcoming.md.', 'upcoming.md'), + ('treeBodyPrefixes', 'Descriptive Set Theory', '(tree, depth)', 'Planned roadmap function for Descriptive Set Theory from upcoming.md.', 'upcoming.md'), + ('arcLength', 'Differential Geometry', '(curve, a, b)', 'Planned roadmap function for Differential Geometry from upcoming.md.', 'upcoming.md'), + ('curvature2D', 'Differential Geometry', '(curve, t)', 'Planned roadmap function for Differential Geometry from upcoming.md.', 'upcoming.md'), + ('curvature3D', 'Differential Geometry', '(curve, t)', 'Planned roadmap function for Differential Geometry from upcoming.md.', 'upcoming.md'), + ('curveDerivative', 'Differential Geometry', '(curve, t)', 'Planned roadmap function for Differential Geometry from upcoming.md.', 'upcoming.md'), + ('differentialGeometryApproximateCurvatureProfile', 'Differential Geometry', '(value, tolerance=1e-9)', 'Approximate a curvature profile with explicit tolerance controls.', 'professional_function_catalog.md'), + ('differentialGeometryApproximateFrameField', 'Differential Geometry', '(value, tolerance=1e-9)', 'Approximate a frame field with explicit tolerance controls.', 'professional_function_catalog.md'), + ('differentialGeometryApproximateGeodesicSample', 'Differential Geometry', '(value, tolerance=1e-9)', 'Approximate a geodesic sample with explicit tolerance controls.', 'professional_function_catalog.md'), + ('differentialGeometryApproximateParametricCurve', 'Differential Geometry', '(value, tolerance=1e-9)', 'Approximate a parametric curve with explicit tolerance controls.', 'professional_function_catalog.md'), + ('differentialGeometryApproximateParametricSurface', 'Differential Geometry', '(value, tolerance=1e-9)', 'Approximate a parametric surface with explicit tolerance controls.', 'professional_function_catalog.md'), + ('differentialGeometryCanonicalizeCurvatureProfile', 'Differential Geometry', '(value)', 'Canonicalize a curvature profile so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('differentialGeometryCanonicalizeFrameField', 'Differential Geometry', '(value)', 'Canonicalize a frame field so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('differentialGeometryCanonicalizeGeodesicSample', 'Differential Geometry', '(value)', 'Canonicalize a geodesic sample so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('differentialGeometryCanonicalizeParametricCurve', 'Differential Geometry', '(value)', 'Canonicalize a parametric curve so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('differentialGeometryCanonicalizeParametricSurface', 'Differential Geometry', '(value)', 'Canonicalize a parametric surface so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('differentialGeometryClassifyCurvatureProfile', 'Differential Geometry', '(value)', 'Classify a curvature profile by its standard Differential Geometry invariants.', 'professional_function_catalog.md'), + ('differentialGeometryClassifyFrameField', 'Differential Geometry', '(value)', 'Classify a frame field by its standard Differential Geometry invariants.', 'professional_function_catalog.md'), + ('differentialGeometryClassifyGeodesicSample', 'Differential Geometry', '(value)', 'Classify a geodesic sample by its standard Differential Geometry invariants.', 'professional_function_catalog.md'), + ('differentialGeometryClassifyParametricCurve', 'Differential Geometry', '(value)', 'Classify a parametric curve by its standard Differential Geometry invariants.', 'professional_function_catalog.md'), + ('differentialGeometryClassifyParametricSurface', 'Differential Geometry', '(value)', 'Classify a parametric surface by its standard Differential Geometry invariants.', 'professional_function_catalog.md'), + ('differentialGeometryCombineCurvatureProfile', 'Differential Geometry', '(left, right)', 'Combine two curvature profile values with the natural operation for Differential Geometry.', 'professional_function_catalog.md'), + ('differentialGeometryCombineFrameField', 'Differential Geometry', '(left, right)', 'Combine two frame field values with the natural operation for Differential Geometry.', 'professional_function_catalog.md'), + ('differentialGeometryCombineGeodesicSample', 'Differential Geometry', '(left, right)', 'Combine two geodesic sample values with the natural operation for Differential Geometry.', 'professional_function_catalog.md'), + ('differentialGeometryCombineParametricCurve', 'Differential Geometry', '(left, right)', 'Combine two parametric curve values with the natural operation for Differential Geometry.', 'professional_function_catalog.md'), + ('differentialGeometryCombineParametricSurface', 'Differential Geometry', '(left, right)', 'Combine two parametric surface values with the natural operation for Differential Geometry.', 'professional_function_catalog.md'), + ('differentialGeometryCompareCurvatureProfile', 'Differential Geometry', '(left, right)', 'Compare two curvature profile values under the conventions of Differential Geometry.', 'professional_function_catalog.md'), + ('differentialGeometryCompareFrameField', 'Differential Geometry', '(left, right)', 'Compare two frame field values under the conventions of Differential Geometry.', 'professional_function_catalog.md'), + ('differentialGeometryCompareGeodesicSample', 'Differential Geometry', '(left, right)', 'Compare two geodesic sample values under the conventions of Differential Geometry.', 'professional_function_catalog.md'), + ('differentialGeometryCompareParametricCurve', 'Differential Geometry', '(left, right)', 'Compare two parametric curve values under the conventions of Differential Geometry.', 'professional_function_catalog.md'), + ('differentialGeometryCompareParametricSurface', 'Differential Geometry', '(left, right)', 'Compare two parametric surface values under the conventions of Differential Geometry.', 'professional_function_catalog.md'), + ('differentialGeometryComputeCurvatureProfile', 'Differential Geometry', '(value)', 'Compute the central numerical or symbolic data of a curvature profile.', 'professional_function_catalog.md'), + ('differentialGeometryComputeFrameField', 'Differential Geometry', '(value)', 'Compute the central numerical or symbolic data of a frame field.', 'professional_function_catalog.md'), + ('differentialGeometryComputeGeodesicSample', 'Differential Geometry', '(value)', 'Compute the central numerical or symbolic data of a geodesic sample.', 'professional_function_catalog.md'), + ('differentialGeometryComputeParametricCurve', 'Differential Geometry', '(value)', 'Compute the central numerical or symbolic data of a parametric curve.', 'professional_function_catalog.md'), + ('differentialGeometryComputeParametricSurface', 'Differential Geometry', '(value)', 'Compute the central numerical or symbolic data of a parametric surface.', 'professional_function_catalog.md'), + ('differentialGeometryConstructCurvatureProfile', 'Differential Geometry', '(*args)', 'Construct a curvature profile from explicit inputs for Differential Geometry.', 'professional_function_catalog.md'), + ('differentialGeometryConstructFrameField', 'Differential Geometry', '(*args)', 'Construct a frame field from explicit inputs for Differential Geometry.', 'professional_function_catalog.md'), + ('differentialGeometryConstructGeodesicSample', 'Differential Geometry', '(*args)', 'Construct a geodesic sample from explicit inputs for Differential Geometry.', 'professional_function_catalog.md'), + ('differentialGeometryConstructParametricCurve', 'Differential Geometry', '(*args)', 'Construct a parametric curve from explicit inputs for Differential Geometry.', 'professional_function_catalog.md'), + ('differentialGeometryConstructParametricSurface', 'Differential Geometry', '(*args)', 'Construct a parametric surface from explicit inputs for Differential Geometry.', 'professional_function_catalog.md'), + ('differentialGeometryDecomposeCurvatureProfile', 'Differential Geometry', '(value)', 'Decompose a curvature profile into simpler or canonical components.', 'professional_function_catalog.md'), + ('differentialGeometryDecomposeFrameField', 'Differential Geometry', '(value)', 'Decompose a frame field into simpler or canonical components.', 'professional_function_catalog.md'), + ('differentialGeometryDecomposeGeodesicSample', 'Differential Geometry', '(value)', 'Decompose a geodesic sample into simpler or canonical components.', 'professional_function_catalog.md'), + ('differentialGeometryDecomposeParametricCurve', 'Differential Geometry', '(value)', 'Decompose a parametric curve into simpler or canonical components.', 'professional_function_catalog.md'), + ('differentialGeometryDecomposeParametricSurface', 'Differential Geometry', '(value)', 'Decompose a parametric surface into simpler or canonical components.', 'professional_function_catalog.md'), + ('differentialGeometryDocumentCurvatureProfile', 'Differential Geometry', '(value)', 'Return a structured explanation of a curvature profile and related assumptions.', 'professional_function_catalog.md'), + ('differentialGeometryDocumentFrameField', 'Differential Geometry', '(value)', 'Return a structured explanation of a frame field and related assumptions.', 'professional_function_catalog.md'), + ('differentialGeometryDocumentGeodesicSample', 'Differential Geometry', '(value)', 'Return a structured explanation of a geodesic sample and related assumptions.', 'professional_function_catalog.md'), + ('differentialGeometryDocumentParametricCurve', 'Differential Geometry', '(value)', 'Return a structured explanation of a parametric curve and related assumptions.', 'professional_function_catalog.md'), + ('differentialGeometryDocumentParametricSurface', 'Differential Geometry', '(value)', 'Return a structured explanation of a parametric surface and related assumptions.', 'professional_function_catalog.md'), + ('differentialGeometryEnumerateCurvatureProfile', 'Differential Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a curvature profile.', 'professional_function_catalog.md'), + ('differentialGeometryEnumerateFrameField', 'Differential Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a frame field.', 'professional_function_catalog.md'), + ('differentialGeometryEnumerateGeodesicSample', 'Differential Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a geodesic sample.', 'professional_function_catalog.md'), + ('differentialGeometryEnumerateParametricCurve', 'Differential Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a parametric curve.', 'professional_function_catalog.md'), + ('differentialGeometryEnumerateParametricSurface', 'Differential Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a parametric surface.', 'professional_function_catalog.md'), + ('differentialGeometryEstimateCurvatureProfile', 'Differential Geometry', '(value, samples=None)', 'Estimate a curvature profile property from finite samples or approximations.', 'professional_function_catalog.md'), + ('differentialGeometryEstimateFrameField', 'Differential Geometry', '(value, samples=None)', 'Estimate a frame field property from finite samples or approximations.', 'professional_function_catalog.md'), + ('differentialGeometryEstimateGeodesicSample', 'Differential Geometry', '(value, samples=None)', 'Estimate a geodesic sample property from finite samples or approximations.', 'professional_function_catalog.md'), + ('differentialGeometryEstimateParametricCurve', 'Differential Geometry', '(value, samples=None)', 'Estimate a parametric curve property from finite samples or approximations.', 'professional_function_catalog.md'), + ('differentialGeometryEstimateParametricSurface', 'Differential Geometry', '(value, samples=None)', 'Estimate a parametric surface property from finite samples or approximations.', 'professional_function_catalog.md'), + ('differentialGeometryEvaluateCurvatureProfile', 'Differential Geometry', '(value, point=None)', 'Evaluate a curvature profile at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('differentialGeometryEvaluateFrameField', 'Differential Geometry', '(value, point=None)', 'Evaluate a frame field at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('differentialGeometryEvaluateGeodesicSample', 'Differential Geometry', '(value, point=None)', 'Evaluate a geodesic sample at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('differentialGeometryEvaluateParametricCurve', 'Differential Geometry', '(value, point=None)', 'Evaluate a parametric curve at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('differentialGeometryEvaluateParametricSurface', 'Differential Geometry', '(value, point=None)', 'Evaluate a parametric surface at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('differentialGeometryFormatCurvatureProfile', 'Differential Geometry', '(value)', 'Format a curvature profile for deterministic user-facing output.', 'professional_function_catalog.md'), + ('differentialGeometryFormatFrameField', 'Differential Geometry', '(value)', 'Format a frame field for deterministic user-facing output.', 'professional_function_catalog.md'), + ('differentialGeometryFormatGeodesicSample', 'Differential Geometry', '(value)', 'Format a geodesic sample for deterministic user-facing output.', 'professional_function_catalog.md'), + ('differentialGeometryFormatParametricCurve', 'Differential Geometry', '(value)', 'Format a parametric curve for deterministic user-facing output.', 'professional_function_catalog.md'), + ('differentialGeometryFormatParametricSurface', 'Differential Geometry', '(value)', 'Format a parametric surface for deterministic user-facing output.', 'professional_function_catalog.md'), + ('differentialGeometryGenerateExampleCurvatureProfile', 'Differential Geometry', '(size=3)', 'Generate a small documented example of a curvature profile.', 'professional_function_catalog.md'), + ('differentialGeometryGenerateExampleFrameField', 'Differential Geometry', '(size=3)', 'Generate a small documented example of a frame field.', 'professional_function_catalog.md'), + ('differentialGeometryGenerateExampleGeodesicSample', 'Differential Geometry', '(size=3)', 'Generate a small documented example of a geodesic sample.', 'professional_function_catalog.md'), + ('differentialGeometryGenerateExampleParametricCurve', 'Differential Geometry', '(size=3)', 'Generate a small documented example of a parametric curve.', 'professional_function_catalog.md'), + ('differentialGeometryGenerateExampleParametricSurface', 'Differential Geometry', '(size=3)', 'Generate a small documented example of a parametric surface.', 'professional_function_catalog.md'), + ('differentialGeometryNormalizeCurvatureProfile', 'Differential Geometry', '(value)', 'Normalize a curvature profile into the standard Differential Geometry representation.', 'professional_function_catalog.md'), + ('differentialGeometryNormalizeFrameField', 'Differential Geometry', '(value)', 'Normalize a frame field into the standard Differential Geometry representation.', 'professional_function_catalog.md'), + ('differentialGeometryNormalizeGeodesicSample', 'Differential Geometry', '(value)', 'Normalize a geodesic sample into the standard Differential Geometry representation.', 'professional_function_catalog.md'), + ('differentialGeometryNormalizeParametricCurve', 'Differential Geometry', '(value)', 'Normalize a parametric curve into the standard Differential Geometry representation.', 'professional_function_catalog.md'), + ('differentialGeometryNormalizeParametricSurface', 'Differential Geometry', '(value)', 'Normalize a parametric surface into the standard Differential Geometry representation.', 'professional_function_catalog.md'), + ('differentialGeometryParseCurvatureProfile', 'Differential Geometry', '(text)', 'Parse a text or structured value into a curvature profile.', 'professional_function_catalog.md'), + ('differentialGeometryParseFrameField', 'Differential Geometry', '(text)', 'Parse a text or structured value into a frame field.', 'professional_function_catalog.md'), + ('differentialGeometryParseGeodesicSample', 'Differential Geometry', '(text)', 'Parse a text or structured value into a geodesic sample.', 'professional_function_catalog.md'), + ('differentialGeometryParseParametricCurve', 'Differential Geometry', '(text)', 'Parse a text or structured value into a parametric curve.', 'professional_function_catalog.md'), + ('differentialGeometryParseParametricSurface', 'Differential Geometry', '(text)', 'Parse a text or structured value into a parametric surface.', 'professional_function_catalog.md'), + ('differentialGeometrySimplifyCurvatureProfile', 'Differential Geometry', '(value)', 'Simplify a curvature profile without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('differentialGeometrySimplifyFrameField', 'Differential Geometry', '(value)', 'Simplify a frame field without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('differentialGeometrySimplifyGeodesicSample', 'Differential Geometry', '(value)', 'Simplify a geodesic sample without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('differentialGeometrySimplifyParametricCurve', 'Differential Geometry', '(value)', 'Simplify a parametric curve without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('differentialGeometrySimplifyParametricSurface', 'Differential Geometry', '(value)', 'Simplify a parametric surface without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('differentialGeometryTestEquivalenceCurvatureProfile', 'Differential Geometry', '(left, right)', 'Test whether two curvature profile values are equivalent in Differential Geometry.', 'professional_function_catalog.md'), + ('differentialGeometryTestEquivalenceFrameField', 'Differential Geometry', '(left, right)', 'Test whether two frame field values are equivalent in Differential Geometry.', 'professional_function_catalog.md'), + ('differentialGeometryTestEquivalenceGeodesicSample', 'Differential Geometry', '(left, right)', 'Test whether two geodesic sample values are equivalent in Differential Geometry.', 'professional_function_catalog.md'), + ('differentialGeometryTestEquivalenceParametricCurve', 'Differential Geometry', '(left, right)', 'Test whether two parametric curve values are equivalent in Differential Geometry.', 'professional_function_catalog.md'), + ('differentialGeometryTestEquivalenceParametricSurface', 'Differential Geometry', '(left, right)', 'Test whether two parametric surface values are equivalent in Differential Geometry.', 'professional_function_catalog.md'), + ('differentialGeometryTransformCurvatureProfile', 'Differential Geometry', '(value, mapping)', 'Transform a curvature profile through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('differentialGeometryTransformFrameField', 'Differential Geometry', '(value, mapping)', 'Transform a frame field through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('differentialGeometryTransformGeodesicSample', 'Differential Geometry', '(value, mapping)', 'Transform a geodesic sample through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('differentialGeometryTransformParametricCurve', 'Differential Geometry', '(value, mapping)', 'Transform a parametric curve through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('differentialGeometryTransformParametricSurface', 'Differential Geometry', '(value, mapping)', 'Transform a parametric surface through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('differentialGeometryValidateCurvatureProfile', 'Differential Geometry', '(value)', 'Validate the curvature profile representation and domain rules for Differential Geometry.', 'professional_function_catalog.md'), + ('differentialGeometryValidateFrameField', 'Differential Geometry', '(value)', 'Validate the frame field representation and domain rules for Differential Geometry.', 'professional_function_catalog.md'), + ('differentialGeometryValidateGeodesicSample', 'Differential Geometry', '(value)', 'Validate the geodesic sample representation and domain rules for Differential Geometry.', 'professional_function_catalog.md'), + ('differentialGeometryValidateParametricCurve', 'Differential Geometry', '(value)', 'Validate the parametric curve representation and domain rules for Differential Geometry.', 'professional_function_catalog.md'), + ('differentialGeometryValidateParametricSurface', 'Differential Geometry', '(value)', 'Validate the parametric surface representation and domain rules for Differential Geometry.', 'professional_function_catalog.md'), + ('firstFundamentalForm', 'Differential Geometry', '(surface, u, v)', 'Planned roadmap function for Differential Geometry from upcoming.md.', 'upcoming.md'), + ('geodesicStep', 'Differential Geometry', '(surface, point, direction, step)', 'Planned roadmap function for Differential Geometry from upcoming.md.', 'upcoming.md'), + ('surfaceNormal', 'Differential Geometry', '(surface, u, v)', 'Planned roadmap function for Differential Geometry from upcoming.md.', 'upcoming.md'), + ('torsion', 'Differential Geometry', '(curve, t)', 'Planned roadmap function for Differential Geometry from upcoming.md.', 'upcoming.md'), + ('criticalValues', 'Differential Topology', '(f, domainPoints)', 'Planned roadmap function for Differential Topology from upcoming.md.', 'upcoming.md'), + ('degreeMapCircle', 'Differential Topology', '(mapSamples)', 'Planned roadmap function for Differential Topology from upcoming.md.', 'upcoming.md'), + ('differentialTopologyApproximateCriticalPoint', 'Differential Topology', '(value, tolerance=1e-9)', 'Approximate a critical point with explicit tolerance controls.', 'professional_function_catalog.md'), + ('differentialTopologyApproximateDiffeomorphism', 'Differential Topology', '(value, tolerance=1e-9)', 'Approximate a diffeomorphism with explicit tolerance controls.', 'professional_function_catalog.md'), + ('differentialTopologyApproximateRegularValue', 'Differential Topology', '(value, tolerance=1e-9)', 'Approximate a regular value with explicit tolerance controls.', 'professional_function_catalog.md'), + ('differentialTopologyApproximateSmoothMap', 'Differential Topology', '(value, tolerance=1e-9)', 'Approximate a smooth map with explicit tolerance controls.', 'professional_function_catalog.md'), + ('differentialTopologyApproximateTransversalitySample', 'Differential Topology', '(value, tolerance=1e-9)', 'Approximate a transversality sample with explicit tolerance controls.', 'professional_function_catalog.md'), + ('differentialTopologyCanonicalizeCriticalPoint', 'Differential Topology', '(value)', 'Canonicalize a critical point so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('differentialTopologyCanonicalizeDiffeomorphism', 'Differential Topology', '(value)', 'Canonicalize a diffeomorphism so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('differentialTopologyCanonicalizeRegularValue', 'Differential Topology', '(value)', 'Canonicalize a regular value so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('differentialTopologyCanonicalizeSmoothMap', 'Differential Topology', '(value)', 'Canonicalize a smooth map so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('differentialTopologyCanonicalizeTransversalitySample', 'Differential Topology', '(value)', 'Canonicalize a transversality sample so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('differentialTopologyClassifyCriticalPoint', 'Differential Topology', '(value)', 'Classify a critical point by its standard Differential Topology invariants.', 'professional_function_catalog.md'), + ('differentialTopologyClassifyDiffeomorphism', 'Differential Topology', '(value)', 'Classify a diffeomorphism by its standard Differential Topology invariants.', 'professional_function_catalog.md'), + ('differentialTopologyClassifyRegularValue', 'Differential Topology', '(value)', 'Classify a regular value by its standard Differential Topology invariants.', 'professional_function_catalog.md'), + ('differentialTopologyClassifySmoothMap', 'Differential Topology', '(value)', 'Classify a smooth map by its standard Differential Topology invariants.', 'professional_function_catalog.md'), + ('differentialTopologyClassifyTransversalitySample', 'Differential Topology', '(value)', 'Classify a transversality sample by its standard Differential Topology invariants.', 'professional_function_catalog.md'), + ('differentialTopologyCombineCriticalPoint', 'Differential Topology', '(left, right)', 'Combine two critical point values with the natural operation for Differential Topology.', 'professional_function_catalog.md'), + ('differentialTopologyCombineDiffeomorphism', 'Differential Topology', '(left, right)', 'Combine two diffeomorphism values with the natural operation for Differential Topology.', 'professional_function_catalog.md'), + ('differentialTopologyCombineRegularValue', 'Differential Topology', '(left, right)', 'Combine two regular value values with the natural operation for Differential Topology.', 'professional_function_catalog.md'), + ('differentialTopologyCombineSmoothMap', 'Differential Topology', '(left, right)', 'Combine two smooth map values with the natural operation for Differential Topology.', 'professional_function_catalog.md'), + ('differentialTopologyCombineTransversalitySample', 'Differential Topology', '(left, right)', 'Combine two transversality sample values with the natural operation for Differential Topology.', 'professional_function_catalog.md'), + ('differentialTopologyCompareCriticalPoint', 'Differential Topology', '(left, right)', 'Compare two critical point values under the conventions of Differential Topology.', 'professional_function_catalog.md'), + ('differentialTopologyCompareDiffeomorphism', 'Differential Topology', '(left, right)', 'Compare two diffeomorphism values under the conventions of Differential Topology.', 'professional_function_catalog.md'), + ('differentialTopologyCompareRegularValue', 'Differential Topology', '(left, right)', 'Compare two regular value values under the conventions of Differential Topology.', 'professional_function_catalog.md'), + ('differentialTopologyCompareSmoothMap', 'Differential Topology', '(left, right)', 'Compare two smooth map values under the conventions of Differential Topology.', 'professional_function_catalog.md'), + ('differentialTopologyCompareTransversalitySample', 'Differential Topology', '(left, right)', 'Compare two transversality sample values under the conventions of Differential Topology.', 'professional_function_catalog.md'), + ('differentialTopologyComputeCriticalPoint', 'Differential Topology', '(value)', 'Compute the central numerical or symbolic data of a critical point.', 'professional_function_catalog.md'), + ('differentialTopologyComputeDiffeomorphism', 'Differential Topology', '(value)', 'Compute the central numerical or symbolic data of a diffeomorphism.', 'professional_function_catalog.md'), + ('differentialTopologyComputeRegularValue', 'Differential Topology', '(value)', 'Compute the central numerical or symbolic data of a regular value.', 'professional_function_catalog.md'), + ('differentialTopologyComputeSmoothMap', 'Differential Topology', '(value)', 'Compute the central numerical or symbolic data of a smooth map.', 'professional_function_catalog.md'), + ('differentialTopologyComputeTransversalitySample', 'Differential Topology', '(value)', 'Compute the central numerical or symbolic data of a transversality sample.', 'professional_function_catalog.md'), + ('differentialTopologyConstructCriticalPoint', 'Differential Topology', '(*args)', 'Construct a critical point from explicit inputs for Differential Topology.', 'professional_function_catalog.md'), + ('differentialTopologyConstructDiffeomorphism', 'Differential Topology', '(*args)', 'Construct a diffeomorphism from explicit inputs for Differential Topology.', 'professional_function_catalog.md'), + ('differentialTopologyConstructRegularValue', 'Differential Topology', '(*args)', 'Construct a regular value from explicit inputs for Differential Topology.', 'professional_function_catalog.md'), + ('differentialTopologyConstructSmoothMap', 'Differential Topology', '(*args)', 'Construct a smooth map from explicit inputs for Differential Topology.', 'professional_function_catalog.md'), + ('differentialTopologyConstructTransversalitySample', 'Differential Topology', '(*args)', 'Construct a transversality sample from explicit inputs for Differential Topology.', 'professional_function_catalog.md'), + ('differentialTopologyDecomposeCriticalPoint', 'Differential Topology', '(value)', 'Decompose a critical point into simpler or canonical components.', 'professional_function_catalog.md'), + ('differentialTopologyDecomposeDiffeomorphism', 'Differential Topology', '(value)', 'Decompose a diffeomorphism into simpler or canonical components.', 'professional_function_catalog.md'), + ('differentialTopologyDecomposeRegularValue', 'Differential Topology', '(value)', 'Decompose a regular value into simpler or canonical components.', 'professional_function_catalog.md'), + ('differentialTopologyDecomposeSmoothMap', 'Differential Topology', '(value)', 'Decompose a smooth map into simpler or canonical components.', 'professional_function_catalog.md'), + ('differentialTopologyDecomposeTransversalitySample', 'Differential Topology', '(value)', 'Decompose a transversality sample into simpler or canonical components.', 'professional_function_catalog.md'), + ('differentialTopologyDocumentCriticalPoint', 'Differential Topology', '(value)', 'Return a structured explanation of a critical point and related assumptions.', 'professional_function_catalog.md'), + ('differentialTopologyDocumentDiffeomorphism', 'Differential Topology', '(value)', 'Return a structured explanation of a diffeomorphism and related assumptions.', 'professional_function_catalog.md'), + ('differentialTopologyDocumentRegularValue', 'Differential Topology', '(value)', 'Return a structured explanation of a regular value and related assumptions.', 'professional_function_catalog.md'), + ('differentialTopologyDocumentSmoothMap', 'Differential Topology', '(value)', 'Return a structured explanation of a smooth map and related assumptions.', 'professional_function_catalog.md'), + ('differentialTopologyDocumentTransversalitySample', 'Differential Topology', '(value)', 'Return a structured explanation of a transversality sample and related assumptions.', 'professional_function_catalog.md'), + ('differentialTopologyEnumerateCriticalPoint', 'Differential Topology', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a critical point.', 'professional_function_catalog.md'), + ('differentialTopologyEnumerateDiffeomorphism', 'Differential Topology', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a diffeomorphism.', 'professional_function_catalog.md'), + ('differentialTopologyEnumerateRegularValue', 'Differential Topology', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a regular value.', 'professional_function_catalog.md'), + ('differentialTopologyEnumerateSmoothMap', 'Differential Topology', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a smooth map.', 'professional_function_catalog.md'), + ('differentialTopologyEnumerateTransversalitySample', 'Differential Topology', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a transversality sample.', 'professional_function_catalog.md'), + ('differentialTopologyEstimateCriticalPoint', 'Differential Topology', '(value, samples=None)', 'Estimate a critical point property from finite samples or approximations.', 'professional_function_catalog.md'), + ('differentialTopologyEstimateDiffeomorphism', 'Differential Topology', '(value, samples=None)', 'Estimate a diffeomorphism property from finite samples or approximations.', 'professional_function_catalog.md'), + ('differentialTopologyEstimateRegularValue', 'Differential Topology', '(value, samples=None)', 'Estimate a regular value property from finite samples or approximations.', 'professional_function_catalog.md'), + ('differentialTopologyEstimateSmoothMap', 'Differential Topology', '(value, samples=None)', 'Estimate a smooth map property from finite samples or approximations.', 'professional_function_catalog.md'), + ('differentialTopologyEstimateTransversalitySample', 'Differential Topology', '(value, samples=None)', 'Estimate a transversality sample property from finite samples or approximations.', 'professional_function_catalog.md'), + ('differentialTopologyEvaluateCriticalPoint', 'Differential Topology', '(value, point=None)', 'Evaluate a critical point at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('differentialTopologyEvaluateDiffeomorphism', 'Differential Topology', '(value, point=None)', 'Evaluate a diffeomorphism at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('differentialTopologyEvaluateRegularValue', 'Differential Topology', '(value, point=None)', 'Evaluate a regular value at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('differentialTopologyEvaluateSmoothMap', 'Differential Topology', '(value, point=None)', 'Evaluate a smooth map at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('differentialTopologyEvaluateTransversalitySample', 'Differential Topology', '(value, point=None)', 'Evaluate a transversality sample at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('differentialTopologyFormatCriticalPoint', 'Differential Topology', '(value)', 'Format a critical point for deterministic user-facing output.', 'professional_function_catalog.md'), + ('differentialTopologyFormatDiffeomorphism', 'Differential Topology', '(value)', 'Format a diffeomorphism for deterministic user-facing output.', 'professional_function_catalog.md'), + ('differentialTopologyFormatRegularValue', 'Differential Topology', '(value)', 'Format a regular value for deterministic user-facing output.', 'professional_function_catalog.md'), + ('differentialTopologyFormatSmoothMap', 'Differential Topology', '(value)', 'Format a smooth map for deterministic user-facing output.', 'professional_function_catalog.md'), + ('differentialTopologyFormatTransversalitySample', 'Differential Topology', '(value)', 'Format a transversality sample for deterministic user-facing output.', 'professional_function_catalog.md'), + ('differentialTopologyGenerateExampleCriticalPoint', 'Differential Topology', '(size=3)', 'Generate a small documented example of a critical point.', 'professional_function_catalog.md'), + ('differentialTopologyGenerateExampleDiffeomorphism', 'Differential Topology', '(size=3)', 'Generate a small documented example of a diffeomorphism.', 'professional_function_catalog.md'), + ('differentialTopologyGenerateExampleRegularValue', 'Differential Topology', '(size=3)', 'Generate a small documented example of a regular value.', 'professional_function_catalog.md'), + ('differentialTopologyGenerateExampleSmoothMap', 'Differential Topology', '(size=3)', 'Generate a small documented example of a smooth map.', 'professional_function_catalog.md'), + ('differentialTopologyGenerateExampleTransversalitySample', 'Differential Topology', '(size=3)', 'Generate a small documented example of a transversality sample.', 'professional_function_catalog.md'), + ('differentialTopologyNormalizeCriticalPoint', 'Differential Topology', '(value)', 'Normalize a critical point into the standard Differential Topology representation.', 'professional_function_catalog.md'), + ('differentialTopologyNormalizeDiffeomorphism', 'Differential Topology', '(value)', 'Normalize a diffeomorphism into the standard Differential Topology representation.', 'professional_function_catalog.md'), + ('differentialTopologyNormalizeRegularValue', 'Differential Topology', '(value)', 'Normalize a regular value into the standard Differential Topology representation.', 'professional_function_catalog.md'), + ('differentialTopologyNormalizeSmoothMap', 'Differential Topology', '(value)', 'Normalize a smooth map into the standard Differential Topology representation.', 'professional_function_catalog.md'), + ('differentialTopologyNormalizeTransversalitySample', 'Differential Topology', '(value)', 'Normalize a transversality sample into the standard Differential Topology representation.', 'professional_function_catalog.md'), + ('differentialTopologyParseCriticalPoint', 'Differential Topology', '(text)', 'Parse a text or structured value into a critical point.', 'professional_function_catalog.md'), + ('differentialTopologyParseDiffeomorphism', 'Differential Topology', '(text)', 'Parse a text or structured value into a diffeomorphism.', 'professional_function_catalog.md'), + ('differentialTopologyParseRegularValue', 'Differential Topology', '(text)', 'Parse a text or structured value into a regular value.', 'professional_function_catalog.md'), + ('differentialTopologyParseSmoothMap', 'Differential Topology', '(text)', 'Parse a text or structured value into a smooth map.', 'professional_function_catalog.md'), + ('differentialTopologyParseTransversalitySample', 'Differential Topology', '(text)', 'Parse a text or structured value into a transversality sample.', 'professional_function_catalog.md'), + ('differentialTopologySimplifyCriticalPoint', 'Differential Topology', '(value)', 'Simplify a critical point without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('differentialTopologySimplifyDiffeomorphism', 'Differential Topology', '(value)', 'Simplify a diffeomorphism without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('differentialTopologySimplifyRegularValue', 'Differential Topology', '(value)', 'Simplify a regular value without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('differentialTopologySimplifySmoothMap', 'Differential Topology', '(value)', 'Simplify a smooth map without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('differentialTopologySimplifyTransversalitySample', 'Differential Topology', '(value)', 'Simplify a transversality sample without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('differentialTopologyTestEquivalenceCriticalPoint', 'Differential Topology', '(left, right)', 'Test whether two critical point values are equivalent in Differential Topology.', 'professional_function_catalog.md'), + ('differentialTopologyTestEquivalenceDiffeomorphism', 'Differential Topology', '(left, right)', 'Test whether two diffeomorphism values are equivalent in Differential Topology.', 'professional_function_catalog.md'), + ('differentialTopologyTestEquivalenceRegularValue', 'Differential Topology', '(left, right)', 'Test whether two regular value values are equivalent in Differential Topology.', 'professional_function_catalog.md'), + ('differentialTopologyTestEquivalenceSmoothMap', 'Differential Topology', '(left, right)', 'Test whether two smooth map values are equivalent in Differential Topology.', 'professional_function_catalog.md'), + ('differentialTopologyTestEquivalenceTransversalitySample', 'Differential Topology', '(left, right)', 'Test whether two transversality sample values are equivalent in Differential Topology.', 'professional_function_catalog.md'), + ('differentialTopologyTransformCriticalPoint', 'Differential Topology', '(value, mapping)', 'Transform a critical point through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('differentialTopologyTransformDiffeomorphism', 'Differential Topology', '(value, mapping)', 'Transform a diffeomorphism through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('differentialTopologyTransformRegularValue', 'Differential Topology', '(value, mapping)', 'Transform a regular value through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('differentialTopologyTransformSmoothMap', 'Differential Topology', '(value, mapping)', 'Transform a smooth map through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('differentialTopologyTransformTransversalitySample', 'Differential Topology', '(value, mapping)', 'Transform a transversality sample through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('differentialTopologyValidateCriticalPoint', 'Differential Topology', '(value)', 'Validate the critical point representation and domain rules for Differential Topology.', 'professional_function_catalog.md'), + ('differentialTopologyValidateDiffeomorphism', 'Differential Topology', '(value)', 'Validate the diffeomorphism representation and domain rules for Differential Topology.', 'professional_function_catalog.md'), + ('differentialTopologyValidateRegularValue', 'Differential Topology', '(value)', 'Validate the regular value representation and domain rules for Differential Topology.', 'professional_function_catalog.md'), + ('differentialTopologyValidateSmoothMap', 'Differential Topology', '(value)', 'Validate the smooth map representation and domain rules for Differential Topology.', 'professional_function_catalog.md'), + ('differentialTopologyValidateTransversalitySample', 'Differential Topology', '(value)', 'Validate the transversality sample representation and domain rules for Differential Topology.', 'professional_function_catalog.md'), + ('isImmersion', 'Differential Topology', '(f, point)', 'Planned roadmap function for Differential Topology from upcoming.md.', 'upcoming.md'), + ('isRegularValue', 'Differential Topology', '(f, value, candidatePreimages)', 'Planned roadmap function for Differential Topology from upcoming.md.', 'upcoming.md'), + ('isSubmersion', 'Differential Topology', '(f, point)', 'Planned roadmap function for Differential Topology from upcoming.md.', 'upcoming.md'), + ('jacobianRank', 'Differential Topology', '(f, point)', 'Planned roadmap function for Differential Topology from upcoming.md.', 'upcoming.md'), + ('localDiffeomorphism', 'Differential Topology', '(f, point)', 'Planned roadmap function for Differential Topology from upcoming.md.', 'upcoming.md'), + ('sardSampleCheck', 'Differential Topology', '(f, domainPoints)', 'Planned roadmap function for Differential Topology from upcoming.md.', 'upcoming.md'), + ('approximationError', 'Diophantine Approximation', '(x, numerator, denominator)', 'Planned roadmap function for Diophantine Approximation from upcoming.md.', 'upcoming.md'), + ('bestRationalApproximation', 'Diophantine Approximation', '(x, maxDenominator)', 'Planned roadmap function for Diophantine Approximation from upcoming.md.', 'upcoming.md'), + ('continuedFraction', 'Diophantine Approximation', '(x, terms)', 'Planned roadmap function for Diophantine Approximation from upcoming.md.', 'upcoming.md'), + ('continuedFractionConvergents', 'Diophantine Approximation', '(coefficients)', 'Planned roadmap function for Diophantine Approximation from upcoming.md.', 'upcoming.md'), + ('diophantineApproximationApproximateContinuedFraction', 'Diophantine Approximation', '(value, tolerance=1e-9)', 'Approximate a continued fraction with explicit tolerance controls.', 'professional_function_catalog.md'), + ('diophantineApproximationApproximateConvergent', 'Diophantine Approximation', '(value, tolerance=1e-9)', 'Approximate a convergent with explicit tolerance controls.', 'professional_function_catalog.md'), + ('diophantineApproximationApproximateFareySequence', 'Diophantine Approximation', '(value, tolerance=1e-9)', 'Approximate a Farey sequence with explicit tolerance controls.', 'professional_function_catalog.md'), + ('diophantineApproximationApproximatePellEquation', 'Diophantine Approximation', '(value, tolerance=1e-9)', 'Approximate a Pell equation with explicit tolerance controls.', 'professional_function_catalog.md'), + ('diophantineApproximationApproximateRationalApproximation', 'Diophantine Approximation', '(value, tolerance=1e-9)', 'Approximate a rational approximation with explicit tolerance controls.', 'professional_function_catalog.md'), + ('diophantineApproximationCanonicalizeContinuedFraction', 'Diophantine Approximation', '(value)', 'Canonicalize a continued fraction so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('diophantineApproximationCanonicalizeConvergent', 'Diophantine Approximation', '(value)', 'Canonicalize a convergent so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('diophantineApproximationCanonicalizeFareySequence', 'Diophantine Approximation', '(value)', 'Canonicalize a Farey sequence so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('diophantineApproximationCanonicalizePellEquation', 'Diophantine Approximation', '(value)', 'Canonicalize a Pell equation so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('diophantineApproximationCanonicalizeRationalApproximation', 'Diophantine Approximation', '(value)', 'Canonicalize a rational approximation so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('diophantineApproximationClassifyContinuedFraction', 'Diophantine Approximation', '(value)', 'Classify a continued fraction by its standard Diophantine Approximation invariants.', 'professional_function_catalog.md'), + ('diophantineApproximationClassifyConvergent', 'Diophantine Approximation', '(value)', 'Classify a convergent by its standard Diophantine Approximation invariants.', 'professional_function_catalog.md'), + ('diophantineApproximationClassifyFareySequence', 'Diophantine Approximation', '(value)', 'Classify a Farey sequence by its standard Diophantine Approximation invariants.', 'professional_function_catalog.md'), + ('diophantineApproximationClassifyPellEquation', 'Diophantine Approximation', '(value)', 'Classify a Pell equation by its standard Diophantine Approximation invariants.', 'professional_function_catalog.md'), + ('diophantineApproximationClassifyRationalApproximation', 'Diophantine Approximation', '(value)', 'Classify a rational approximation by its standard Diophantine Approximation invariants.', 'professional_function_catalog.md'), + ('diophantineApproximationCombineContinuedFraction', 'Diophantine Approximation', '(left, right)', 'Combine two continued fraction values with the natural operation for Diophantine Approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationCombineConvergent', 'Diophantine Approximation', '(left, right)', 'Combine two convergent values with the natural operation for Diophantine Approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationCombineFareySequence', 'Diophantine Approximation', '(left, right)', 'Combine two Farey sequence values with the natural operation for Diophantine Approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationCombinePellEquation', 'Diophantine Approximation', '(left, right)', 'Combine two Pell equation values with the natural operation for Diophantine Approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationCombineRationalApproximation', 'Diophantine Approximation', '(left, right)', 'Combine two rational approximation values with the natural operation for Diophantine Approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationCompareContinuedFraction', 'Diophantine Approximation', '(left, right)', 'Compare two continued fraction values under the conventions of Diophantine Approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationCompareConvergent', 'Diophantine Approximation', '(left, right)', 'Compare two convergent values under the conventions of Diophantine Approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationCompareFareySequence', 'Diophantine Approximation', '(left, right)', 'Compare two Farey sequence values under the conventions of Diophantine Approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationComparePellEquation', 'Diophantine Approximation', '(left, right)', 'Compare two Pell equation values under the conventions of Diophantine Approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationCompareRationalApproximation', 'Diophantine Approximation', '(left, right)', 'Compare two rational approximation values under the conventions of Diophantine Approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationComputeContinuedFraction', 'Diophantine Approximation', '(value)', 'Compute the central numerical or symbolic data of a continued fraction.', 'professional_function_catalog.md'), + ('diophantineApproximationComputeConvergent', 'Diophantine Approximation', '(value)', 'Compute the central numerical or symbolic data of a convergent.', 'professional_function_catalog.md'), + ('diophantineApproximationComputeFareySequence', 'Diophantine Approximation', '(value)', 'Compute the central numerical or symbolic data of a Farey sequence.', 'professional_function_catalog.md'), + ('diophantineApproximationComputePellEquation', 'Diophantine Approximation', '(value)', 'Compute the central numerical or symbolic data of a Pell equation.', 'professional_function_catalog.md'), + ('diophantineApproximationComputeRationalApproximation', 'Diophantine Approximation', '(value)', 'Compute the central numerical or symbolic data of a rational approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationConstructContinuedFraction', 'Diophantine Approximation', '(*args)', 'Construct a continued fraction from explicit inputs for Diophantine Approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationConstructConvergent', 'Diophantine Approximation', '(*args)', 'Construct a convergent from explicit inputs for Diophantine Approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationConstructFareySequence', 'Diophantine Approximation', '(*args)', 'Construct a Farey sequence from explicit inputs for Diophantine Approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationConstructPellEquation', 'Diophantine Approximation', '(*args)', 'Construct a Pell equation from explicit inputs for Diophantine Approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationConstructRationalApproximation', 'Diophantine Approximation', '(*args)', 'Construct a rational approximation from explicit inputs for Diophantine Approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationDecomposeContinuedFraction', 'Diophantine Approximation', '(value)', 'Decompose a continued fraction into simpler or canonical components.', 'professional_function_catalog.md'), + ('diophantineApproximationDecomposeConvergent', 'Diophantine Approximation', '(value)', 'Decompose a convergent into simpler or canonical components.', 'professional_function_catalog.md'), + ('diophantineApproximationDecomposeFareySequence', 'Diophantine Approximation', '(value)', 'Decompose a Farey sequence into simpler or canonical components.', 'professional_function_catalog.md'), + ('diophantineApproximationDecomposePellEquation', 'Diophantine Approximation', '(value)', 'Decompose a Pell equation into simpler or canonical components.', 'professional_function_catalog.md'), + ('diophantineApproximationDecomposeRationalApproximation', 'Diophantine Approximation', '(value)', 'Decompose a rational approximation into simpler or canonical components.', 'professional_function_catalog.md'), + ('diophantineApproximationDocumentContinuedFraction', 'Diophantine Approximation', '(value)', 'Return a structured explanation of a continued fraction and related assumptions.', 'professional_function_catalog.md'), + ('diophantineApproximationDocumentConvergent', 'Diophantine Approximation', '(value)', 'Return a structured explanation of a convergent and related assumptions.', 'professional_function_catalog.md'), + ('diophantineApproximationDocumentFareySequence', 'Diophantine Approximation', '(value)', 'Return a structured explanation of a Farey sequence and related assumptions.', 'professional_function_catalog.md'), + ('diophantineApproximationDocumentPellEquation', 'Diophantine Approximation', '(value)', 'Return a structured explanation of a Pell equation and related assumptions.', 'professional_function_catalog.md'), + ('diophantineApproximationDocumentRationalApproximation', 'Diophantine Approximation', '(value)', 'Return a structured explanation of a rational approximation and related assumptions.', 'professional_function_catalog.md'), + ('diophantineApproximationEnumerateContinuedFraction', 'Diophantine Approximation', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a continued fraction.', 'professional_function_catalog.md'), + ('diophantineApproximationEnumerateConvergent', 'Diophantine Approximation', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a convergent.', 'professional_function_catalog.md'), + ('diophantineApproximationEnumerateFareySequence', 'Diophantine Approximation', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a Farey sequence.', 'professional_function_catalog.md'), + ('diophantineApproximationEnumeratePellEquation', 'Diophantine Approximation', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a Pell equation.', 'professional_function_catalog.md'), + ('diophantineApproximationEnumerateRationalApproximation', 'Diophantine Approximation', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a rational approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationEstimateContinuedFraction', 'Diophantine Approximation', '(value, samples=None)', 'Estimate a continued fraction property from finite samples or approximations.', 'professional_function_catalog.md'), + ('diophantineApproximationEstimateConvergent', 'Diophantine Approximation', '(value, samples=None)', 'Estimate a convergent property from finite samples or approximations.', 'professional_function_catalog.md'), + ('diophantineApproximationEstimateFareySequence', 'Diophantine Approximation', '(value, samples=None)', 'Estimate a Farey sequence property from finite samples or approximations.', 'professional_function_catalog.md'), + ('diophantineApproximationEstimatePellEquation', 'Diophantine Approximation', '(value, samples=None)', 'Estimate a Pell equation property from finite samples or approximations.', 'professional_function_catalog.md'), + ('diophantineApproximationEstimateRationalApproximation', 'Diophantine Approximation', '(value, samples=None)', 'Estimate a rational approximation property from finite samples or approximations.', 'professional_function_catalog.md'), + ('diophantineApproximationEvaluateContinuedFraction', 'Diophantine Approximation', '(value, point=None)', 'Evaluate a continued fraction at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('diophantineApproximationEvaluateConvergent', 'Diophantine Approximation', '(value, point=None)', 'Evaluate a convergent at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('diophantineApproximationEvaluateFareySequence', 'Diophantine Approximation', '(value, point=None)', 'Evaluate a Farey sequence at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('diophantineApproximationEvaluatePellEquation', 'Diophantine Approximation', '(value, point=None)', 'Evaluate a Pell equation at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('diophantineApproximationEvaluateRationalApproximation', 'Diophantine Approximation', '(value, point=None)', 'Evaluate a rational approximation at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('diophantineApproximationFormatContinuedFraction', 'Diophantine Approximation', '(value)', 'Format a continued fraction for deterministic user-facing output.', 'professional_function_catalog.md'), + ('diophantineApproximationFormatConvergent', 'Diophantine Approximation', '(value)', 'Format a convergent for deterministic user-facing output.', 'professional_function_catalog.md'), + ('diophantineApproximationFormatFareySequence', 'Diophantine Approximation', '(value)', 'Format a Farey sequence for deterministic user-facing output.', 'professional_function_catalog.md'), + ('diophantineApproximationFormatPellEquation', 'Diophantine Approximation', '(value)', 'Format a Pell equation for deterministic user-facing output.', 'professional_function_catalog.md'), + ('diophantineApproximationFormatRationalApproximation', 'Diophantine Approximation', '(value)', 'Format a rational approximation for deterministic user-facing output.', 'professional_function_catalog.md'), + ('diophantineApproximationGenerateExampleContinuedFraction', 'Diophantine Approximation', '(size=3)', 'Generate a small documented example of a continued fraction.', 'professional_function_catalog.md'), + ('diophantineApproximationGenerateExampleConvergent', 'Diophantine Approximation', '(size=3)', 'Generate a small documented example of a convergent.', 'professional_function_catalog.md'), + ('diophantineApproximationGenerateExampleFareySequence', 'Diophantine Approximation', '(size=3)', 'Generate a small documented example of a Farey sequence.', 'professional_function_catalog.md'), + ('diophantineApproximationGenerateExamplePellEquation', 'Diophantine Approximation', '(size=3)', 'Generate a small documented example of a Pell equation.', 'professional_function_catalog.md'), + ('diophantineApproximationGenerateExampleRationalApproximation', 'Diophantine Approximation', '(size=3)', 'Generate a small documented example of a rational approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationNormalizeContinuedFraction', 'Diophantine Approximation', '(value)', 'Normalize a continued fraction into the standard Diophantine Approximation representation.', 'professional_function_catalog.md'), + ('diophantineApproximationNormalizeConvergent', 'Diophantine Approximation', '(value)', 'Normalize a convergent into the standard Diophantine Approximation representation.', 'professional_function_catalog.md'), + ('diophantineApproximationNormalizeFareySequence', 'Diophantine Approximation', '(value)', 'Normalize a Farey sequence into the standard Diophantine Approximation representation.', 'professional_function_catalog.md'), + ('diophantineApproximationNormalizePellEquation', 'Diophantine Approximation', '(value)', 'Normalize a Pell equation into the standard Diophantine Approximation representation.', 'professional_function_catalog.md'), + ('diophantineApproximationNormalizeRationalApproximation', 'Diophantine Approximation', '(value)', 'Normalize a rational approximation into the standard Diophantine Approximation representation.', 'professional_function_catalog.md'), + ('diophantineApproximationParseContinuedFraction', 'Diophantine Approximation', '(text)', 'Parse a text or structured value into a continued fraction.', 'professional_function_catalog.md'), + ('diophantineApproximationParseConvergent', 'Diophantine Approximation', '(text)', 'Parse a text or structured value into a convergent.', 'professional_function_catalog.md'), + ('diophantineApproximationParseFareySequence', 'Diophantine Approximation', '(text)', 'Parse a text or structured value into a Farey sequence.', 'professional_function_catalog.md'), + ('diophantineApproximationParsePellEquation', 'Diophantine Approximation', '(text)', 'Parse a text or structured value into a Pell equation.', 'professional_function_catalog.md'), + ('diophantineApproximationParseRationalApproximation', 'Diophantine Approximation', '(text)', 'Parse a text or structured value into a rational approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationSimplifyContinuedFraction', 'Diophantine Approximation', '(value)', 'Simplify a continued fraction without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('diophantineApproximationSimplifyConvergent', 'Diophantine Approximation', '(value)', 'Simplify a convergent without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('diophantineApproximationSimplifyFareySequence', 'Diophantine Approximation', '(value)', 'Simplify a Farey sequence without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('diophantineApproximationSimplifyPellEquation', 'Diophantine Approximation', '(value)', 'Simplify a Pell equation without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('diophantineApproximationSimplifyRationalApproximation', 'Diophantine Approximation', '(value)', 'Simplify a rational approximation without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('diophantineApproximationTestEquivalenceContinuedFraction', 'Diophantine Approximation', '(left, right)', 'Test whether two continued fraction values are equivalent in Diophantine Approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationTestEquivalenceConvergent', 'Diophantine Approximation', '(left, right)', 'Test whether two convergent values are equivalent in Diophantine Approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationTestEquivalenceFareySequence', 'Diophantine Approximation', '(left, right)', 'Test whether two Farey sequence values are equivalent in Diophantine Approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationTestEquivalencePellEquation', 'Diophantine Approximation', '(left, right)', 'Test whether two Pell equation values are equivalent in Diophantine Approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationTestEquivalenceRationalApproximation', 'Diophantine Approximation', '(left, right)', 'Test whether two rational approximation values are equivalent in Diophantine Approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationTransformContinuedFraction', 'Diophantine Approximation', '(value, mapping)', 'Transform a continued fraction through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('diophantineApproximationTransformConvergent', 'Diophantine Approximation', '(value, mapping)', 'Transform a convergent through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('diophantineApproximationTransformFareySequence', 'Diophantine Approximation', '(value, mapping)', 'Transform a Farey sequence through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('diophantineApproximationTransformPellEquation', 'Diophantine Approximation', '(value, mapping)', 'Transform a Pell equation through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('diophantineApproximationTransformRationalApproximation', 'Diophantine Approximation', '(value, mapping)', 'Transform a rational approximation through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('diophantineApproximationValidateContinuedFraction', 'Diophantine Approximation', '(value)', 'Validate the continued fraction representation and domain rules for Diophantine Approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationValidateConvergent', 'Diophantine Approximation', '(value)', 'Validate the convergent representation and domain rules for Diophantine Approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationValidateFareySequence', 'Diophantine Approximation', '(value)', 'Validate the Farey sequence representation and domain rules for Diophantine Approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationValidatePellEquation', 'Diophantine Approximation', '(value)', 'Validate the Pell equation representation and domain rules for Diophantine Approximation.', 'professional_function_catalog.md'), + ('diophantineApproximationValidateRationalApproximation', 'Diophantine Approximation', '(value)', 'Validate the rational approximation representation and domain rules for Diophantine Approximation.', 'professional_function_catalog.md'), + ('fareySequence', 'Diophantine Approximation', '(n)', 'Planned roadmap function for Diophantine Approximation from upcoming.md.', 'upcoming.md'), + ('isDiophantineSolution', 'Diophantine Approximation', '(equation, values)', 'Planned roadmap function for Diophantine Approximation from upcoming.md.', 'upcoming.md'), + ('mediant', 'Diophantine Approximation', '(fracA, fracB)', 'Planned roadmap function for Diophantine Approximation from upcoming.md.', 'upcoming.md'), + ('solvePell', 'Diophantine Approximation', '(D, limit)', 'Planned roadmap function for Diophantine Approximation from upcoming.md.', 'upcoming.md'), + ('cobwebData', 'Dynamical Systems', '(f, x0, steps)', 'Planned roadmap function for Dynamical Systems from upcoming.md.', 'upcoming.md'), + ('dynamicalSystemsApproximateFixedPoint', 'Dynamical Systems', '(value, tolerance=1e-9)', 'Approximate a fixed point with explicit tolerance controls.', 'professional_function_catalog.md'), + ('dynamicalSystemsApproximateIteratedMap', 'Dynamical Systems', '(value, tolerance=1e-9)', 'Approximate a iterated map with explicit tolerance controls.', 'professional_function_catalog.md'), + ('dynamicalSystemsApproximateOrbit', 'Dynamical Systems', '(value, tolerance=1e-9)', 'Approximate a orbit with explicit tolerance controls.', 'professional_function_catalog.md'), + ('dynamicalSystemsApproximatePhaseSpace', 'Dynamical Systems', '(value, tolerance=1e-9)', 'Approximate a phase space with explicit tolerance controls.', 'professional_function_catalog.md'), + ('dynamicalSystemsApproximateStabilityProfile', 'Dynamical Systems', '(value, tolerance=1e-9)', 'Approximate a stability profile with explicit tolerance controls.', 'professional_function_catalog.md'), + ('dynamicalSystemsCanonicalizeFixedPoint', 'Dynamical Systems', '(value)', 'Canonicalize a fixed point so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('dynamicalSystemsCanonicalizeIteratedMap', 'Dynamical Systems', '(value)', 'Canonicalize a iterated map so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('dynamicalSystemsCanonicalizeOrbit', 'Dynamical Systems', '(value)', 'Canonicalize a orbit so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('dynamicalSystemsCanonicalizePhaseSpace', 'Dynamical Systems', '(value)', 'Canonicalize a phase space so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('dynamicalSystemsCanonicalizeStabilityProfile', 'Dynamical Systems', '(value)', 'Canonicalize a stability profile so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('dynamicalSystemsClassifyFixedPoint', 'Dynamical Systems', '(value)', 'Classify a fixed point by its standard Dynamical Systems invariants.', 'professional_function_catalog.md'), + ('dynamicalSystemsClassifyIteratedMap', 'Dynamical Systems', '(value)', 'Classify a iterated map by its standard Dynamical Systems invariants.', 'professional_function_catalog.md'), + ('dynamicalSystemsClassifyOrbit', 'Dynamical Systems', '(value)', 'Classify a orbit by its standard Dynamical Systems invariants.', 'professional_function_catalog.md'), + ('dynamicalSystemsClassifyPhaseSpace', 'Dynamical Systems', '(value)', 'Classify a phase space by its standard Dynamical Systems invariants.', 'professional_function_catalog.md'), + ('dynamicalSystemsClassifyStabilityProfile', 'Dynamical Systems', '(value)', 'Classify a stability profile by its standard Dynamical Systems invariants.', 'professional_function_catalog.md'), + ('dynamicalSystemsCombineFixedPoint', 'Dynamical Systems', '(left, right)', 'Combine two fixed point values with the natural operation for Dynamical Systems.', 'professional_function_catalog.md'), + ('dynamicalSystemsCombineIteratedMap', 'Dynamical Systems', '(left, right)', 'Combine two iterated map values with the natural operation for Dynamical Systems.', 'professional_function_catalog.md'), + ('dynamicalSystemsCombineOrbit', 'Dynamical Systems', '(left, right)', 'Combine two orbit values with the natural operation for Dynamical Systems.', 'professional_function_catalog.md'), + ('dynamicalSystemsCombinePhaseSpace', 'Dynamical Systems', '(left, right)', 'Combine two phase space values with the natural operation for Dynamical Systems.', 'professional_function_catalog.md'), + ('dynamicalSystemsCombineStabilityProfile', 'Dynamical Systems', '(left, right)', 'Combine two stability profile values with the natural operation for Dynamical Systems.', 'professional_function_catalog.md'), + ('dynamicalSystemsCompareFixedPoint', 'Dynamical Systems', '(left, right)', 'Compare two fixed point values under the conventions of Dynamical Systems.', 'professional_function_catalog.md'), + ('dynamicalSystemsCompareIteratedMap', 'Dynamical Systems', '(left, right)', 'Compare two iterated map values under the conventions of Dynamical Systems.', 'professional_function_catalog.md'), + ('dynamicalSystemsCompareOrbit', 'Dynamical Systems', '(left, right)', 'Compare two orbit values under the conventions of Dynamical Systems.', 'professional_function_catalog.md'), + ('dynamicalSystemsComparePhaseSpace', 'Dynamical Systems', '(left, right)', 'Compare two phase space values under the conventions of Dynamical Systems.', 'professional_function_catalog.md'), + ('dynamicalSystemsCompareStabilityProfile', 'Dynamical Systems', '(left, right)', 'Compare two stability profile values under the conventions of Dynamical Systems.', 'professional_function_catalog.md'), + ('dynamicalSystemsComputeFixedPoint', 'Dynamical Systems', '(value)', 'Compute the central numerical or symbolic data of a fixed point.', 'professional_function_catalog.md'), + ('dynamicalSystemsComputeIteratedMap', 'Dynamical Systems', '(value)', 'Compute the central numerical or symbolic data of a iterated map.', 'professional_function_catalog.md'), + ('dynamicalSystemsComputeOrbit', 'Dynamical Systems', '(value)', 'Compute the central numerical or symbolic data of a orbit.', 'professional_function_catalog.md'), + ('dynamicalSystemsComputePhaseSpace', 'Dynamical Systems', '(value)', 'Compute the central numerical or symbolic data of a phase space.', 'professional_function_catalog.md'), + ('dynamicalSystemsComputeStabilityProfile', 'Dynamical Systems', '(value)', 'Compute the central numerical or symbolic data of a stability profile.', 'professional_function_catalog.md'), + ('dynamicalSystemsConstructFixedPoint', 'Dynamical Systems', '(*args)', 'Construct a fixed point from explicit inputs for Dynamical Systems.', 'professional_function_catalog.md'), + ('dynamicalSystemsConstructIteratedMap', 'Dynamical Systems', '(*args)', 'Construct a iterated map from explicit inputs for Dynamical Systems.', 'professional_function_catalog.md'), + ('dynamicalSystemsConstructOrbit', 'Dynamical Systems', '(*args)', 'Construct a orbit from explicit inputs for Dynamical Systems.', 'professional_function_catalog.md'), + ('dynamicalSystemsConstructPhaseSpace', 'Dynamical Systems', '(*args)', 'Construct a phase space from explicit inputs for Dynamical Systems.', 'professional_function_catalog.md'), + ('dynamicalSystemsConstructStabilityProfile', 'Dynamical Systems', '(*args)', 'Construct a stability profile from explicit inputs for Dynamical Systems.', 'professional_function_catalog.md'), + ('dynamicalSystemsDecomposeFixedPoint', 'Dynamical Systems', '(value)', 'Decompose a fixed point into simpler or canonical components.', 'professional_function_catalog.md'), + ('dynamicalSystemsDecomposeIteratedMap', 'Dynamical Systems', '(value)', 'Decompose a iterated map into simpler or canonical components.', 'professional_function_catalog.md'), + ('dynamicalSystemsDecomposeOrbit', 'Dynamical Systems', '(value)', 'Decompose a orbit into simpler or canonical components.', 'professional_function_catalog.md'), + ('dynamicalSystemsDecomposePhaseSpace', 'Dynamical Systems', '(value)', 'Decompose a phase space into simpler or canonical components.', 'professional_function_catalog.md'), + ('dynamicalSystemsDecomposeStabilityProfile', 'Dynamical Systems', '(value)', 'Decompose a stability profile into simpler or canonical components.', 'professional_function_catalog.md'), + ('dynamicalSystemsDocumentFixedPoint', 'Dynamical Systems', '(value)', 'Return a structured explanation of a fixed point and related assumptions.', 'professional_function_catalog.md'), + ('dynamicalSystemsDocumentIteratedMap', 'Dynamical Systems', '(value)', 'Return a structured explanation of a iterated map and related assumptions.', 'professional_function_catalog.md'), + ('dynamicalSystemsDocumentOrbit', 'Dynamical Systems', '(value)', 'Return a structured explanation of a orbit and related assumptions.', 'professional_function_catalog.md'), + ('dynamicalSystemsDocumentPhaseSpace', 'Dynamical Systems', '(value)', 'Return a structured explanation of a phase space and related assumptions.', 'professional_function_catalog.md'), + ('dynamicalSystemsDocumentStabilityProfile', 'Dynamical Systems', '(value)', 'Return a structured explanation of a stability profile and related assumptions.', 'professional_function_catalog.md'), + ('dynamicalSystemsEnumerateFixedPoint', 'Dynamical Systems', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a fixed point.', 'professional_function_catalog.md'), + ('dynamicalSystemsEnumerateIteratedMap', 'Dynamical Systems', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a iterated map.', 'professional_function_catalog.md'), + ('dynamicalSystemsEnumerateOrbit', 'Dynamical Systems', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a orbit.', 'professional_function_catalog.md'), + ('dynamicalSystemsEnumeratePhaseSpace', 'Dynamical Systems', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a phase space.', 'professional_function_catalog.md'), + ('dynamicalSystemsEnumerateStabilityProfile', 'Dynamical Systems', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a stability profile.', 'professional_function_catalog.md'), + ('dynamicalSystemsEstimateFixedPoint', 'Dynamical Systems', '(value, samples=None)', 'Estimate a fixed point property from finite samples or approximations.', 'professional_function_catalog.md'), + ('dynamicalSystemsEstimateIteratedMap', 'Dynamical Systems', '(value, samples=None)', 'Estimate a iterated map property from finite samples or approximations.', 'professional_function_catalog.md'), + ('dynamicalSystemsEstimateOrbit', 'Dynamical Systems', '(value, samples=None)', 'Estimate a orbit property from finite samples or approximations.', 'professional_function_catalog.md'), + ('dynamicalSystemsEstimatePhaseSpace', 'Dynamical Systems', '(value, samples=None)', 'Estimate a phase space property from finite samples or approximations.', 'professional_function_catalog.md'), + ('dynamicalSystemsEstimateStabilityProfile', 'Dynamical Systems', '(value, samples=None)', 'Estimate a stability profile property from finite samples or approximations.', 'professional_function_catalog.md'), + ('dynamicalSystemsEvaluateFixedPoint', 'Dynamical Systems', '(value, point=None)', 'Evaluate a fixed point at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('dynamicalSystemsEvaluateIteratedMap', 'Dynamical Systems', '(value, point=None)', 'Evaluate a iterated map at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('dynamicalSystemsEvaluateOrbit', 'Dynamical Systems', '(value, point=None)', 'Evaluate a orbit at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('dynamicalSystemsEvaluatePhaseSpace', 'Dynamical Systems', '(value, point=None)', 'Evaluate a phase space at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('dynamicalSystemsEvaluateStabilityProfile', 'Dynamical Systems', '(value, point=None)', 'Evaluate a stability profile at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('dynamicalSystemsFormatFixedPoint', 'Dynamical Systems', '(value)', 'Format a fixed point for deterministic user-facing output.', 'professional_function_catalog.md'), + ('dynamicalSystemsFormatIteratedMap', 'Dynamical Systems', '(value)', 'Format a iterated map for deterministic user-facing output.', 'professional_function_catalog.md'), + ('dynamicalSystemsFormatOrbit', 'Dynamical Systems', '(value)', 'Format a orbit for deterministic user-facing output.', 'professional_function_catalog.md'), + ('dynamicalSystemsFormatPhaseSpace', 'Dynamical Systems', '(value)', 'Format a phase space for deterministic user-facing output.', 'professional_function_catalog.md'), + ('dynamicalSystemsFormatStabilityProfile', 'Dynamical Systems', '(value)', 'Format a stability profile for deterministic user-facing output.', 'professional_function_catalog.md'), + ('dynamicalSystemsGenerateExampleFixedPoint', 'Dynamical Systems', '(size=3)', 'Generate a small documented example of a fixed point.', 'professional_function_catalog.md'), + ('dynamicalSystemsGenerateExampleIteratedMap', 'Dynamical Systems', '(size=3)', 'Generate a small documented example of a iterated map.', 'professional_function_catalog.md'), + ('dynamicalSystemsGenerateExampleOrbit', 'Dynamical Systems', '(size=3)', 'Generate a small documented example of a orbit.', 'professional_function_catalog.md'), + ('dynamicalSystemsGenerateExamplePhaseSpace', 'Dynamical Systems', '(size=3)', 'Generate a small documented example of a phase space.', 'professional_function_catalog.md'), + ('dynamicalSystemsGenerateExampleStabilityProfile', 'Dynamical Systems', '(size=3)', 'Generate a small documented example of a stability profile.', 'professional_function_catalog.md'), + ('dynamicalSystemsNormalizeFixedPoint', 'Dynamical Systems', '(value)', 'Normalize a fixed point into the standard Dynamical Systems representation.', 'professional_function_catalog.md'), + ('dynamicalSystemsNormalizeIteratedMap', 'Dynamical Systems', '(value)', 'Normalize a iterated map into the standard Dynamical Systems representation.', 'professional_function_catalog.md'), + ('dynamicalSystemsNormalizeOrbit', 'Dynamical Systems', '(value)', 'Normalize a orbit into the standard Dynamical Systems representation.', 'professional_function_catalog.md'), + ('dynamicalSystemsNormalizePhaseSpace', 'Dynamical Systems', '(value)', 'Normalize a phase space into the standard Dynamical Systems representation.', 'professional_function_catalog.md'), + ('dynamicalSystemsNormalizeStabilityProfile', 'Dynamical Systems', '(value)', 'Normalize a stability profile into the standard Dynamical Systems representation.', 'professional_function_catalog.md'), + ('dynamicalSystemsParseFixedPoint', 'Dynamical Systems', '(text)', 'Parse a text or structured value into a fixed point.', 'professional_function_catalog.md'), + ('dynamicalSystemsParseIteratedMap', 'Dynamical Systems', '(text)', 'Parse a text or structured value into a iterated map.', 'professional_function_catalog.md'), + ('dynamicalSystemsParseOrbit', 'Dynamical Systems', '(text)', 'Parse a text or structured value into a orbit.', 'professional_function_catalog.md'), + ('dynamicalSystemsParsePhaseSpace', 'Dynamical Systems', '(text)', 'Parse a text or structured value into a phase space.', 'professional_function_catalog.md'), + ('dynamicalSystemsParseStabilityProfile', 'Dynamical Systems', '(text)', 'Parse a text or structured value into a stability profile.', 'professional_function_catalog.md'), + ('dynamicalSystemsSimplifyFixedPoint', 'Dynamical Systems', '(value)', 'Simplify a fixed point without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('dynamicalSystemsSimplifyIteratedMap', 'Dynamical Systems', '(value)', 'Simplify a iterated map without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('dynamicalSystemsSimplifyOrbit', 'Dynamical Systems', '(value)', 'Simplify a orbit without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('dynamicalSystemsSimplifyPhaseSpace', 'Dynamical Systems', '(value)', 'Simplify a phase space without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('dynamicalSystemsSimplifyStabilityProfile', 'Dynamical Systems', '(value)', 'Simplify a stability profile without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('dynamicalSystemsTestEquivalenceFixedPoint', 'Dynamical Systems', '(left, right)', 'Test whether two fixed point values are equivalent in Dynamical Systems.', 'professional_function_catalog.md'), + ('dynamicalSystemsTestEquivalenceIteratedMap', 'Dynamical Systems', '(left, right)', 'Test whether two iterated map values are equivalent in Dynamical Systems.', 'professional_function_catalog.md'), + ('dynamicalSystemsTestEquivalenceOrbit', 'Dynamical Systems', '(left, right)', 'Test whether two orbit values are equivalent in Dynamical Systems.', 'professional_function_catalog.md'), + ('dynamicalSystemsTestEquivalencePhaseSpace', 'Dynamical Systems', '(left, right)', 'Test whether two phase space values are equivalent in Dynamical Systems.', 'professional_function_catalog.md'), + ('dynamicalSystemsTestEquivalenceStabilityProfile', 'Dynamical Systems', '(left, right)', 'Test whether two stability profile values are equivalent in Dynamical Systems.', 'professional_function_catalog.md'), + ('dynamicalSystemsTransformFixedPoint', 'Dynamical Systems', '(value, mapping)', 'Transform a fixed point through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('dynamicalSystemsTransformIteratedMap', 'Dynamical Systems', '(value, mapping)', 'Transform a iterated map through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('dynamicalSystemsTransformOrbit', 'Dynamical Systems', '(value, mapping)', 'Transform a orbit through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('dynamicalSystemsTransformPhaseSpace', 'Dynamical Systems', '(value, mapping)', 'Transform a phase space through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('dynamicalSystemsTransformStabilityProfile', 'Dynamical Systems', '(value, mapping)', 'Transform a stability profile through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('dynamicalSystemsValidateFixedPoint', 'Dynamical Systems', '(value)', 'Validate the fixed point representation and domain rules for Dynamical Systems.', 'professional_function_catalog.md'), + ('dynamicalSystemsValidateIteratedMap', 'Dynamical Systems', '(value)', 'Validate the iterated map representation and domain rules for Dynamical Systems.', 'professional_function_catalog.md'), + ('dynamicalSystemsValidateOrbit', 'Dynamical Systems', '(value)', 'Validate the orbit representation and domain rules for Dynamical Systems.', 'professional_function_catalog.md'), + ('dynamicalSystemsValidatePhaseSpace', 'Dynamical Systems', '(value)', 'Validate the phase space representation and domain rules for Dynamical Systems.', 'professional_function_catalog.md'), + ('dynamicalSystemsValidateStabilityProfile', 'Dynamical Systems', '(value)', 'Validate the stability profile representation and domain rules for Dynamical Systems.', 'professional_function_catalog.md'), + ('fixedPoints', 'Dynamical Systems', '(f, candidates, tolerance=1e-9)', 'Planned roadmap function for Dynamical Systems from upcoming.md.', 'upcoming.md'), + ('isPeriodicOrbit', 'Dynamical Systems', '(values, period, tolerance=1e-9)', 'Planned roadmap function for Dynamical Systems from upcoming.md.', 'upcoming.md'), + ('iterateFunction', 'Dynamical Systems', '(f, x0, steps)', 'Planned roadmap function for Dynamical Systems from upcoming.md.', 'upcoming.md'), + ('logisticMap', 'Dynamical Systems', '(r, x0, steps)', 'Planned roadmap function for Dynamical Systems from upcoming.md.', 'upcoming.md'), + ('lyapunovExponentLogistic', 'Dynamical Systems', '(r, x0, steps)', 'Planned roadmap function for Dynamical Systems from upcoming.md.', 'upcoming.md'), + ('orbit', 'Dynamical Systems', '(f, x0, steps)', 'Planned roadmap function for Dynamical Systems from upcoming.md.', 'upcoming.md'), + ('birkhoffAverage', 'Ergodic Theory', '(values)', 'Planned roadmap function for Ergodic Theory from upcoming.md.', 'upcoming.md'), + ('ergodicSampleCheck', 'Ergodic Theory', '(transform, space, measure)', 'Planned roadmap function for Ergodic Theory from upcoming.md.', 'upcoming.md'), + ('ergodicTheoryApproximateInvariantSet', 'Ergodic Theory', '(value, tolerance=1e-9)', 'Approximate a invariant set with explicit tolerance controls.', 'professional_function_catalog.md'), + ('ergodicTheoryApproximateMeasurePreservingMap', 'Ergodic Theory', '(value, tolerance=1e-9)', 'Approximate a measure preserving map with explicit tolerance controls.', 'professional_function_catalog.md'), + ('ergodicTheoryApproximateMixingSample', 'Ergodic Theory', '(value, tolerance=1e-9)', 'Approximate a mixing sample with explicit tolerance controls.', 'professional_function_catalog.md'), + ('ergodicTheoryApproximateOrbitAverage', 'Ergodic Theory', '(value, tolerance=1e-9)', 'Approximate a orbit average with explicit tolerance controls.', 'professional_function_catalog.md'), + ('ergodicTheoryApproximateReturnTime', 'Ergodic Theory', '(value, tolerance=1e-9)', 'Approximate a return time with explicit tolerance controls.', 'professional_function_catalog.md'), + ('ergodicTheoryCanonicalizeInvariantSet', 'Ergodic Theory', '(value)', 'Canonicalize a invariant set so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('ergodicTheoryCanonicalizeMeasurePreservingMap', 'Ergodic Theory', '(value)', 'Canonicalize a measure preserving map so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('ergodicTheoryCanonicalizeMixingSample', 'Ergodic Theory', '(value)', 'Canonicalize a mixing sample so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('ergodicTheoryCanonicalizeOrbitAverage', 'Ergodic Theory', '(value)', 'Canonicalize a orbit average so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('ergodicTheoryCanonicalizeReturnTime', 'Ergodic Theory', '(value)', 'Canonicalize a return time so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('ergodicTheoryClassifyInvariantSet', 'Ergodic Theory', '(value)', 'Classify a invariant set by its standard Ergodic Theory invariants.', 'professional_function_catalog.md'), + ('ergodicTheoryClassifyMeasurePreservingMap', 'Ergodic Theory', '(value)', 'Classify a measure preserving map by its standard Ergodic Theory invariants.', 'professional_function_catalog.md'), + ('ergodicTheoryClassifyMixingSample', 'Ergodic Theory', '(value)', 'Classify a mixing sample by its standard Ergodic Theory invariants.', 'professional_function_catalog.md'), + ('ergodicTheoryClassifyOrbitAverage', 'Ergodic Theory', '(value)', 'Classify a orbit average by its standard Ergodic Theory invariants.', 'professional_function_catalog.md'), + ('ergodicTheoryClassifyReturnTime', 'Ergodic Theory', '(value)', 'Classify a return time by its standard Ergodic Theory invariants.', 'professional_function_catalog.md'), + ('ergodicTheoryCombineInvariantSet', 'Ergodic Theory', '(left, right)', 'Combine two invariant set values with the natural operation for Ergodic Theory.', 'professional_function_catalog.md'), + ('ergodicTheoryCombineMeasurePreservingMap', 'Ergodic Theory', '(left, right)', 'Combine two measure preserving map values with the natural operation for Ergodic Theory.', 'professional_function_catalog.md'), + ('ergodicTheoryCombineMixingSample', 'Ergodic Theory', '(left, right)', 'Combine two mixing sample values with the natural operation for Ergodic Theory.', 'professional_function_catalog.md'), + ('ergodicTheoryCombineOrbitAverage', 'Ergodic Theory', '(left, right)', 'Combine two orbit average values with the natural operation for Ergodic Theory.', 'professional_function_catalog.md'), + ('ergodicTheoryCombineReturnTime', 'Ergodic Theory', '(left, right)', 'Combine two return time values with the natural operation for Ergodic Theory.', 'professional_function_catalog.md'), + ('ergodicTheoryCompareInvariantSet', 'Ergodic Theory', '(left, right)', 'Compare two invariant set values under the conventions of Ergodic Theory.', 'professional_function_catalog.md'), + ('ergodicTheoryCompareMeasurePreservingMap', 'Ergodic Theory', '(left, right)', 'Compare two measure preserving map values under the conventions of Ergodic Theory.', 'professional_function_catalog.md'), + ('ergodicTheoryCompareMixingSample', 'Ergodic Theory', '(left, right)', 'Compare two mixing sample values under the conventions of Ergodic Theory.', 'professional_function_catalog.md'), + ('ergodicTheoryCompareOrbitAverage', 'Ergodic Theory', '(left, right)', 'Compare two orbit average values under the conventions of Ergodic Theory.', 'professional_function_catalog.md'), + ('ergodicTheoryCompareReturnTime', 'Ergodic Theory', '(left, right)', 'Compare two return time values under the conventions of Ergodic Theory.', 'professional_function_catalog.md'), + ('ergodicTheoryComputeInvariantSet', 'Ergodic Theory', '(value)', 'Compute the central numerical or symbolic data of a invariant set.', 'professional_function_catalog.md'), + ('ergodicTheoryComputeMeasurePreservingMap', 'Ergodic Theory', '(value)', 'Compute the central numerical or symbolic data of a measure preserving map.', 'professional_function_catalog.md'), + ('ergodicTheoryComputeMixingSample', 'Ergodic Theory', '(value)', 'Compute the central numerical or symbolic data of a mixing sample.', 'professional_function_catalog.md'), + ('ergodicTheoryComputeOrbitAverage', 'Ergodic Theory', '(value)', 'Compute the central numerical or symbolic data of a orbit average.', 'professional_function_catalog.md'), + ('ergodicTheoryComputeReturnTime', 'Ergodic Theory', '(value)', 'Compute the central numerical or symbolic data of a return time.', 'professional_function_catalog.md'), + ('ergodicTheoryConstructInvariantSet', 'Ergodic Theory', '(*args)', 'Construct a invariant set from explicit inputs for Ergodic Theory.', 'professional_function_catalog.md'), + ('ergodicTheoryConstructMeasurePreservingMap', 'Ergodic Theory', '(*args)', 'Construct a measure preserving map from explicit inputs for Ergodic Theory.', 'professional_function_catalog.md'), + ('ergodicTheoryConstructMixingSample', 'Ergodic Theory', '(*args)', 'Construct a mixing sample from explicit inputs for Ergodic Theory.', 'professional_function_catalog.md'), + ('ergodicTheoryConstructOrbitAverage', 'Ergodic Theory', '(*args)', 'Construct a orbit average from explicit inputs for Ergodic Theory.', 'professional_function_catalog.md'), + ('ergodicTheoryConstructReturnTime', 'Ergodic Theory', '(*args)', 'Construct a return time from explicit inputs for Ergodic Theory.', 'professional_function_catalog.md'), + ('ergodicTheoryDecomposeInvariantSet', 'Ergodic Theory', '(value)', 'Decompose a invariant set into simpler or canonical components.', 'professional_function_catalog.md'), + ('ergodicTheoryDecomposeMeasurePreservingMap', 'Ergodic Theory', '(value)', 'Decompose a measure preserving map into simpler or canonical components.', 'professional_function_catalog.md'), + ('ergodicTheoryDecomposeMixingSample', 'Ergodic Theory', '(value)', 'Decompose a mixing sample into simpler or canonical components.', 'professional_function_catalog.md'), + ('ergodicTheoryDecomposeOrbitAverage', 'Ergodic Theory', '(value)', 'Decompose a orbit average into simpler or canonical components.', 'professional_function_catalog.md'), + ('ergodicTheoryDecomposeReturnTime', 'Ergodic Theory', '(value)', 'Decompose a return time into simpler or canonical components.', 'professional_function_catalog.md'), + ('ergodicTheoryDocumentInvariantSet', 'Ergodic Theory', '(value)', 'Return a structured explanation of a invariant set and related assumptions.', 'professional_function_catalog.md'), + ('ergodicTheoryDocumentMeasurePreservingMap', 'Ergodic Theory', '(value)', 'Return a structured explanation of a measure preserving map and related assumptions.', 'professional_function_catalog.md'), + ('ergodicTheoryDocumentMixingSample', 'Ergodic Theory', '(value)', 'Return a structured explanation of a mixing sample and related assumptions.', 'professional_function_catalog.md'), + ('ergodicTheoryDocumentOrbitAverage', 'Ergodic Theory', '(value)', 'Return a structured explanation of a orbit average and related assumptions.', 'professional_function_catalog.md'), + ('ergodicTheoryDocumentReturnTime', 'Ergodic Theory', '(value)', 'Return a structured explanation of a return time and related assumptions.', 'professional_function_catalog.md'), + ('ergodicTheoryEnumerateInvariantSet', 'Ergodic Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a invariant set.', 'professional_function_catalog.md'), + ('ergodicTheoryEnumerateMeasurePreservingMap', 'Ergodic Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a measure preserving map.', 'professional_function_catalog.md'), + ('ergodicTheoryEnumerateMixingSample', 'Ergodic Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a mixing sample.', 'professional_function_catalog.md'), + ('ergodicTheoryEnumerateOrbitAverage', 'Ergodic Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a orbit average.', 'professional_function_catalog.md'), + ('ergodicTheoryEnumerateReturnTime', 'Ergodic Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a return time.', 'professional_function_catalog.md'), + ('ergodicTheoryEstimateInvariantSet', 'Ergodic Theory', '(value, samples=None)', 'Estimate a invariant set property from finite samples or approximations.', 'professional_function_catalog.md'), + ('ergodicTheoryEstimateMeasurePreservingMap', 'Ergodic Theory', '(value, samples=None)', 'Estimate a measure preserving map property from finite samples or approximations.', 'professional_function_catalog.md'), + ('ergodicTheoryEstimateMixingSample', 'Ergodic Theory', '(value, samples=None)', 'Estimate a mixing sample property from finite samples or approximations.', 'professional_function_catalog.md'), + ('ergodicTheoryEstimateOrbitAverage', 'Ergodic Theory', '(value, samples=None)', 'Estimate a orbit average property from finite samples or approximations.', 'professional_function_catalog.md'), + ('ergodicTheoryEstimateReturnTime', 'Ergodic Theory', '(value, samples=None)', 'Estimate a return time property from finite samples or approximations.', 'professional_function_catalog.md'), + ('ergodicTheoryEvaluateInvariantSet', 'Ergodic Theory', '(value, point=None)', 'Evaluate a invariant set at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('ergodicTheoryEvaluateMeasurePreservingMap', 'Ergodic Theory', '(value, point=None)', 'Evaluate a measure preserving map at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('ergodicTheoryEvaluateMixingSample', 'Ergodic Theory', '(value, point=None)', 'Evaluate a mixing sample at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('ergodicTheoryEvaluateOrbitAverage', 'Ergodic Theory', '(value, point=None)', 'Evaluate a orbit average at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('ergodicTheoryEvaluateReturnTime', 'Ergodic Theory', '(value, point=None)', 'Evaluate a return time at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('ergodicTheoryFormatInvariantSet', 'Ergodic Theory', '(value)', 'Format a invariant set for deterministic user-facing output.', 'professional_function_catalog.md'), + ('ergodicTheoryFormatMeasurePreservingMap', 'Ergodic Theory', '(value)', 'Format a measure preserving map for deterministic user-facing output.', 'professional_function_catalog.md'), + ('ergodicTheoryFormatMixingSample', 'Ergodic Theory', '(value)', 'Format a mixing sample for deterministic user-facing output.', 'professional_function_catalog.md'), + ('ergodicTheoryFormatOrbitAverage', 'Ergodic Theory', '(value)', 'Format a orbit average for deterministic user-facing output.', 'professional_function_catalog.md'), + ('ergodicTheoryFormatReturnTime', 'Ergodic Theory', '(value)', 'Format a return time for deterministic user-facing output.', 'professional_function_catalog.md'), + ('ergodicTheoryGenerateExampleInvariantSet', 'Ergodic Theory', '(size=3)', 'Generate a small documented example of a invariant set.', 'professional_function_catalog.md'), + ('ergodicTheoryGenerateExampleMeasurePreservingMap', 'Ergodic Theory', '(size=3)', 'Generate a small documented example of a measure preserving map.', 'professional_function_catalog.md'), + ('ergodicTheoryGenerateExampleMixingSample', 'Ergodic Theory', '(size=3)', 'Generate a small documented example of a mixing sample.', 'professional_function_catalog.md'), + ('ergodicTheoryGenerateExampleOrbitAverage', 'Ergodic Theory', '(size=3)', 'Generate a small documented example of a orbit average.', 'professional_function_catalog.md'), + ('ergodicTheoryGenerateExampleReturnTime', 'Ergodic Theory', '(size=3)', 'Generate a small documented example of a return time.', 'professional_function_catalog.md'), + ('ergodicTheoryNormalizeInvariantSet', 'Ergodic Theory', '(value)', 'Normalize a invariant set into the standard Ergodic Theory representation.', 'professional_function_catalog.md'), + ('ergodicTheoryNormalizeMeasurePreservingMap', 'Ergodic Theory', '(value)', 'Normalize a measure preserving map into the standard Ergodic Theory representation.', 'professional_function_catalog.md'), + ('ergodicTheoryNormalizeMixingSample', 'Ergodic Theory', '(value)', 'Normalize a mixing sample into the standard Ergodic Theory representation.', 'professional_function_catalog.md'), + ('ergodicTheoryNormalizeOrbitAverage', 'Ergodic Theory', '(value)', 'Normalize a orbit average into the standard Ergodic Theory representation.', 'professional_function_catalog.md'), + ('ergodicTheoryNormalizeReturnTime', 'Ergodic Theory', '(value)', 'Normalize a return time into the standard Ergodic Theory representation.', 'professional_function_catalog.md'), + ('ergodicTheoryParseInvariantSet', 'Ergodic Theory', '(text)', 'Parse a text or structured value into a invariant set.', 'professional_function_catalog.md'), + ('ergodicTheoryParseMeasurePreservingMap', 'Ergodic Theory', '(text)', 'Parse a text or structured value into a measure preserving map.', 'professional_function_catalog.md'), + ('ergodicTheoryParseMixingSample', 'Ergodic Theory', '(text)', 'Parse a text or structured value into a mixing sample.', 'professional_function_catalog.md'), + ('ergodicTheoryParseOrbitAverage', 'Ergodic Theory', '(text)', 'Parse a text or structured value into a orbit average.', 'professional_function_catalog.md'), + ('ergodicTheoryParseReturnTime', 'Ergodic Theory', '(text)', 'Parse a text or structured value into a return time.', 'professional_function_catalog.md'), + ('ergodicTheorySimplifyInvariantSet', 'Ergodic Theory', '(value)', 'Simplify a invariant set without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('ergodicTheorySimplifyMeasurePreservingMap', 'Ergodic Theory', '(value)', 'Simplify a measure preserving map without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('ergodicTheorySimplifyMixingSample', 'Ergodic Theory', '(value)', 'Simplify a mixing sample without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('ergodicTheorySimplifyOrbitAverage', 'Ergodic Theory', '(value)', 'Simplify a orbit average without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('ergodicTheorySimplifyReturnTime', 'Ergodic Theory', '(value)', 'Simplify a return time without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('ergodicTheoryTestEquivalenceInvariantSet', 'Ergodic Theory', '(left, right)', 'Test whether two invariant set values are equivalent in Ergodic Theory.', 'professional_function_catalog.md'), + ('ergodicTheoryTestEquivalenceMeasurePreservingMap', 'Ergodic Theory', '(left, right)', 'Test whether two measure preserving map values are equivalent in Ergodic Theory.', 'professional_function_catalog.md'), + ('ergodicTheoryTestEquivalenceMixingSample', 'Ergodic Theory', '(left, right)', 'Test whether two mixing sample values are equivalent in Ergodic Theory.', 'professional_function_catalog.md'), + ('ergodicTheoryTestEquivalenceOrbitAverage', 'Ergodic Theory', '(left, right)', 'Test whether two orbit average values are equivalent in Ergodic Theory.', 'professional_function_catalog.md'), + ('ergodicTheoryTestEquivalenceReturnTime', 'Ergodic Theory', '(left, right)', 'Test whether two return time values are equivalent in Ergodic Theory.', 'professional_function_catalog.md'), + ('ergodicTheoryTransformInvariantSet', 'Ergodic Theory', '(value, mapping)', 'Transform a invariant set through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('ergodicTheoryTransformMeasurePreservingMap', 'Ergodic Theory', '(value, mapping)', 'Transform a measure preserving map through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('ergodicTheoryTransformMixingSample', 'Ergodic Theory', '(value, mapping)', 'Transform a mixing sample through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('ergodicTheoryTransformOrbitAverage', 'Ergodic Theory', '(value, mapping)', 'Transform a orbit average through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('ergodicTheoryTransformReturnTime', 'Ergodic Theory', '(value, mapping)', 'Transform a return time through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('ergodicTheoryValidateInvariantSet', 'Ergodic Theory', '(value)', 'Validate the invariant set representation and domain rules for Ergodic Theory.', 'professional_function_catalog.md'), + ('ergodicTheoryValidateMeasurePreservingMap', 'Ergodic Theory', '(value)', 'Validate the measure preserving map representation and domain rules for Ergodic Theory.', 'professional_function_catalog.md'), + ('ergodicTheoryValidateMixingSample', 'Ergodic Theory', '(value)', 'Validate the mixing sample representation and domain rules for Ergodic Theory.', 'professional_function_catalog.md'), + ('ergodicTheoryValidateOrbitAverage', 'Ergodic Theory', '(value)', 'Validate the orbit average representation and domain rules for Ergodic Theory.', 'professional_function_catalog.md'), + ('ergodicTheoryValidateReturnTime', 'Ergodic Theory', '(value)', 'Validate the return time representation and domain rules for Ergodic Theory.', 'professional_function_catalog.md'), + ('invariantSet', 'Ergodic Theory', '(transform, subset)', 'Planned roadmap function for Ergodic Theory from upcoming.md.', 'upcoming.md'), + ('isMeasurePreserving', 'Ergodic Theory', '(transform, space, measure)', 'Planned roadmap function for Ergodic Theory from upcoming.md.', 'upcoming.md'), + ('mixingSampleCheck', 'Ergodic Theory', '(transform, sets, steps)', 'Planned roadmap function for Ergodic Theory from upcoming.md.', 'upcoming.md'), + ('poincareReturnTimes', 'Ergodic Theory', '(transform, x0, targetSet, steps)', 'Planned roadmap function for Ergodic Theory from upcoming.md.', 'upcoming.md'), + ('spaceAverage', 'Ergodic Theory', '(values, measure)', 'Planned roadmap function for Ergodic Theory from upcoming.md.', 'upcoming.md'), + ('timeAverage', 'Ergodic Theory', '(f, transform, x0, steps)', 'Planned roadmap function for Ergodic Theory from upcoming.md.', 'upcoming.md'), + ('anovaOneWay', 'Experimental Design', '(groups)', 'Planned roadmap function for Experimental Design from upcoming.md.', 'upcoming.md'), + ('blockedRandomAssignment', 'Experimental Design', '(blocks, treatments)', 'Planned roadmap function for Experimental Design from upcoming.md.', 'upcoming.md'), + ('completeRandomAssignment', 'Experimental Design', '(subjects, treatments)', 'Planned roadmap function for Experimental Design from upcoming.md.', 'upcoming.md'), + ('effectSizeDifference', 'Experimental Design', '(meanA, meanB, pooledStdDev)', 'Planned roadmap function for Experimental Design from upcoming.md.', 'upcoming.md'), + ('experimentalDesignApproximateAnovaTable', 'Experimental Design', '(value, tolerance=1e-9)', 'Approximate a anova table with explicit tolerance controls.', 'professional_function_catalog.md'), + ('experimentalDesignApproximateAssignmentRule', 'Experimental Design', '(value, tolerance=1e-9)', 'Approximate a assignment rule with explicit tolerance controls.', 'professional_function_catalog.md'), + ('experimentalDesignApproximateBlockDesign', 'Experimental Design', '(value, tolerance=1e-9)', 'Approximate a block design with explicit tolerance controls.', 'professional_function_catalog.md'), + ('experimentalDesignApproximateFactorialDesign', 'Experimental Design', '(value, tolerance=1e-9)', 'Approximate a factorial design with explicit tolerance controls.', 'professional_function_catalog.md'), + ('experimentalDesignApproximateTreatmentPlan', 'Experimental Design', '(value, tolerance=1e-9)', 'Approximate a treatment plan with explicit tolerance controls.', 'professional_function_catalog.md'), + ('experimentalDesignCanonicalizeAnovaTable', 'Experimental Design', '(value)', 'Canonicalize a anova table so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('experimentalDesignCanonicalizeAssignmentRule', 'Experimental Design', '(value)', 'Canonicalize a assignment rule so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('experimentalDesignCanonicalizeBlockDesign', 'Experimental Design', '(value)', 'Canonicalize a block design so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('experimentalDesignCanonicalizeFactorialDesign', 'Experimental Design', '(value)', 'Canonicalize a factorial design so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('experimentalDesignCanonicalizeTreatmentPlan', 'Experimental Design', '(value)', 'Canonicalize a treatment plan so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('experimentalDesignClassifyAnovaTable', 'Experimental Design', '(value)', 'Classify a anova table by its standard Experimental Design invariants.', 'professional_function_catalog.md'), + ('experimentalDesignClassifyAssignmentRule', 'Experimental Design', '(value)', 'Classify a assignment rule by its standard Experimental Design invariants.', 'professional_function_catalog.md'), + ('experimentalDesignClassifyBlockDesign', 'Experimental Design', '(value)', 'Classify a block design by its standard Experimental Design invariants.', 'professional_function_catalog.md'), + ('experimentalDesignClassifyFactorialDesign', 'Experimental Design', '(value)', 'Classify a factorial design by its standard Experimental Design invariants.', 'professional_function_catalog.md'), + ('experimentalDesignClassifyTreatmentPlan', 'Experimental Design', '(value)', 'Classify a treatment plan by its standard Experimental Design invariants.', 'professional_function_catalog.md'), + ('experimentalDesignCombineAnovaTable', 'Experimental Design', '(left, right)', 'Combine two anova table values with the natural operation for Experimental Design.', 'professional_function_catalog.md'), + ('experimentalDesignCombineAssignmentRule', 'Experimental Design', '(left, right)', 'Combine two assignment rule values with the natural operation for Experimental Design.', 'professional_function_catalog.md'), + ('experimentalDesignCombineBlockDesign', 'Experimental Design', '(left, right)', 'Combine two block design values with the natural operation for Experimental Design.', 'professional_function_catalog.md'), + ('experimentalDesignCombineFactorialDesign', 'Experimental Design', '(left, right)', 'Combine two factorial design values with the natural operation for Experimental Design.', 'professional_function_catalog.md'), + ('experimentalDesignCombineTreatmentPlan', 'Experimental Design', '(left, right)', 'Combine two treatment plan values with the natural operation for Experimental Design.', 'professional_function_catalog.md'), + ('experimentalDesignCompareAnovaTable', 'Experimental Design', '(left, right)', 'Compare two anova table values under the conventions of Experimental Design.', 'professional_function_catalog.md'), + ('experimentalDesignCompareAssignmentRule', 'Experimental Design', '(left, right)', 'Compare two assignment rule values under the conventions of Experimental Design.', 'professional_function_catalog.md'), + ('experimentalDesignCompareBlockDesign', 'Experimental Design', '(left, right)', 'Compare two block design values under the conventions of Experimental Design.', 'professional_function_catalog.md'), + ('experimentalDesignCompareFactorialDesign', 'Experimental Design', '(left, right)', 'Compare two factorial design values under the conventions of Experimental Design.', 'professional_function_catalog.md'), + ('experimentalDesignCompareTreatmentPlan', 'Experimental Design', '(left, right)', 'Compare two treatment plan values under the conventions of Experimental Design.', 'professional_function_catalog.md'), + ('experimentalDesignComputeAnovaTable', 'Experimental Design', '(value)', 'Compute the central numerical or symbolic data of a anova table.', 'professional_function_catalog.md'), + ('experimentalDesignComputeAssignmentRule', 'Experimental Design', '(value)', 'Compute the central numerical or symbolic data of a assignment rule.', 'professional_function_catalog.md'), + ('experimentalDesignComputeBlockDesign', 'Experimental Design', '(value)', 'Compute the central numerical or symbolic data of a block design.', 'professional_function_catalog.md'), + ('experimentalDesignComputeFactorialDesign', 'Experimental Design', '(value)', 'Compute the central numerical or symbolic data of a factorial design.', 'professional_function_catalog.md'), + ('experimentalDesignComputeTreatmentPlan', 'Experimental Design', '(value)', 'Compute the central numerical or symbolic data of a treatment plan.', 'professional_function_catalog.md'), + ('experimentalDesignConstructAnovaTable', 'Experimental Design', '(*args)', 'Construct a anova table from explicit inputs for Experimental Design.', 'professional_function_catalog.md'), + ('experimentalDesignConstructAssignmentRule', 'Experimental Design', '(*args)', 'Construct a assignment rule from explicit inputs for Experimental Design.', 'professional_function_catalog.md'), + ('experimentalDesignConstructBlockDesign', 'Experimental Design', '(*args)', 'Construct a block design from explicit inputs for Experimental Design.', 'professional_function_catalog.md'), + ('experimentalDesignConstructFactorialDesign', 'Experimental Design', '(*args)', 'Construct a factorial design from explicit inputs for Experimental Design.', 'professional_function_catalog.md'), + ('experimentalDesignConstructTreatmentPlan', 'Experimental Design', '(*args)', 'Construct a treatment plan from explicit inputs for Experimental Design.', 'professional_function_catalog.md'), + ('experimentalDesignDecomposeAnovaTable', 'Experimental Design', '(value)', 'Decompose a anova table into simpler or canonical components.', 'professional_function_catalog.md'), + ('experimentalDesignDecomposeAssignmentRule', 'Experimental Design', '(value)', 'Decompose a assignment rule into simpler or canonical components.', 'professional_function_catalog.md'), + ('experimentalDesignDecomposeBlockDesign', 'Experimental Design', '(value)', 'Decompose a block design into simpler or canonical components.', 'professional_function_catalog.md'), + ('experimentalDesignDecomposeFactorialDesign', 'Experimental Design', '(value)', 'Decompose a factorial design into simpler or canonical components.', 'professional_function_catalog.md'), + ('experimentalDesignDecomposeTreatmentPlan', 'Experimental Design', '(value)', 'Decompose a treatment plan into simpler or canonical components.', 'professional_function_catalog.md'), + ('experimentalDesignDocumentAnovaTable', 'Experimental Design', '(value)', 'Return a structured explanation of a anova table and related assumptions.', 'professional_function_catalog.md'), + ('experimentalDesignDocumentAssignmentRule', 'Experimental Design', '(value)', 'Return a structured explanation of a assignment rule and related assumptions.', 'professional_function_catalog.md'), + ('experimentalDesignDocumentBlockDesign', 'Experimental Design', '(value)', 'Return a structured explanation of a block design and related assumptions.', 'professional_function_catalog.md'), + ('experimentalDesignDocumentFactorialDesign', 'Experimental Design', '(value)', 'Return a structured explanation of a factorial design and related assumptions.', 'professional_function_catalog.md'), + ('experimentalDesignDocumentTreatmentPlan', 'Experimental Design', '(value)', 'Return a structured explanation of a treatment plan and related assumptions.', 'professional_function_catalog.md'), + ('experimentalDesignEnumerateAnovaTable', 'Experimental Design', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a anova table.', 'professional_function_catalog.md'), + ('experimentalDesignEnumerateAssignmentRule', 'Experimental Design', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a assignment rule.', 'professional_function_catalog.md'), + ('experimentalDesignEnumerateBlockDesign', 'Experimental Design', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a block design.', 'professional_function_catalog.md'), + ('experimentalDesignEnumerateFactorialDesign', 'Experimental Design', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a factorial design.', 'professional_function_catalog.md'), + ('experimentalDesignEnumerateTreatmentPlan', 'Experimental Design', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a treatment plan.', 'professional_function_catalog.md'), + ('experimentalDesignEstimateAnovaTable', 'Experimental Design', '(value, samples=None)', 'Estimate a anova table property from finite samples or approximations.', 'professional_function_catalog.md'), + ('experimentalDesignEstimateAssignmentRule', 'Experimental Design', '(value, samples=None)', 'Estimate a assignment rule property from finite samples or approximations.', 'professional_function_catalog.md'), + ('experimentalDesignEstimateBlockDesign', 'Experimental Design', '(value, samples=None)', 'Estimate a block design property from finite samples or approximations.', 'professional_function_catalog.md'), + ('experimentalDesignEstimateFactorialDesign', 'Experimental Design', '(value, samples=None)', 'Estimate a factorial design property from finite samples or approximations.', 'professional_function_catalog.md'), + ('experimentalDesignEstimateTreatmentPlan', 'Experimental Design', '(value, samples=None)', 'Estimate a treatment plan property from finite samples or approximations.', 'professional_function_catalog.md'), + ('experimentalDesignEvaluateAnovaTable', 'Experimental Design', '(value, point=None)', 'Evaluate a anova table at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('experimentalDesignEvaluateAssignmentRule', 'Experimental Design', '(value, point=None)', 'Evaluate a assignment rule at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('experimentalDesignEvaluateBlockDesign', 'Experimental Design', '(value, point=None)', 'Evaluate a block design at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('experimentalDesignEvaluateFactorialDesign', 'Experimental Design', '(value, point=None)', 'Evaluate a factorial design at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('experimentalDesignEvaluateTreatmentPlan', 'Experimental Design', '(value, point=None)', 'Evaluate a treatment plan at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('experimentalDesignFormatAnovaTable', 'Experimental Design', '(value)', 'Format a anova table for deterministic user-facing output.', 'professional_function_catalog.md'), + ('experimentalDesignFormatAssignmentRule', 'Experimental Design', '(value)', 'Format a assignment rule for deterministic user-facing output.', 'professional_function_catalog.md'), + ('experimentalDesignFormatBlockDesign', 'Experimental Design', '(value)', 'Format a block design for deterministic user-facing output.', 'professional_function_catalog.md'), + ('experimentalDesignFormatFactorialDesign', 'Experimental Design', '(value)', 'Format a factorial design for deterministic user-facing output.', 'professional_function_catalog.md'), + ('experimentalDesignFormatTreatmentPlan', 'Experimental Design', '(value)', 'Format a treatment plan for deterministic user-facing output.', 'professional_function_catalog.md'), + ('experimentalDesignGenerateExampleAnovaTable', 'Experimental Design', '(size=3)', 'Generate a small documented example of a anova table.', 'professional_function_catalog.md'), + ('experimentalDesignGenerateExampleAssignmentRule', 'Experimental Design', '(size=3)', 'Generate a small documented example of a assignment rule.', 'professional_function_catalog.md'), + ('experimentalDesignGenerateExampleBlockDesign', 'Experimental Design', '(size=3)', 'Generate a small documented example of a block design.', 'professional_function_catalog.md'), + ('experimentalDesignGenerateExampleFactorialDesign', 'Experimental Design', '(size=3)', 'Generate a small documented example of a factorial design.', 'professional_function_catalog.md'), + ('experimentalDesignGenerateExampleTreatmentPlan', 'Experimental Design', '(size=3)', 'Generate a small documented example of a treatment plan.', 'professional_function_catalog.md'), + ('experimentalDesignNormalizeAnovaTable', 'Experimental Design', '(value)', 'Normalize a anova table into the standard Experimental Design representation.', 'professional_function_catalog.md'), + ('experimentalDesignNormalizeAssignmentRule', 'Experimental Design', '(value)', 'Normalize a assignment rule into the standard Experimental Design representation.', 'professional_function_catalog.md'), + ('experimentalDesignNormalizeBlockDesign', 'Experimental Design', '(value)', 'Normalize a block design into the standard Experimental Design representation.', 'professional_function_catalog.md'), + ('experimentalDesignNormalizeFactorialDesign', 'Experimental Design', '(value)', 'Normalize a factorial design into the standard Experimental Design representation.', 'professional_function_catalog.md'), + ('experimentalDesignNormalizeTreatmentPlan', 'Experimental Design', '(value)', 'Normalize a treatment plan into the standard Experimental Design representation.', 'professional_function_catalog.md'), + ('experimentalDesignParseAnovaTable', 'Experimental Design', '(text)', 'Parse a text or structured value into a anova table.', 'professional_function_catalog.md'), + ('experimentalDesignParseAssignmentRule', 'Experimental Design', '(text)', 'Parse a text or structured value into a assignment rule.', 'professional_function_catalog.md'), + ('experimentalDesignParseBlockDesign', 'Experimental Design', '(text)', 'Parse a text or structured value into a block design.', 'professional_function_catalog.md'), + ('experimentalDesignParseFactorialDesign', 'Experimental Design', '(text)', 'Parse a text or structured value into a factorial design.', 'professional_function_catalog.md'), + ('experimentalDesignParseTreatmentPlan', 'Experimental Design', '(text)', 'Parse a text or structured value into a treatment plan.', 'professional_function_catalog.md'), + ('experimentalDesignSimplifyAnovaTable', 'Experimental Design', '(value)', 'Simplify a anova table without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('experimentalDesignSimplifyAssignmentRule', 'Experimental Design', '(value)', 'Simplify a assignment rule without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('experimentalDesignSimplifyBlockDesign', 'Experimental Design', '(value)', 'Simplify a block design without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('experimentalDesignSimplifyFactorialDesign', 'Experimental Design', '(value)', 'Simplify a factorial design without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('experimentalDesignSimplifyTreatmentPlan', 'Experimental Design', '(value)', 'Simplify a treatment plan without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('experimentalDesignTestEquivalenceAnovaTable', 'Experimental Design', '(left, right)', 'Test whether two anova table values are equivalent in Experimental Design.', 'professional_function_catalog.md'), + ('experimentalDesignTestEquivalenceAssignmentRule', 'Experimental Design', '(left, right)', 'Test whether two assignment rule values are equivalent in Experimental Design.', 'professional_function_catalog.md'), + ('experimentalDesignTestEquivalenceBlockDesign', 'Experimental Design', '(left, right)', 'Test whether two block design values are equivalent in Experimental Design.', 'professional_function_catalog.md'), + ('experimentalDesignTestEquivalenceFactorialDesign', 'Experimental Design', '(left, right)', 'Test whether two factorial design values are equivalent in Experimental Design.', 'professional_function_catalog.md'), + ('experimentalDesignTestEquivalenceTreatmentPlan', 'Experimental Design', '(left, right)', 'Test whether two treatment plan values are equivalent in Experimental Design.', 'professional_function_catalog.md'), + ('experimentalDesignTransformAnovaTable', 'Experimental Design', '(value, mapping)', 'Transform a anova table through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('experimentalDesignTransformAssignmentRule', 'Experimental Design', '(value, mapping)', 'Transform a assignment rule through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('experimentalDesignTransformBlockDesign', 'Experimental Design', '(value, mapping)', 'Transform a block design through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('experimentalDesignTransformFactorialDesign', 'Experimental Design', '(value, mapping)', 'Transform a factorial design through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('experimentalDesignTransformTreatmentPlan', 'Experimental Design', '(value, mapping)', 'Transform a treatment plan through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('experimentalDesignValidateAnovaTable', 'Experimental Design', '(value)', 'Validate the anova table representation and domain rules for Experimental Design.', 'professional_function_catalog.md'), + ('experimentalDesignValidateAssignmentRule', 'Experimental Design', '(value)', 'Validate the assignment rule representation and domain rules for Experimental Design.', 'professional_function_catalog.md'), + ('experimentalDesignValidateBlockDesign', 'Experimental Design', '(value)', 'Validate the block design representation and domain rules for Experimental Design.', 'professional_function_catalog.md'), + ('experimentalDesignValidateFactorialDesign', 'Experimental Design', '(value)', 'Validate the factorial design representation and domain rules for Experimental Design.', 'professional_function_catalog.md'), + ('experimentalDesignValidateTreatmentPlan', 'Experimental Design', '(value)', 'Validate the treatment plan representation and domain rules for Experimental Design.', 'professional_function_catalog.md'), + ('factorialDesign', 'Experimental Design', '(factors)', 'Planned roadmap function for Experimental Design from upcoming.md.', 'upcoming.md'), + ('latinSquare', 'Experimental Design', '(n)', 'Planned roadmap function for Experimental Design from upcoming.md.', 'upcoming.md'), + ('minimumDetectableEffect', 'Experimental Design', '(stdDev, n, alpha, power)', 'Planned roadmap function for Experimental Design from upcoming.md.', 'upcoming.md'), + ('treatmentMeans', 'Experimental Design', '(data, treatmentLabels)', 'Planned roadmap function for Experimental Design from upcoming.md.', 'upcoming.md'), + ('fieldAdd', 'Finite Fields', '(a, b, p)', 'Planned roadmap function for Finite Fields from upcoming.md.', 'upcoming.md'), + ('fieldDivide', 'Finite Fields', '(a, b, p)', 'Planned roadmap function for Finite Fields from upcoming.md.', 'upcoming.md'), + ('fieldInverse', 'Finite Fields', '(a, p)', 'Planned roadmap function for Finite Fields from upcoming.md.', 'upcoming.md'), + ('fieldMultiply', 'Finite Fields', '(a, b, p)', 'Planned roadmap function for Finite Fields from upcoming.md.', 'upcoming.md'), + ('fieldPower', 'Finite Fields', '(a, n, p)', 'Planned roadmap function for Finite Fields from upcoming.md.', 'upcoming.md'), + ('fieldSubtract', 'Finite Fields', '(a, b, p)', 'Planned roadmap function for Finite Fields from upcoming.md.', 'upcoming.md'), + ('finiteFieldsApproximateExtensionField', 'Finite Fields', '(value, tolerance=1e-9)', 'Approximate a extension field with explicit tolerance controls.', 'professional_function_catalog.md'), + ('finiteFieldsApproximateFieldElement', 'Finite Fields', '(value, tolerance=1e-9)', 'Approximate a field element with explicit tolerance controls.', 'professional_function_catalog.md'), + ('finiteFieldsApproximateFieldPolynomial', 'Finite Fields', '(value, tolerance=1e-9)', 'Approximate a field polynomial with explicit tolerance controls.', 'professional_function_catalog.md'), + ('finiteFieldsApproximatePrimeField', 'Finite Fields', '(value, tolerance=1e-9)', 'Approximate a prime field with explicit tolerance controls.', 'professional_function_catalog.md'), + ('finiteFieldsApproximatePrimitiveElement', 'Finite Fields', '(value, tolerance=1e-9)', 'Approximate a primitive element with explicit tolerance controls.', 'professional_function_catalog.md'), + ('finiteFieldsCanonicalizeExtensionField', 'Finite Fields', '(value)', 'Canonicalize a extension field so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('finiteFieldsCanonicalizeFieldElement', 'Finite Fields', '(value)', 'Canonicalize a field element so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('finiteFieldsCanonicalizeFieldPolynomial', 'Finite Fields', '(value)', 'Canonicalize a field polynomial so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('finiteFieldsCanonicalizePrimeField', 'Finite Fields', '(value)', 'Canonicalize a prime field so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('finiteFieldsCanonicalizePrimitiveElement', 'Finite Fields', '(value)', 'Canonicalize a primitive element so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('finiteFieldsClassifyExtensionField', 'Finite Fields', '(value)', 'Classify a extension field by its standard Finite Fields invariants.', 'professional_function_catalog.md'), + ('finiteFieldsClassifyFieldElement', 'Finite Fields', '(value)', 'Classify a field element by its standard Finite Fields invariants.', 'professional_function_catalog.md'), + ('finiteFieldsClassifyFieldPolynomial', 'Finite Fields', '(value)', 'Classify a field polynomial by its standard Finite Fields invariants.', 'professional_function_catalog.md'), + ('finiteFieldsClassifyPrimeField', 'Finite Fields', '(value)', 'Classify a prime field by its standard Finite Fields invariants.', 'professional_function_catalog.md'), + ('finiteFieldsClassifyPrimitiveElement', 'Finite Fields', '(value)', 'Classify a primitive element by its standard Finite Fields invariants.', 'professional_function_catalog.md'), + ('finiteFieldsCombineExtensionField', 'Finite Fields', '(left, right)', 'Combine two extension field values with the natural operation for Finite Fields.', 'professional_function_catalog.md'), + ('finiteFieldsCombineFieldElement', 'Finite Fields', '(left, right)', 'Combine two field element values with the natural operation for Finite Fields.', 'professional_function_catalog.md'), + ('finiteFieldsCombineFieldPolynomial', 'Finite Fields', '(left, right)', 'Combine two field polynomial values with the natural operation for Finite Fields.', 'professional_function_catalog.md'), + ('finiteFieldsCombinePrimeField', 'Finite Fields', '(left, right)', 'Combine two prime field values with the natural operation for Finite Fields.', 'professional_function_catalog.md'), + ('finiteFieldsCombinePrimitiveElement', 'Finite Fields', '(left, right)', 'Combine two primitive element values with the natural operation for Finite Fields.', 'professional_function_catalog.md'), + ('finiteFieldsCompareExtensionField', 'Finite Fields', '(left, right)', 'Compare two extension field values under the conventions of Finite Fields.', 'professional_function_catalog.md'), + ('finiteFieldsCompareFieldElement', 'Finite Fields', '(left, right)', 'Compare two field element values under the conventions of Finite Fields.', 'professional_function_catalog.md'), + ('finiteFieldsCompareFieldPolynomial', 'Finite Fields', '(left, right)', 'Compare two field polynomial values under the conventions of Finite Fields.', 'professional_function_catalog.md'), + ('finiteFieldsComparePrimeField', 'Finite Fields', '(left, right)', 'Compare two prime field values under the conventions of Finite Fields.', 'professional_function_catalog.md'), + ('finiteFieldsComparePrimitiveElement', 'Finite Fields', '(left, right)', 'Compare two primitive element values under the conventions of Finite Fields.', 'professional_function_catalog.md'), + ('finiteFieldsComputeExtensionField', 'Finite Fields', '(value)', 'Compute the central numerical or symbolic data of a extension field.', 'professional_function_catalog.md'), + ('finiteFieldsComputeFieldElement', 'Finite Fields', '(value)', 'Compute the central numerical or symbolic data of a field element.', 'professional_function_catalog.md'), + ('finiteFieldsComputeFieldPolynomial', 'Finite Fields', '(value)', 'Compute the central numerical or symbolic data of a field polynomial.', 'professional_function_catalog.md'), + ('finiteFieldsComputePrimeField', 'Finite Fields', '(value)', 'Compute the central numerical or symbolic data of a prime field.', 'professional_function_catalog.md'), + ('finiteFieldsComputePrimitiveElement', 'Finite Fields', '(value)', 'Compute the central numerical or symbolic data of a primitive element.', 'professional_function_catalog.md'), + ('finiteFieldsConstructExtensionField', 'Finite Fields', '(*args)', 'Construct a extension field from explicit inputs for Finite Fields.', 'professional_function_catalog.md'), + ('finiteFieldsConstructFieldElement', 'Finite Fields', '(*args)', 'Construct a field element from explicit inputs for Finite Fields.', 'professional_function_catalog.md'), + ('finiteFieldsConstructFieldPolynomial', 'Finite Fields', '(*args)', 'Construct a field polynomial from explicit inputs for Finite Fields.', 'professional_function_catalog.md'), + ('finiteFieldsConstructPrimeField', 'Finite Fields', '(*args)', 'Construct a prime field from explicit inputs for Finite Fields.', 'professional_function_catalog.md'), + ('finiteFieldsConstructPrimitiveElement', 'Finite Fields', '(*args)', 'Construct a primitive element from explicit inputs for Finite Fields.', 'professional_function_catalog.md'), + ('finiteFieldsDecomposeExtensionField', 'Finite Fields', '(value)', 'Decompose a extension field into simpler or canonical components.', 'professional_function_catalog.md'), + ('finiteFieldsDecomposeFieldElement', 'Finite Fields', '(value)', 'Decompose a field element into simpler or canonical components.', 'professional_function_catalog.md'), + ('finiteFieldsDecomposeFieldPolynomial', 'Finite Fields', '(value)', 'Decompose a field polynomial into simpler or canonical components.', 'professional_function_catalog.md'), + ('finiteFieldsDecomposePrimeField', 'Finite Fields', '(value)', 'Decompose a prime field into simpler or canonical components.', 'professional_function_catalog.md'), + ('finiteFieldsDecomposePrimitiveElement', 'Finite Fields', '(value)', 'Decompose a primitive element into simpler or canonical components.', 'professional_function_catalog.md'), + ('finiteFieldsDocumentExtensionField', 'Finite Fields', '(value)', 'Return a structured explanation of a extension field and related assumptions.', 'professional_function_catalog.md'), + ('finiteFieldsDocumentFieldElement', 'Finite Fields', '(value)', 'Return a structured explanation of a field element and related assumptions.', 'professional_function_catalog.md'), + ('finiteFieldsDocumentFieldPolynomial', 'Finite Fields', '(value)', 'Return a structured explanation of a field polynomial and related assumptions.', 'professional_function_catalog.md'), + ('finiteFieldsDocumentPrimeField', 'Finite Fields', '(value)', 'Return a structured explanation of a prime field and related assumptions.', 'professional_function_catalog.md'), + ('finiteFieldsDocumentPrimitiveElement', 'Finite Fields', '(value)', 'Return a structured explanation of a primitive element and related assumptions.', 'professional_function_catalog.md'), + ('finiteFieldsEnumerateExtensionField', 'Finite Fields', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a extension field.', 'professional_function_catalog.md'), + ('finiteFieldsEnumerateFieldElement', 'Finite Fields', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a field element.', 'professional_function_catalog.md'), + ('finiteFieldsEnumerateFieldPolynomial', 'Finite Fields', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a field polynomial.', 'professional_function_catalog.md'), + ('finiteFieldsEnumeratePrimeField', 'Finite Fields', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a prime field.', 'professional_function_catalog.md'), + ('finiteFieldsEnumeratePrimitiveElement', 'Finite Fields', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a primitive element.', 'professional_function_catalog.md'), + ('finiteFieldsEstimateExtensionField', 'Finite Fields', '(value, samples=None)', 'Estimate a extension field property from finite samples or approximations.', 'professional_function_catalog.md'), + ('finiteFieldsEstimateFieldElement', 'Finite Fields', '(value, samples=None)', 'Estimate a field element property from finite samples or approximations.', 'professional_function_catalog.md'), + ('finiteFieldsEstimateFieldPolynomial', 'Finite Fields', '(value, samples=None)', 'Estimate a field polynomial property from finite samples or approximations.', 'professional_function_catalog.md'), + ('finiteFieldsEstimatePrimeField', 'Finite Fields', '(value, samples=None)', 'Estimate a prime field property from finite samples or approximations.', 'professional_function_catalog.md'), + ('finiteFieldsEstimatePrimitiveElement', 'Finite Fields', '(value, samples=None)', 'Estimate a primitive element property from finite samples or approximations.', 'professional_function_catalog.md'), + ('finiteFieldsEvaluateExtensionField', 'Finite Fields', '(value, point=None)', 'Evaluate a extension field at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('finiteFieldsEvaluateFieldElement', 'Finite Fields', '(value, point=None)', 'Evaluate a field element at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('finiteFieldsEvaluateFieldPolynomial', 'Finite Fields', '(value, point=None)', 'Evaluate a field polynomial at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('finiteFieldsEvaluatePrimeField', 'Finite Fields', '(value, point=None)', 'Evaluate a prime field at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('finiteFieldsEvaluatePrimitiveElement', 'Finite Fields', '(value, point=None)', 'Evaluate a primitive element at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('finiteFieldsFormatExtensionField', 'Finite Fields', '(value)', 'Format a extension field for deterministic user-facing output.', 'professional_function_catalog.md'), + ('finiteFieldsFormatFieldElement', 'Finite Fields', '(value)', 'Format a field element for deterministic user-facing output.', 'professional_function_catalog.md'), + ('finiteFieldsFormatFieldPolynomial', 'Finite Fields', '(value)', 'Format a field polynomial for deterministic user-facing output.', 'professional_function_catalog.md'), + ('finiteFieldsFormatPrimeField', 'Finite Fields', '(value)', 'Format a prime field for deterministic user-facing output.', 'professional_function_catalog.md'), + ('finiteFieldsFormatPrimitiveElement', 'Finite Fields', '(value)', 'Format a primitive element for deterministic user-facing output.', 'professional_function_catalog.md'), + ('finiteFieldsGenerateExampleExtensionField', 'Finite Fields', '(size=3)', 'Generate a small documented example of a extension field.', 'professional_function_catalog.md'), + ('finiteFieldsGenerateExampleFieldElement', 'Finite Fields', '(size=3)', 'Generate a small documented example of a field element.', 'professional_function_catalog.md'), + ('finiteFieldsGenerateExampleFieldPolynomial', 'Finite Fields', '(size=3)', 'Generate a small documented example of a field polynomial.', 'professional_function_catalog.md'), + ('finiteFieldsGenerateExamplePrimeField', 'Finite Fields', '(size=3)', 'Generate a small documented example of a prime field.', 'professional_function_catalog.md'), + ('finiteFieldsGenerateExamplePrimitiveElement', 'Finite Fields', '(size=3)', 'Generate a small documented example of a primitive element.', 'professional_function_catalog.md'), + ('finiteFieldsNormalizeExtensionField', 'Finite Fields', '(value)', 'Normalize a extension field into the standard Finite Fields representation.', 'professional_function_catalog.md'), + ('finiteFieldsNormalizeFieldElement', 'Finite Fields', '(value)', 'Normalize a field element into the standard Finite Fields representation.', 'professional_function_catalog.md'), + ('finiteFieldsNormalizeFieldPolynomial', 'Finite Fields', '(value)', 'Normalize a field polynomial into the standard Finite Fields representation.', 'professional_function_catalog.md'), + ('finiteFieldsNormalizePrimeField', 'Finite Fields', '(value)', 'Normalize a prime field into the standard Finite Fields representation.', 'professional_function_catalog.md'), + ('finiteFieldsNormalizePrimitiveElement', 'Finite Fields', '(value)', 'Normalize a primitive element into the standard Finite Fields representation.', 'professional_function_catalog.md'), + ('finiteFieldsParseExtensionField', 'Finite Fields', '(text)', 'Parse a text or structured value into a extension field.', 'professional_function_catalog.md'), + ('finiteFieldsParseFieldElement', 'Finite Fields', '(text)', 'Parse a text or structured value into a field element.', 'professional_function_catalog.md'), + ('finiteFieldsParseFieldPolynomial', 'Finite Fields', '(text)', 'Parse a text or structured value into a field polynomial.', 'professional_function_catalog.md'), + ('finiteFieldsParsePrimeField', 'Finite Fields', '(text)', 'Parse a text or structured value into a prime field.', 'professional_function_catalog.md'), + ('finiteFieldsParsePrimitiveElement', 'Finite Fields', '(text)', 'Parse a text or structured value into a primitive element.', 'professional_function_catalog.md'), + ('finiteFieldsSimplifyExtensionField', 'Finite Fields', '(value)', 'Simplify a extension field without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('finiteFieldsSimplifyFieldElement', 'Finite Fields', '(value)', 'Simplify a field element without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('finiteFieldsSimplifyFieldPolynomial', 'Finite Fields', '(value)', 'Simplify a field polynomial without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('finiteFieldsSimplifyPrimeField', 'Finite Fields', '(value)', 'Simplify a prime field without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('finiteFieldsSimplifyPrimitiveElement', 'Finite Fields', '(value)', 'Simplify a primitive element without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('finiteFieldsTestEquivalenceExtensionField', 'Finite Fields', '(left, right)', 'Test whether two extension field values are equivalent in Finite Fields.', 'professional_function_catalog.md'), + ('finiteFieldsTestEquivalenceFieldElement', 'Finite Fields', '(left, right)', 'Test whether two field element values are equivalent in Finite Fields.', 'professional_function_catalog.md'), + ('finiteFieldsTestEquivalenceFieldPolynomial', 'Finite Fields', '(left, right)', 'Test whether two field polynomial values are equivalent in Finite Fields.', 'professional_function_catalog.md'), + ('finiteFieldsTestEquivalencePrimeField', 'Finite Fields', '(left, right)', 'Test whether two prime field values are equivalent in Finite Fields.', 'professional_function_catalog.md'), + ('finiteFieldsTestEquivalencePrimitiveElement', 'Finite Fields', '(left, right)', 'Test whether two primitive element values are equivalent in Finite Fields.', 'professional_function_catalog.md'), + ('finiteFieldsTransformExtensionField', 'Finite Fields', '(value, mapping)', 'Transform a extension field through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('finiteFieldsTransformFieldElement', 'Finite Fields', '(value, mapping)', 'Transform a field element through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('finiteFieldsTransformFieldPolynomial', 'Finite Fields', '(value, mapping)', 'Transform a field polynomial through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('finiteFieldsTransformPrimeField', 'Finite Fields', '(value, mapping)', 'Transform a prime field through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('finiteFieldsTransformPrimitiveElement', 'Finite Fields', '(value, mapping)', 'Transform a primitive element through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('finiteFieldsValidateExtensionField', 'Finite Fields', '(value)', 'Validate the extension field representation and domain rules for Finite Fields.', 'professional_function_catalog.md'), + ('finiteFieldsValidateFieldElement', 'Finite Fields', '(value)', 'Validate the field element representation and domain rules for Finite Fields.', 'professional_function_catalog.md'), + ('finiteFieldsValidateFieldPolynomial', 'Finite Fields', '(value)', 'Validate the field polynomial representation and domain rules for Finite Fields.', 'professional_function_catalog.md'), + ('finiteFieldsValidatePrimeField', 'Finite Fields', '(value)', 'Validate the prime field representation and domain rules for Finite Fields.', 'professional_function_catalog.md'), + ('finiteFieldsValidatePrimitiveElement', 'Finite Fields', '(value)', 'Validate the primitive element representation and domain rules for Finite Fields.', 'professional_function_catalog.md'), + ('isPrimitiveRoot', 'Finite Fields', '(g, p)', 'Planned roadmap function for Finite Fields from upcoming.md.', 'upcoming.md'), + ('multiplicativeOrderMod', 'Finite Fields', '(a, p)', 'Planned roadmap function for Finite Fields from upcoming.md.', 'upcoming.md'), + ('convolution', 'Fourier Analysis', '(sequenceA, sequenceB)', 'Planned roadmap function for Fourier Analysis from upcoming.md.', 'upcoming.md'), + ('cosineSeriesCoefficient', 'Fourier Analysis', '(f, n, a, b)', 'Planned roadmap function for Fourier Analysis from upcoming.md.', 'upcoming.md'), + ('discreteFourierTransform', 'Fourier Analysis', '(values)', 'Planned roadmap function for Fourier Analysis from upcoming.md.', 'upcoming.md'), + ('fourierAnalysisApproximateConvolutionModel', 'Fourier Analysis', '(value, tolerance=1e-9)', 'Approximate a convolution model with explicit tolerance controls.', 'professional_function_catalog.md'), + ('fourierAnalysisApproximateFrequencyCoefficient', 'Fourier Analysis', '(value, tolerance=1e-9)', 'Approximate a frequency coefficient with explicit tolerance controls.', 'professional_function_catalog.md'), + ('fourierAnalysisApproximateKernel', 'Fourier Analysis', '(value, tolerance=1e-9)', 'Approximate a kernel with explicit tolerance controls.', 'professional_function_catalog.md'), + ('fourierAnalysisApproximateSignal', 'Fourier Analysis', '(value, tolerance=1e-9)', 'Approximate a signal with explicit tolerance controls.', 'professional_function_catalog.md'), + ('fourierAnalysisApproximateTransform', 'Fourier Analysis', '(value, tolerance=1e-9)', 'Approximate a transform with explicit tolerance controls.', 'professional_function_catalog.md'), + ('fourierAnalysisCanonicalizeConvolutionModel', 'Fourier Analysis', '(value)', 'Canonicalize a convolution model so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('fourierAnalysisCanonicalizeFrequencyCoefficient', 'Fourier Analysis', '(value)', 'Canonicalize a frequency coefficient so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('fourierAnalysisCanonicalizeKernel', 'Fourier Analysis', '(value)', 'Canonicalize a kernel so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('fourierAnalysisCanonicalizeSignal', 'Fourier Analysis', '(value)', 'Canonicalize a signal so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('fourierAnalysisCanonicalizeTransform', 'Fourier Analysis', '(value)', 'Canonicalize a transform so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('fourierAnalysisClassifyConvolutionModel', 'Fourier Analysis', '(value)', 'Classify a convolution model by its standard Fourier Analysis invariants.', 'professional_function_catalog.md'), + ('fourierAnalysisClassifyFrequencyCoefficient', 'Fourier Analysis', '(value)', 'Classify a frequency coefficient by its standard Fourier Analysis invariants.', 'professional_function_catalog.md'), + ('fourierAnalysisClassifyKernel', 'Fourier Analysis', '(value)', 'Classify a kernel by its standard Fourier Analysis invariants.', 'professional_function_catalog.md'), + ('fourierAnalysisClassifySignal', 'Fourier Analysis', '(value)', 'Classify a signal by its standard Fourier Analysis invariants.', 'professional_function_catalog.md'), + ('fourierAnalysisClassifyTransform', 'Fourier Analysis', '(value)', 'Classify a transform by its standard Fourier Analysis invariants.', 'professional_function_catalog.md'), + ('fourierAnalysisCombineConvolutionModel', 'Fourier Analysis', '(left, right)', 'Combine two convolution model values with the natural operation for Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierAnalysisCombineFrequencyCoefficient', 'Fourier Analysis', '(left, right)', 'Combine two frequency coefficient values with the natural operation for Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierAnalysisCombineKernel', 'Fourier Analysis', '(left, right)', 'Combine two kernel values with the natural operation for Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierAnalysisCombineSignal', 'Fourier Analysis', '(left, right)', 'Combine two signal values with the natural operation for Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierAnalysisCombineTransform', 'Fourier Analysis', '(left, right)', 'Combine two transform values with the natural operation for Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierAnalysisCompareConvolutionModel', 'Fourier Analysis', '(left, right)', 'Compare two convolution model values under the conventions of Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierAnalysisCompareFrequencyCoefficient', 'Fourier Analysis', '(left, right)', 'Compare two frequency coefficient values under the conventions of Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierAnalysisCompareKernel', 'Fourier Analysis', '(left, right)', 'Compare two kernel values under the conventions of Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierAnalysisCompareSignal', 'Fourier Analysis', '(left, right)', 'Compare two signal values under the conventions of Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierAnalysisCompareTransform', 'Fourier Analysis', '(left, right)', 'Compare two transform values under the conventions of Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierAnalysisComputeConvolutionModel', 'Fourier Analysis', '(value)', 'Compute the central numerical or symbolic data of a convolution model.', 'professional_function_catalog.md'), + ('fourierAnalysisComputeFrequencyCoefficient', 'Fourier Analysis', '(value)', 'Compute the central numerical or symbolic data of a frequency coefficient.', 'professional_function_catalog.md'), + ('fourierAnalysisComputeKernel', 'Fourier Analysis', '(value)', 'Compute the central numerical or symbolic data of a kernel.', 'professional_function_catalog.md'), + ('fourierAnalysisComputeSignal', 'Fourier Analysis', '(value)', 'Compute the central numerical or symbolic data of a signal.', 'professional_function_catalog.md'), + ('fourierAnalysisComputeTransform', 'Fourier Analysis', '(value)', 'Compute the central numerical or symbolic data of a transform.', 'professional_function_catalog.md'), + ('fourierAnalysisConstructConvolutionModel', 'Fourier Analysis', '(*args)', 'Construct a convolution model from explicit inputs for Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierAnalysisConstructFrequencyCoefficient', 'Fourier Analysis', '(*args)', 'Construct a frequency coefficient from explicit inputs for Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierAnalysisConstructKernel', 'Fourier Analysis', '(*args)', 'Construct a kernel from explicit inputs for Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierAnalysisConstructSignal', 'Fourier Analysis', '(*args)', 'Construct a signal from explicit inputs for Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierAnalysisConstructTransform', 'Fourier Analysis', '(*args)', 'Construct a transform from explicit inputs for Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierAnalysisDecomposeConvolutionModel', 'Fourier Analysis', '(value)', 'Decompose a convolution model into simpler or canonical components.', 'professional_function_catalog.md'), + ('fourierAnalysisDecomposeFrequencyCoefficient', 'Fourier Analysis', '(value)', 'Decompose a frequency coefficient into simpler or canonical components.', 'professional_function_catalog.md'), + ('fourierAnalysisDecomposeKernel', 'Fourier Analysis', '(value)', 'Decompose a kernel into simpler or canonical components.', 'professional_function_catalog.md'), + ('fourierAnalysisDecomposeSignal', 'Fourier Analysis', '(value)', 'Decompose a signal into simpler or canonical components.', 'professional_function_catalog.md'), + ('fourierAnalysisDecomposeTransform', 'Fourier Analysis', '(value)', 'Decompose a transform into simpler or canonical components.', 'professional_function_catalog.md'), + ('fourierAnalysisDocumentConvolutionModel', 'Fourier Analysis', '(value)', 'Return a structured explanation of a convolution model and related assumptions.', 'professional_function_catalog.md'), + ('fourierAnalysisDocumentFrequencyCoefficient', 'Fourier Analysis', '(value)', 'Return a structured explanation of a frequency coefficient and related assumptions.', 'professional_function_catalog.md'), + ('fourierAnalysisDocumentKernel', 'Fourier Analysis', '(value)', 'Return a structured explanation of a kernel and related assumptions.', 'professional_function_catalog.md'), + ('fourierAnalysisDocumentSignal', 'Fourier Analysis', '(value)', 'Return a structured explanation of a signal and related assumptions.', 'professional_function_catalog.md'), + ('fourierAnalysisDocumentTransform', 'Fourier Analysis', '(value)', 'Return a structured explanation of a transform and related assumptions.', 'professional_function_catalog.md'), + ('fourierAnalysisEnumerateConvolutionModel', 'Fourier Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a convolution model.', 'professional_function_catalog.md'), + ('fourierAnalysisEnumerateFrequencyCoefficient', 'Fourier Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a frequency coefficient.', 'professional_function_catalog.md'), + ('fourierAnalysisEnumerateKernel', 'Fourier Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a kernel.', 'professional_function_catalog.md'), + ('fourierAnalysisEnumerateSignal', 'Fourier Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a signal.', 'professional_function_catalog.md'), + ('fourierAnalysisEnumerateTransform', 'Fourier Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a transform.', 'professional_function_catalog.md'), + ('fourierAnalysisEstimateConvolutionModel', 'Fourier Analysis', '(value, samples=None)', 'Estimate a convolution model property from finite samples or approximations.', 'professional_function_catalog.md'), + ('fourierAnalysisEstimateFrequencyCoefficient', 'Fourier Analysis', '(value, samples=None)', 'Estimate a frequency coefficient property from finite samples or approximations.', 'professional_function_catalog.md'), + ('fourierAnalysisEstimateKernel', 'Fourier Analysis', '(value, samples=None)', 'Estimate a kernel property from finite samples or approximations.', 'professional_function_catalog.md'), + ('fourierAnalysisEstimateSignal', 'Fourier Analysis', '(value, samples=None)', 'Estimate a signal property from finite samples or approximations.', 'professional_function_catalog.md'), + ('fourierAnalysisEstimateTransform', 'Fourier Analysis', '(value, samples=None)', 'Estimate a transform property from finite samples or approximations.', 'professional_function_catalog.md'), + ('fourierAnalysisEvaluateConvolutionModel', 'Fourier Analysis', '(value, point=None)', 'Evaluate a convolution model at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('fourierAnalysisEvaluateFrequencyCoefficient', 'Fourier Analysis', '(value, point=None)', 'Evaluate a frequency coefficient at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('fourierAnalysisEvaluateKernel', 'Fourier Analysis', '(value, point=None)', 'Evaluate a kernel at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('fourierAnalysisEvaluateSignal', 'Fourier Analysis', '(value, point=None)', 'Evaluate a signal at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('fourierAnalysisEvaluateTransform', 'Fourier Analysis', '(value, point=None)', 'Evaluate a transform at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('fourierAnalysisFormatConvolutionModel', 'Fourier Analysis', '(value)', 'Format a convolution model for deterministic user-facing output.', 'professional_function_catalog.md'), + ('fourierAnalysisFormatFrequencyCoefficient', 'Fourier Analysis', '(value)', 'Format a frequency coefficient for deterministic user-facing output.', 'professional_function_catalog.md'), + ('fourierAnalysisFormatKernel', 'Fourier Analysis', '(value)', 'Format a kernel for deterministic user-facing output.', 'professional_function_catalog.md'), + ('fourierAnalysisFormatSignal', 'Fourier Analysis', '(value)', 'Format a signal for deterministic user-facing output.', 'professional_function_catalog.md'), + ('fourierAnalysisFormatTransform', 'Fourier Analysis', '(value)', 'Format a transform for deterministic user-facing output.', 'professional_function_catalog.md'), + ('fourierAnalysisGenerateExampleConvolutionModel', 'Fourier Analysis', '(size=3)', 'Generate a small documented example of a convolution model.', 'professional_function_catalog.md'), + ('fourierAnalysisGenerateExampleFrequencyCoefficient', 'Fourier Analysis', '(size=3)', 'Generate a small documented example of a frequency coefficient.', 'professional_function_catalog.md'), + ('fourierAnalysisGenerateExampleKernel', 'Fourier Analysis', '(size=3)', 'Generate a small documented example of a kernel.', 'professional_function_catalog.md'), + ('fourierAnalysisGenerateExampleSignal', 'Fourier Analysis', '(size=3)', 'Generate a small documented example of a signal.', 'professional_function_catalog.md'), + ('fourierAnalysisGenerateExampleTransform', 'Fourier Analysis', '(size=3)', 'Generate a small documented example of a transform.', 'professional_function_catalog.md'), + ('fourierAnalysisNormalizeConvolutionModel', 'Fourier Analysis', '(value)', 'Normalize a convolution model into the standard Fourier Analysis representation.', 'professional_function_catalog.md'), + ('fourierAnalysisNormalizeFrequencyCoefficient', 'Fourier Analysis', '(value)', 'Normalize a frequency coefficient into the standard Fourier Analysis representation.', 'professional_function_catalog.md'), + ('fourierAnalysisNormalizeKernel', 'Fourier Analysis', '(value)', 'Normalize a kernel into the standard Fourier Analysis representation.', 'professional_function_catalog.md'), + ('fourierAnalysisNormalizeSignal', 'Fourier Analysis', '(value)', 'Normalize a signal into the standard Fourier Analysis representation.', 'professional_function_catalog.md'), + ('fourierAnalysisNormalizeTransform', 'Fourier Analysis', '(value)', 'Normalize a transform into the standard Fourier Analysis representation.', 'professional_function_catalog.md'), + ('fourierAnalysisParseConvolutionModel', 'Fourier Analysis', '(text)', 'Parse a text or structured value into a convolution model.', 'professional_function_catalog.md'), + ('fourierAnalysisParseFrequencyCoefficient', 'Fourier Analysis', '(text)', 'Parse a text or structured value into a frequency coefficient.', 'professional_function_catalog.md'), + ('fourierAnalysisParseKernel', 'Fourier Analysis', '(text)', 'Parse a text or structured value into a kernel.', 'professional_function_catalog.md'), + ('fourierAnalysisParseSignal', 'Fourier Analysis', '(text)', 'Parse a text or structured value into a signal.', 'professional_function_catalog.md'), + ('fourierAnalysisParseTransform', 'Fourier Analysis', '(text)', 'Parse a text or structured value into a transform.', 'professional_function_catalog.md'), + ('fourierAnalysisSimplifyConvolutionModel', 'Fourier Analysis', '(value)', 'Simplify a convolution model without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('fourierAnalysisSimplifyFrequencyCoefficient', 'Fourier Analysis', '(value)', 'Simplify a frequency coefficient without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('fourierAnalysisSimplifyKernel', 'Fourier Analysis', '(value)', 'Simplify a kernel without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('fourierAnalysisSimplifySignal', 'Fourier Analysis', '(value)', 'Simplify a signal without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('fourierAnalysisSimplifyTransform', 'Fourier Analysis', '(value)', 'Simplify a transform without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('fourierAnalysisTestEquivalenceConvolutionModel', 'Fourier Analysis', '(left, right)', 'Test whether two convolution model values are equivalent in Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierAnalysisTestEquivalenceFrequencyCoefficient', 'Fourier Analysis', '(left, right)', 'Test whether two frequency coefficient values are equivalent in Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierAnalysisTestEquivalenceKernel', 'Fourier Analysis', '(left, right)', 'Test whether two kernel values are equivalent in Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierAnalysisTestEquivalenceSignal', 'Fourier Analysis', '(left, right)', 'Test whether two signal values are equivalent in Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierAnalysisTestEquivalenceTransform', 'Fourier Analysis', '(left, right)', 'Test whether two transform values are equivalent in Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierAnalysisTransformConvolutionModel', 'Fourier Analysis', '(value, mapping)', 'Transform a convolution model through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('fourierAnalysisTransformFrequencyCoefficient', 'Fourier Analysis', '(value, mapping)', 'Transform a frequency coefficient through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('fourierAnalysisTransformKernel', 'Fourier Analysis', '(value, mapping)', 'Transform a kernel through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('fourierAnalysisTransformSignal', 'Fourier Analysis', '(value, mapping)', 'Transform a signal through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('fourierAnalysisTransformTransform', 'Fourier Analysis', '(value, mapping)', 'Transform a transform through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('fourierAnalysisValidateConvolutionModel', 'Fourier Analysis', '(value)', 'Validate the convolution model representation and domain rules for Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierAnalysisValidateFrequencyCoefficient', 'Fourier Analysis', '(value)', 'Validate the frequency coefficient representation and domain rules for Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierAnalysisValidateKernel', 'Fourier Analysis', '(value)', 'Validate the kernel representation and domain rules for Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierAnalysisValidateSignal', 'Fourier Analysis', '(value)', 'Validate the signal representation and domain rules for Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierAnalysisValidateTransform', 'Fourier Analysis', '(value)', 'Validate the transform representation and domain rules for Fourier Analysis.', 'professional_function_catalog.md'), + ('fourierSeriesCoefficient', 'Fourier Analysis', '(f, n, a, b)', 'Planned roadmap function for Fourier Analysis from upcoming.md.', 'upcoming.md'), + ('inverseDiscreteFourierTransform', 'Fourier Analysis', '(values)', 'Planned roadmap function for Fourier Analysis from upcoming.md.', 'upcoming.md'), + ('sineSeriesCoefficient', 'Fourier Analysis', '(f, n, a, b)', 'Planned roadmap function for Fourier Analysis from upcoming.md.', 'upcoming.md'), + ('functionalAnalysisApproximateBoundedOperator', 'Functional Analysis', '(value, tolerance=1e-9)', 'Approximate a bounded operator with explicit tolerance controls.', 'professional_function_catalog.md'), + ('functionalAnalysisApproximateCompleteSpace', 'Functional Analysis', '(value, tolerance=1e-9)', 'Approximate a complete space with explicit tolerance controls.', 'professional_function_catalog.md'), + ('functionalAnalysisApproximateInnerProduct', 'Functional Analysis', '(value, tolerance=1e-9)', 'Approximate a inner product with explicit tolerance controls.', 'professional_function_catalog.md'), + ('functionalAnalysisApproximateLinearFunctional', 'Functional Analysis', '(value, tolerance=1e-9)', 'Approximate a linear functional with explicit tolerance controls.', 'professional_function_catalog.md'), + ('functionalAnalysisApproximateNormedSpace', 'Functional Analysis', '(value, tolerance=1e-9)', 'Approximate a normed space with explicit tolerance controls.', 'professional_function_catalog.md'), + ('functionalAnalysisCanonicalizeBoundedOperator', 'Functional Analysis', '(value)', 'Canonicalize a bounded operator so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('functionalAnalysisCanonicalizeCompleteSpace', 'Functional Analysis', '(value)', 'Canonicalize a complete space so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('functionalAnalysisCanonicalizeInnerProduct', 'Functional Analysis', '(value)', 'Canonicalize a inner product so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('functionalAnalysisCanonicalizeLinearFunctional', 'Functional Analysis', '(value)', 'Canonicalize a linear functional so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('functionalAnalysisCanonicalizeNormedSpace', 'Functional Analysis', '(value)', 'Canonicalize a normed space so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('functionalAnalysisClassifyBoundedOperator', 'Functional Analysis', '(value)', 'Classify a bounded operator by its standard Functional Analysis invariants.', 'professional_function_catalog.md'), + ('functionalAnalysisClassifyCompleteSpace', 'Functional Analysis', '(value)', 'Classify a complete space by its standard Functional Analysis invariants.', 'professional_function_catalog.md'), + ('functionalAnalysisClassifyInnerProduct', 'Functional Analysis', '(value)', 'Classify a inner product by its standard Functional Analysis invariants.', 'professional_function_catalog.md'), + ('functionalAnalysisClassifyLinearFunctional', 'Functional Analysis', '(value)', 'Classify a linear functional by its standard Functional Analysis invariants.', 'professional_function_catalog.md'), + ('functionalAnalysisClassifyNormedSpace', 'Functional Analysis', '(value)', 'Classify a normed space by its standard Functional Analysis invariants.', 'professional_function_catalog.md'), + ('functionalAnalysisCombineBoundedOperator', 'Functional Analysis', '(left, right)', 'Combine two bounded operator values with the natural operation for Functional Analysis.', 'professional_function_catalog.md'), + ('functionalAnalysisCombineCompleteSpace', 'Functional Analysis', '(left, right)', 'Combine two complete space values with the natural operation for Functional Analysis.', 'professional_function_catalog.md'), + ('functionalAnalysisCombineInnerProduct', 'Functional Analysis', '(left, right)', 'Combine two inner product values with the natural operation for Functional Analysis.', 'professional_function_catalog.md'), + ('functionalAnalysisCombineLinearFunctional', 'Functional Analysis', '(left, right)', 'Combine two linear functional values with the natural operation for Functional Analysis.', 'professional_function_catalog.md'), + ('functionalAnalysisCombineNormedSpace', 'Functional Analysis', '(left, right)', 'Combine two normed space values with the natural operation for Functional Analysis.', 'professional_function_catalog.md'), + ('functionalAnalysisCompareBoundedOperator', 'Functional Analysis', '(left, right)', 'Compare two bounded operator values under the conventions of Functional Analysis.', 'professional_function_catalog.md'), + ('functionalAnalysisCompareCompleteSpace', 'Functional Analysis', '(left, right)', 'Compare two complete space values under the conventions of Functional Analysis.', 'professional_function_catalog.md'), + ('functionalAnalysisCompareInnerProduct', 'Functional Analysis', '(left, right)', 'Compare two inner product values under the conventions of Functional Analysis.', 'professional_function_catalog.md'), + ('functionalAnalysisCompareLinearFunctional', 'Functional Analysis', '(left, right)', 'Compare two linear functional values under the conventions of Functional Analysis.', 'professional_function_catalog.md'), + ('functionalAnalysisCompareNormedSpace', 'Functional Analysis', '(left, right)', 'Compare two normed space values under the conventions of Functional Analysis.', 'professional_function_catalog.md'), + ('functionalAnalysisComputeBoundedOperator', 'Functional Analysis', '(value)', 'Compute the central numerical or symbolic data of a bounded operator.', 'professional_function_catalog.md'), + ('functionalAnalysisComputeCompleteSpace', 'Functional Analysis', '(value)', 'Compute the central numerical or symbolic data of a complete space.', 'professional_function_catalog.md'), + ('functionalAnalysisComputeInnerProduct', 'Functional Analysis', '(value)', 'Compute the central numerical or symbolic data of a inner product.', 'professional_function_catalog.md'), + ('functionalAnalysisComputeLinearFunctional', 'Functional Analysis', '(value)', 'Compute the central numerical or symbolic data of a linear functional.', 'professional_function_catalog.md'), + ('functionalAnalysisComputeNormedSpace', 'Functional Analysis', '(value)', 'Compute the central numerical or symbolic data of a normed space.', 'professional_function_catalog.md'), + ('functionalAnalysisConstructBoundedOperator', 'Functional Analysis', '(*args)', 'Construct a bounded operator from explicit inputs for Functional Analysis.', 'professional_function_catalog.md'), + ('functionalAnalysisConstructCompleteSpace', 'Functional Analysis', '(*args)', 'Construct a complete space from explicit inputs for Functional Analysis.', 'professional_function_catalog.md'), + ('functionalAnalysisConstructInnerProduct', 'Functional Analysis', '(*args)', 'Construct a inner product from explicit inputs for Functional Analysis.', 'professional_function_catalog.md'), + ('functionalAnalysisConstructLinearFunctional', 'Functional Analysis', '(*args)', 'Construct a linear functional from explicit inputs for Functional Analysis.', 'professional_function_catalog.md'), + ('functionalAnalysisConstructNormedSpace', 'Functional Analysis', '(*args)', 'Construct a normed space from explicit inputs for Functional Analysis.', 'professional_function_catalog.md'), + ('functionalAnalysisDecomposeBoundedOperator', 'Functional Analysis', '(value)', 'Decompose a bounded operator into simpler or canonical components.', 'professional_function_catalog.md'), + ('functionalAnalysisDecomposeCompleteSpace', 'Functional Analysis', '(value)', 'Decompose a complete space into simpler or canonical components.', 'professional_function_catalog.md'), + ('functionalAnalysisDecomposeInnerProduct', 'Functional Analysis', '(value)', 'Decompose a inner product into simpler or canonical components.', 'professional_function_catalog.md'), + ('functionalAnalysisDecomposeLinearFunctional', 'Functional Analysis', '(value)', 'Decompose a linear functional into simpler or canonical components.', 'professional_function_catalog.md'), + ('functionalAnalysisDecomposeNormedSpace', 'Functional Analysis', '(value)', 'Decompose a normed space into simpler or canonical components.', 'professional_function_catalog.md'), + ('functionalAnalysisDocumentBoundedOperator', 'Functional Analysis', '(value)', 'Return a structured explanation of a bounded operator and related assumptions.', 'professional_function_catalog.md'), + ('functionalAnalysisDocumentCompleteSpace', 'Functional Analysis', '(value)', 'Return a structured explanation of a complete space and related assumptions.', 'professional_function_catalog.md'), + ('functionalAnalysisDocumentInnerProduct', 'Functional Analysis', '(value)', 'Return a structured explanation of a inner product and related assumptions.', 'professional_function_catalog.md'), + ('functionalAnalysisDocumentLinearFunctional', 'Functional Analysis', '(value)', 'Return a structured explanation of a linear functional and related assumptions.', 'professional_function_catalog.md'), + ('functionalAnalysisDocumentNormedSpace', 'Functional Analysis', '(value)', 'Return a structured explanation of a normed space and related assumptions.', 'professional_function_catalog.md'), + ('functionalAnalysisEnumerateBoundedOperator', 'Functional Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a bounded operator.', 'professional_function_catalog.md'), + ('functionalAnalysisEnumerateCompleteSpace', 'Functional Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a complete space.', 'professional_function_catalog.md'), + ('functionalAnalysisEnumerateInnerProduct', 'Functional Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a inner product.', 'professional_function_catalog.md'), + ('functionalAnalysisEnumerateLinearFunctional', 'Functional Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a linear functional.', 'professional_function_catalog.md'), + ('functionalAnalysisEnumerateNormedSpace', 'Functional Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a normed space.', 'professional_function_catalog.md'), + ('functionalAnalysisEstimateBoundedOperator', 'Functional Analysis', '(value, samples=None)', 'Estimate a bounded operator property from finite samples or approximations.', 'professional_function_catalog.md'), + ('functionalAnalysisEstimateCompleteSpace', 'Functional Analysis', '(value, samples=None)', 'Estimate a complete space property from finite samples or approximations.', 'professional_function_catalog.md'), + ('functionalAnalysisEstimateInnerProduct', 'Functional Analysis', '(value, samples=None)', 'Estimate a inner product property from finite samples or approximations.', 'professional_function_catalog.md'), + ('functionalAnalysisEstimateLinearFunctional', 'Functional Analysis', '(value, samples=None)', 'Estimate a linear functional property from finite samples or approximations.', 'professional_function_catalog.md'), + ('functionalAnalysisEstimateNormedSpace', 'Functional Analysis', '(value, samples=None)', 'Estimate a normed space property from finite samples or approximations.', 'professional_function_catalog.md'), + ('functionalAnalysisEvaluateBoundedOperator', 'Functional Analysis', '(value, point=None)', 'Evaluate a bounded operator at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('functionalAnalysisEvaluateCompleteSpace', 'Functional Analysis', '(value, point=None)', 'Evaluate a complete space at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('functionalAnalysisEvaluateInnerProduct', 'Functional Analysis', '(value, point=None)', 'Evaluate a inner product at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('functionalAnalysisEvaluateLinearFunctional', 'Functional Analysis', '(value, point=None)', 'Evaluate a linear functional at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('functionalAnalysisEvaluateNormedSpace', 'Functional Analysis', '(value, point=None)', 'Evaluate a normed space at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('functionalAnalysisFormatBoundedOperator', 'Functional Analysis', '(value)', 'Format a bounded operator for deterministic user-facing output.', 'professional_function_catalog.md'), + ('functionalAnalysisFormatCompleteSpace', 'Functional Analysis', '(value)', 'Format a complete space for deterministic user-facing output.', 'professional_function_catalog.md'), + ('functionalAnalysisFormatInnerProduct', 'Functional Analysis', '(value)', 'Format a inner product for deterministic user-facing output.', 'professional_function_catalog.md'), + ('functionalAnalysisFormatLinearFunctional', 'Functional Analysis', '(value)', 'Format a linear functional for deterministic user-facing output.', 'professional_function_catalog.md'), + ('functionalAnalysisFormatNormedSpace', 'Functional Analysis', '(value)', 'Format a normed space for deterministic user-facing output.', 'professional_function_catalog.md'), + ('functionalAnalysisGenerateExampleBoundedOperator', 'Functional Analysis', '(size=3)', 'Generate a small documented example of a bounded operator.', 'professional_function_catalog.md'), + ('functionalAnalysisGenerateExampleCompleteSpace', 'Functional Analysis', '(size=3)', 'Generate a small documented example of a complete space.', 'professional_function_catalog.md'), + ('functionalAnalysisGenerateExampleInnerProduct', 'Functional Analysis', '(size=3)', 'Generate a small documented example of a inner product.', 'professional_function_catalog.md'), + ('functionalAnalysisGenerateExampleLinearFunctional', 'Functional Analysis', '(size=3)', 'Generate a small documented example of a linear functional.', 'professional_function_catalog.md'), + ('functionalAnalysisGenerateExampleNormedSpace', 'Functional Analysis', '(size=3)', 'Generate a small documented example of a normed space.', 'professional_function_catalog.md'), + ('functionalAnalysisNormalizeBoundedOperator', 'Functional Analysis', '(value)', 'Normalize a bounded operator into the standard Functional Analysis representation.', 'professional_function_catalog.md'), + ('functionalAnalysisNormalizeCompleteSpace', 'Functional Analysis', '(value)', 'Normalize a complete space into the standard Functional Analysis representation.', 'professional_function_catalog.md'), + ('functionalAnalysisNormalizeInnerProduct', 'Functional Analysis', '(value)', 'Normalize a inner product into the standard Functional Analysis representation.', 'professional_function_catalog.md'), + ('functionalAnalysisNormalizeLinearFunctional', 'Functional Analysis', '(value)', 'Normalize a linear functional into the standard Functional Analysis representation.', 'professional_function_catalog.md'), + ('functionalAnalysisNormalizeNormedSpace', 'Functional Analysis', '(value)', 'Normalize a normed space into the standard Functional Analysis representation.', 'professional_function_catalog.md'), + ('functionalAnalysisParseBoundedOperator', 'Functional Analysis', '(text)', 'Parse a text or structured value into a bounded operator.', 'professional_function_catalog.md'), + ('functionalAnalysisParseCompleteSpace', 'Functional Analysis', '(text)', 'Parse a text or structured value into a complete space.', 'professional_function_catalog.md'), + ('functionalAnalysisParseInnerProduct', 'Functional Analysis', '(text)', 'Parse a text or structured value into a inner product.', 'professional_function_catalog.md'), + ('functionalAnalysisParseLinearFunctional', 'Functional Analysis', '(text)', 'Parse a text or structured value into a linear functional.', 'professional_function_catalog.md'), + ('functionalAnalysisParseNormedSpace', 'Functional Analysis', '(text)', 'Parse a text or structured value into a normed space.', 'professional_function_catalog.md'), + ('functionalAnalysisSimplifyBoundedOperator', 'Functional Analysis', '(value)', 'Simplify a bounded operator without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('functionalAnalysisSimplifyCompleteSpace', 'Functional Analysis', '(value)', 'Simplify a complete space without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('functionalAnalysisSimplifyInnerProduct', 'Functional Analysis', '(value)', 'Simplify a inner product without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('functionalAnalysisSimplifyLinearFunctional', 'Functional Analysis', '(value)', 'Simplify a linear functional without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('functionalAnalysisSimplifyNormedSpace', 'Functional Analysis', '(value)', 'Simplify a normed space without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('functionalAnalysisTestEquivalenceBoundedOperator', 'Functional Analysis', '(left, right)', 'Test whether two bounded operator values are equivalent in Functional Analysis.', 'professional_function_catalog.md'), + ('functionalAnalysisTestEquivalenceCompleteSpace', 'Functional Analysis', '(left, right)', 'Test whether two complete space values are equivalent in Functional Analysis.', 'professional_function_catalog.md'), + ('functionalAnalysisTestEquivalenceInnerProduct', 'Functional Analysis', '(left, right)', 'Test whether two inner product values are equivalent in Functional Analysis.', 'professional_function_catalog.md'), + ('functionalAnalysisTestEquivalenceLinearFunctional', 'Functional Analysis', '(left, right)', 'Test whether two linear functional values are equivalent in Functional Analysis.', 'professional_function_catalog.md'), + ('functionalAnalysisTestEquivalenceNormedSpace', 'Functional Analysis', '(left, right)', 'Test whether two normed space values are equivalent in Functional Analysis.', 'professional_function_catalog.md'), + ('functionalAnalysisTransformBoundedOperator', 'Functional Analysis', '(value, mapping)', 'Transform a bounded operator through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('functionalAnalysisTransformCompleteSpace', 'Functional Analysis', '(value, mapping)', 'Transform a complete space through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('functionalAnalysisTransformInnerProduct', 'Functional Analysis', '(value, mapping)', 'Transform a inner product through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('functionalAnalysisTransformLinearFunctional', 'Functional Analysis', '(value, mapping)', 'Transform a linear functional through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('functionalAnalysisTransformNormedSpace', 'Functional Analysis', '(value, mapping)', 'Transform a normed space through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('functionalAnalysisValidateBoundedOperator', 'Functional Analysis', '(value)', 'Validate the bounded operator representation and domain rules for Functional Analysis.', 'professional_function_catalog.md'), + ('functionalAnalysisValidateCompleteSpace', 'Functional Analysis', '(value)', 'Validate the complete space representation and domain rules for Functional Analysis.', 'professional_function_catalog.md'), + ('functionalAnalysisValidateInnerProduct', 'Functional Analysis', '(value)', 'Validate the inner product representation and domain rules for Functional Analysis.', 'professional_function_catalog.md'), + ('functionalAnalysisValidateLinearFunctional', 'Functional Analysis', '(value)', 'Validate the linear functional representation and domain rules for Functional Analysis.', 'professional_function_catalog.md'), + ('functionalAnalysisValidateNormedSpace', 'Functional Analysis', '(value)', 'Validate the normed space representation and domain rules for Functional Analysis.', 'professional_function_catalog.md'), + ('innerProduct', 'Functional Analysis', '(v, w)', 'Planned roadmap function for Functional Analysis from upcoming.md.', 'upcoming.md'), + ('isContraction', 'Functional Analysis', '(operator, vectors, norm)', 'Planned roadmap function for Functional Analysis from upcoming.md.', 'upcoming.md'), + ('isInnerProduct', 'Functional Analysis', '(inner, vectors)', 'Planned roadmap function for Functional Analysis from upcoming.md.', 'upcoming.md'), + ('isLinearFunctional', 'Functional Analysis', '(functional, vectors)', 'Planned roadmap function for Functional Analysis from upcoming.md.', 'upcoming.md'), + ('isNorm', 'Functional Analysis', '(norm, vectors)', 'Planned roadmap function for Functional Analysis from upcoming.md.', 'upcoming.md'), + ('lpNorm', 'Functional Analysis', '(vector, p)', 'Planned roadmap function for Functional Analysis from upcoming.md.', 'upcoming.md'), + ('operatorNorm', 'Functional Analysis', '(matrix, p=2)', 'Planned roadmap function for Functional Analysis from upcoming.md.', 'upcoming.md'), + ('supNorm', 'Functional Analysis', '(values)', 'Planned roadmap function for Functional Analysis from upcoming.md.', 'upcoming.md'), + ('conjugateRootsQuadratic', 'Galois Theory', '(a, b, c)', 'Planned roadmap function for Galois Theory from upcoming.md.', 'upcoming.md'), + ('fieldExtensionDegree', 'Galois Theory', '(minimalPolynomial)', 'Planned roadmap function for Galois Theory from upcoming.md.', 'upcoming.md'), + ('galoisTheoryApproximateAutomorphism', 'Galois Theory', '(value, tolerance=1e-9)', 'Approximate a automorphism with explicit tolerance controls.', 'professional_function_catalog.md'), + ('galoisTheoryApproximateFieldExtension', 'Galois Theory', '(value, tolerance=1e-9)', 'Approximate a field extension with explicit tolerance controls.', 'professional_function_catalog.md'), + ('galoisTheoryApproximateGaloisGroup', 'Galois Theory', '(value, tolerance=1e-9)', 'Approximate a Galois group with explicit tolerance controls.', 'professional_function_catalog.md'), + ('galoisTheoryApproximateMinimalPolynomial', 'Galois Theory', '(value, tolerance=1e-9)', 'Approximate a minimal polynomial with explicit tolerance controls.', 'professional_function_catalog.md'), + ('galoisTheoryApproximateSplittingField', 'Galois Theory', '(value, tolerance=1e-9)', 'Approximate a splitting field with explicit tolerance controls.', 'professional_function_catalog.md'), + ('galoisTheoryCanonicalizeAutomorphism', 'Galois Theory', '(value)', 'Canonicalize a automorphism so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('galoisTheoryCanonicalizeFieldExtension', 'Galois Theory', '(value)', 'Canonicalize a field extension so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('galoisTheoryCanonicalizeGaloisGroup', 'Galois Theory', '(value)', 'Canonicalize a Galois group so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('galoisTheoryCanonicalizeMinimalPolynomial', 'Galois Theory', '(value)', 'Canonicalize a minimal polynomial so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('galoisTheoryCanonicalizeSplittingField', 'Galois Theory', '(value)', 'Canonicalize a splitting field so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('galoisTheoryClassifyAutomorphism', 'Galois Theory', '(value)', 'Classify a automorphism by its standard Galois Theory invariants.', 'professional_function_catalog.md'), + ('galoisTheoryClassifyFieldExtension', 'Galois Theory', '(value)', 'Classify a field extension by its standard Galois Theory invariants.', 'professional_function_catalog.md'), + ('galoisTheoryClassifyGaloisGroup', 'Galois Theory', '(value)', 'Classify a Galois group by its standard Galois Theory invariants.', 'professional_function_catalog.md'), + ('galoisTheoryClassifyMinimalPolynomial', 'Galois Theory', '(value)', 'Classify a minimal polynomial by its standard Galois Theory invariants.', 'professional_function_catalog.md'), + ('galoisTheoryClassifySplittingField', 'Galois Theory', '(value)', 'Classify a splitting field by its standard Galois Theory invariants.', 'professional_function_catalog.md'), + ('galoisTheoryCombineAutomorphism', 'Galois Theory', '(left, right)', 'Combine two automorphism values with the natural operation for Galois Theory.', 'professional_function_catalog.md'), + ('galoisTheoryCombineFieldExtension', 'Galois Theory', '(left, right)', 'Combine two field extension values with the natural operation for Galois Theory.', 'professional_function_catalog.md'), + ('galoisTheoryCombineGaloisGroup', 'Galois Theory', '(left, right)', 'Combine two Galois group values with the natural operation for Galois Theory.', 'professional_function_catalog.md'), + ('galoisTheoryCombineMinimalPolynomial', 'Galois Theory', '(left, right)', 'Combine two minimal polynomial values with the natural operation for Galois Theory.', 'professional_function_catalog.md'), + ('galoisTheoryCombineSplittingField', 'Galois Theory', '(left, right)', 'Combine two splitting field values with the natural operation for Galois Theory.', 'professional_function_catalog.md'), + ('galoisTheoryCompareAutomorphism', 'Galois Theory', '(left, right)', 'Compare two automorphism values under the conventions of Galois Theory.', 'professional_function_catalog.md'), + ('galoisTheoryCompareFieldExtension', 'Galois Theory', '(left, right)', 'Compare two field extension values under the conventions of Galois Theory.', 'professional_function_catalog.md'), + ('galoisTheoryCompareGaloisGroup', 'Galois Theory', '(left, right)', 'Compare two Galois group values under the conventions of Galois Theory.', 'professional_function_catalog.md'), + ('galoisTheoryCompareMinimalPolynomial', 'Galois Theory', '(left, right)', 'Compare two minimal polynomial values under the conventions of Galois Theory.', 'professional_function_catalog.md'), + ('galoisTheoryCompareSplittingField', 'Galois Theory', '(left, right)', 'Compare two splitting field values under the conventions of Galois Theory.', 'professional_function_catalog.md'), + ('galoisTheoryComputeAutomorphism', 'Galois Theory', '(value)', 'Compute the central numerical or symbolic data of a automorphism.', 'professional_function_catalog.md'), + ('galoisTheoryComputeFieldExtension', 'Galois Theory', '(value)', 'Compute the central numerical or symbolic data of a field extension.', 'professional_function_catalog.md'), + ('galoisTheoryComputeGaloisGroup', 'Galois Theory', '(value)', 'Compute the central numerical or symbolic data of a Galois group.', 'professional_function_catalog.md'), + ('galoisTheoryComputeMinimalPolynomial', 'Galois Theory', '(value)', 'Compute the central numerical or symbolic data of a minimal polynomial.', 'professional_function_catalog.md'), + ('galoisTheoryComputeSplittingField', 'Galois Theory', '(value)', 'Compute the central numerical or symbolic data of a splitting field.', 'professional_function_catalog.md'), + ('galoisTheoryConstructAutomorphism', 'Galois Theory', '(*args)', 'Construct a automorphism from explicit inputs for Galois Theory.', 'professional_function_catalog.md'), + ('galoisTheoryConstructFieldExtension', 'Galois Theory', '(*args)', 'Construct a field extension from explicit inputs for Galois Theory.', 'professional_function_catalog.md'), + ('galoisTheoryConstructGaloisGroup', 'Galois Theory', '(*args)', 'Construct a Galois group from explicit inputs for Galois Theory.', 'professional_function_catalog.md'), + ('galoisTheoryConstructMinimalPolynomial', 'Galois Theory', '(*args)', 'Construct a minimal polynomial from explicit inputs for Galois Theory.', 'professional_function_catalog.md'), + ('galoisTheoryConstructSplittingField', 'Galois Theory', '(*args)', 'Construct a splitting field from explicit inputs for Galois Theory.', 'professional_function_catalog.md'), + ('galoisTheoryDecomposeAutomorphism', 'Galois Theory', '(value)', 'Decompose a automorphism into simpler or canonical components.', 'professional_function_catalog.md'), + ('galoisTheoryDecomposeFieldExtension', 'Galois Theory', '(value)', 'Decompose a field extension into simpler or canonical components.', 'professional_function_catalog.md'), + ('galoisTheoryDecomposeGaloisGroup', 'Galois Theory', '(value)', 'Decompose a Galois group into simpler or canonical components.', 'professional_function_catalog.md'), + ('galoisTheoryDecomposeMinimalPolynomial', 'Galois Theory', '(value)', 'Decompose a minimal polynomial into simpler or canonical components.', 'professional_function_catalog.md'), + ('galoisTheoryDecomposeSplittingField', 'Galois Theory', '(value)', 'Decompose a splitting field into simpler or canonical components.', 'professional_function_catalog.md'), + ('galoisTheoryDocumentAutomorphism', 'Galois Theory', '(value)', 'Return a structured explanation of a automorphism and related assumptions.', 'professional_function_catalog.md'), + ('galoisTheoryDocumentFieldExtension', 'Galois Theory', '(value)', 'Return a structured explanation of a field extension and related assumptions.', 'professional_function_catalog.md'), + ('galoisTheoryDocumentGaloisGroup', 'Galois Theory', '(value)', 'Return a structured explanation of a Galois group and related assumptions.', 'professional_function_catalog.md'), + ('galoisTheoryDocumentMinimalPolynomial', 'Galois Theory', '(value)', 'Return a structured explanation of a minimal polynomial and related assumptions.', 'professional_function_catalog.md'), + ('galoisTheoryDocumentSplittingField', 'Galois Theory', '(value)', 'Return a structured explanation of a splitting field and related assumptions.', 'professional_function_catalog.md'), + ('galoisTheoryEnumerateAutomorphism', 'Galois Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a automorphism.', 'professional_function_catalog.md'), + ('galoisTheoryEnumerateFieldExtension', 'Galois Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a field extension.', 'professional_function_catalog.md'), + ('galoisTheoryEnumerateGaloisGroup', 'Galois Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a Galois group.', 'professional_function_catalog.md'), + ('galoisTheoryEnumerateMinimalPolynomial', 'Galois Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a minimal polynomial.', 'professional_function_catalog.md'), + ('galoisTheoryEnumerateSplittingField', 'Galois Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a splitting field.', 'professional_function_catalog.md'), + ('galoisTheoryEstimateAutomorphism', 'Galois Theory', '(value, samples=None)', 'Estimate a automorphism property from finite samples or approximations.', 'professional_function_catalog.md'), + ('galoisTheoryEstimateFieldExtension', 'Galois Theory', '(value, samples=None)', 'Estimate a field extension property from finite samples or approximations.', 'professional_function_catalog.md'), + ('galoisTheoryEstimateGaloisGroup', 'Galois Theory', '(value, samples=None)', 'Estimate a Galois group property from finite samples or approximations.', 'professional_function_catalog.md'), + ('galoisTheoryEstimateMinimalPolynomial', 'Galois Theory', '(value, samples=None)', 'Estimate a minimal polynomial property from finite samples or approximations.', 'professional_function_catalog.md'), + ('galoisTheoryEstimateSplittingField', 'Galois Theory', '(value, samples=None)', 'Estimate a splitting field property from finite samples or approximations.', 'professional_function_catalog.md'), + ('galoisTheoryEvaluateAutomorphism', 'Galois Theory', '(value, point=None)', 'Evaluate a automorphism at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('galoisTheoryEvaluateFieldExtension', 'Galois Theory', '(value, point=None)', 'Evaluate a field extension at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('galoisTheoryEvaluateGaloisGroup', 'Galois Theory', '(value, point=None)', 'Evaluate a Galois group at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('galoisTheoryEvaluateMinimalPolynomial', 'Galois Theory', '(value, point=None)', 'Evaluate a minimal polynomial at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('galoisTheoryEvaluateSplittingField', 'Galois Theory', '(value, point=None)', 'Evaluate a splitting field at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('galoisTheoryFormatAutomorphism', 'Galois Theory', '(value)', 'Format a automorphism for deterministic user-facing output.', 'professional_function_catalog.md'), + ('galoisTheoryFormatFieldExtension', 'Galois Theory', '(value)', 'Format a field extension for deterministic user-facing output.', 'professional_function_catalog.md'), + ('galoisTheoryFormatGaloisGroup', 'Galois Theory', '(value)', 'Format a Galois group for deterministic user-facing output.', 'professional_function_catalog.md'), + ('galoisTheoryFormatMinimalPolynomial', 'Galois Theory', '(value)', 'Format a minimal polynomial for deterministic user-facing output.', 'professional_function_catalog.md'), + ('galoisTheoryFormatSplittingField', 'Galois Theory', '(value)', 'Format a splitting field for deterministic user-facing output.', 'professional_function_catalog.md'), + ('galoisTheoryGenerateExampleAutomorphism', 'Galois Theory', '(size=3)', 'Generate a small documented example of a automorphism.', 'professional_function_catalog.md'), + ('galoisTheoryGenerateExampleFieldExtension', 'Galois Theory', '(size=3)', 'Generate a small documented example of a field extension.', 'professional_function_catalog.md'), + ('galoisTheoryGenerateExampleGaloisGroup', 'Galois Theory', '(size=3)', 'Generate a small documented example of a Galois group.', 'professional_function_catalog.md'), + ('galoisTheoryGenerateExampleMinimalPolynomial', 'Galois Theory', '(size=3)', 'Generate a small documented example of a minimal polynomial.', 'professional_function_catalog.md'), + ('galoisTheoryGenerateExampleSplittingField', 'Galois Theory', '(size=3)', 'Generate a small documented example of a splitting field.', 'professional_function_catalog.md'), + ('galoisTheoryNormalizeAutomorphism', 'Galois Theory', '(value)', 'Normalize a automorphism into the standard Galois Theory representation.', 'professional_function_catalog.md'), + ('galoisTheoryNormalizeFieldExtension', 'Galois Theory', '(value)', 'Normalize a field extension into the standard Galois Theory representation.', 'professional_function_catalog.md'), + ('galoisTheoryNormalizeGaloisGroup', 'Galois Theory', '(value)', 'Normalize a Galois group into the standard Galois Theory representation.', 'professional_function_catalog.md'), + ('galoisTheoryNormalizeMinimalPolynomial', 'Galois Theory', '(value)', 'Normalize a minimal polynomial into the standard Galois Theory representation.', 'professional_function_catalog.md'), + ('galoisTheoryNormalizeSplittingField', 'Galois Theory', '(value)', 'Normalize a splitting field into the standard Galois Theory representation.', 'professional_function_catalog.md'), + ('galoisTheoryParseAutomorphism', 'Galois Theory', '(text)', 'Parse a text or structured value into a automorphism.', 'professional_function_catalog.md'), + ('galoisTheoryParseFieldExtension', 'Galois Theory', '(text)', 'Parse a text or structured value into a field extension.', 'professional_function_catalog.md'), + ('galoisTheoryParseGaloisGroup', 'Galois Theory', '(text)', 'Parse a text or structured value into a Galois group.', 'professional_function_catalog.md'), + ('galoisTheoryParseMinimalPolynomial', 'Galois Theory', '(text)', 'Parse a text or structured value into a minimal polynomial.', 'professional_function_catalog.md'), + ('galoisTheoryParseSplittingField', 'Galois Theory', '(text)', 'Parse a text or structured value into a splitting field.', 'professional_function_catalog.md'), + ('galoisTheorySimplifyAutomorphism', 'Galois Theory', '(value)', 'Simplify a automorphism without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('galoisTheorySimplifyFieldExtension', 'Galois Theory', '(value)', 'Simplify a field extension without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('galoisTheorySimplifyGaloisGroup', 'Galois Theory', '(value)', 'Simplify a Galois group without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('galoisTheorySimplifyMinimalPolynomial', 'Galois Theory', '(value)', 'Simplify a minimal polynomial without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('galoisTheorySimplifySplittingField', 'Galois Theory', '(value)', 'Simplify a splitting field without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('galoisTheoryTestEquivalenceAutomorphism', 'Galois Theory', '(left, right)', 'Test whether two automorphism values are equivalent in Galois Theory.', 'professional_function_catalog.md'), + ('galoisTheoryTestEquivalenceFieldExtension', 'Galois Theory', '(left, right)', 'Test whether two field extension values are equivalent in Galois Theory.', 'professional_function_catalog.md'), + ('galoisTheoryTestEquivalenceGaloisGroup', 'Galois Theory', '(left, right)', 'Test whether two Galois group values are equivalent in Galois Theory.', 'professional_function_catalog.md'), + ('galoisTheoryTestEquivalenceMinimalPolynomial', 'Galois Theory', '(left, right)', 'Test whether two minimal polynomial values are equivalent in Galois Theory.', 'professional_function_catalog.md'), + ('galoisTheoryTestEquivalenceSplittingField', 'Galois Theory', '(left, right)', 'Test whether two splitting field values are equivalent in Galois Theory.', 'professional_function_catalog.md'), + ('galoisTheoryTransformAutomorphism', 'Galois Theory', '(value, mapping)', 'Transform a automorphism through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('galoisTheoryTransformFieldExtension', 'Galois Theory', '(value, mapping)', 'Transform a field extension through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('galoisTheoryTransformGaloisGroup', 'Galois Theory', '(value, mapping)', 'Transform a Galois group through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('galoisTheoryTransformMinimalPolynomial', 'Galois Theory', '(value, mapping)', 'Transform a minimal polynomial through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('galoisTheoryTransformSplittingField', 'Galois Theory', '(value, mapping)', 'Transform a splitting field through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('galoisTheoryValidateAutomorphism', 'Galois Theory', '(value)', 'Validate the automorphism representation and domain rules for Galois Theory.', 'professional_function_catalog.md'), + ('galoisTheoryValidateFieldExtension', 'Galois Theory', '(value)', 'Validate the field extension representation and domain rules for Galois Theory.', 'professional_function_catalog.md'), + ('galoisTheoryValidateGaloisGroup', 'Galois Theory', '(value)', 'Validate the Galois group representation and domain rules for Galois Theory.', 'professional_function_catalog.md'), + ('galoisTheoryValidateMinimalPolynomial', 'Galois Theory', '(value)', 'Validate the minimal polynomial representation and domain rules for Galois Theory.', 'professional_function_catalog.md'), + ('galoisTheoryValidateSplittingField', 'Galois Theory', '(value)', 'Validate the splitting field representation and domain rules for Galois Theory.', 'professional_function_catalog.md'), + ('isIrreduciblePolynomial', 'Galois Theory', '(coefficients, field="Q")', 'Planned roadmap function for Galois Theory from upcoming.md.', 'upcoming.md'), + ('isSeparablePolynomial', 'Galois Theory', '(coefficients, characteristic=0)', 'Planned roadmap function for Galois Theory from upcoming.md.', 'upcoming.md'), + ('polynomialDiscriminantCubic', 'Galois Theory', '(a, b, c, d)', 'Planned roadmap function for Galois Theory from upcoming.md.', 'upcoming.md'), + ('polynomialDiscriminantQuadratic', 'Galois Theory', '(a, b, c)', 'Planned roadmap function for Galois Theory from upcoming.md.', 'upcoming.md'), + ('quadraticGaloisGroup', 'Galois Theory', '(a, b, c)', 'Planned roadmap function for Galois Theory from upcoming.md.', 'upcoming.md'), + ('rationalRootTest', 'Galois Theory', '(coefficients)', 'Planned roadmap function for Galois Theory from upcoming.md.', 'upcoming.md'), + ('dominantStrategy', 'Game Theory', '(payoffMatrix, player)', 'Planned roadmap function for Game Theory from upcoming.md.', 'upcoming.md'), + ('gameTheoryApproximateCoalition', 'Game Theory', '(value, tolerance=1e-9)', 'Approximate a coalition with explicit tolerance controls.', 'professional_function_catalog.md'), + ('gameTheoryApproximateEquilibrium', 'Game Theory', '(value, tolerance=1e-9)', 'Approximate a equilibrium with explicit tolerance controls.', 'professional_function_catalog.md'), + ('gameTheoryApproximateGameMatrix', 'Game Theory', '(value, tolerance=1e-9)', 'Approximate a game matrix with explicit tolerance controls.', 'professional_function_catalog.md'), + ('gameTheoryApproximatePayoffModel', 'Game Theory', '(value, tolerance=1e-9)', 'Approximate a payoff model with explicit tolerance controls.', 'professional_function_catalog.md'), + ('gameTheoryApproximateStrategy', 'Game Theory', '(value, tolerance=1e-9)', 'Approximate a strategy with explicit tolerance controls.', 'professional_function_catalog.md'), + ('gameTheoryCanonicalizeCoalition', 'Game Theory', '(value)', 'Canonicalize a coalition so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('gameTheoryCanonicalizeEquilibrium', 'Game Theory', '(value)', 'Canonicalize a equilibrium so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('gameTheoryCanonicalizeGameMatrix', 'Game Theory', '(value)', 'Canonicalize a game matrix so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('gameTheoryCanonicalizePayoffModel', 'Game Theory', '(value)', 'Canonicalize a payoff model so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('gameTheoryCanonicalizeStrategy', 'Game Theory', '(value)', 'Canonicalize a strategy so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('gameTheoryClassifyCoalition', 'Game Theory', '(value)', 'Classify a coalition by its standard Game Theory invariants.', 'professional_function_catalog.md'), + ('gameTheoryClassifyEquilibrium', 'Game Theory', '(value)', 'Classify a equilibrium by its standard Game Theory invariants.', 'professional_function_catalog.md'), + ('gameTheoryClassifyGameMatrix', 'Game Theory', '(value)', 'Classify a game matrix by its standard Game Theory invariants.', 'professional_function_catalog.md'), + ('gameTheoryClassifyPayoffModel', 'Game Theory', '(value)', 'Classify a payoff model by its standard Game Theory invariants.', 'professional_function_catalog.md'), + ('gameTheoryClassifyStrategy', 'Game Theory', '(value)', 'Classify a strategy by its standard Game Theory invariants.', 'professional_function_catalog.md'), + ('gameTheoryCombineCoalition', 'Game Theory', '(left, right)', 'Combine two coalition values with the natural operation for Game Theory.', 'professional_function_catalog.md'), + ('gameTheoryCombineEquilibrium', 'Game Theory', '(left, right)', 'Combine two equilibrium values with the natural operation for Game Theory.', 'professional_function_catalog.md'), + ('gameTheoryCombineGameMatrix', 'Game Theory', '(left, right)', 'Combine two game matrix values with the natural operation for Game Theory.', 'professional_function_catalog.md'), + ('gameTheoryCombinePayoffModel', 'Game Theory', '(left, right)', 'Combine two payoff model values with the natural operation for Game Theory.', 'professional_function_catalog.md'), + ('gameTheoryCombineStrategy', 'Game Theory', '(left, right)', 'Combine two strategy values with the natural operation for Game Theory.', 'professional_function_catalog.md'), + ('gameTheoryCompareCoalition', 'Game Theory', '(left, right)', 'Compare two coalition values under the conventions of Game Theory.', 'professional_function_catalog.md'), + ('gameTheoryCompareEquilibrium', 'Game Theory', '(left, right)', 'Compare two equilibrium values under the conventions of Game Theory.', 'professional_function_catalog.md'), + ('gameTheoryCompareGameMatrix', 'Game Theory', '(left, right)', 'Compare two game matrix values under the conventions of Game Theory.', 'professional_function_catalog.md'), + ('gameTheoryComparePayoffModel', 'Game Theory', '(left, right)', 'Compare two payoff model values under the conventions of Game Theory.', 'professional_function_catalog.md'), + ('gameTheoryCompareStrategy', 'Game Theory', '(left, right)', 'Compare two strategy values under the conventions of Game Theory.', 'professional_function_catalog.md'), + ('gameTheoryComputeCoalition', 'Game Theory', '(value)', 'Compute the central numerical or symbolic data of a coalition.', 'professional_function_catalog.md'), + ('gameTheoryComputeEquilibrium', 'Game Theory', '(value)', 'Compute the central numerical or symbolic data of a equilibrium.', 'professional_function_catalog.md'), + ('gameTheoryComputeGameMatrix', 'Game Theory', '(value)', 'Compute the central numerical or symbolic data of a game matrix.', 'professional_function_catalog.md'), + ('gameTheoryComputePayoffModel', 'Game Theory', '(value)', 'Compute the central numerical or symbolic data of a payoff model.', 'professional_function_catalog.md'), + ('gameTheoryComputeStrategy', 'Game Theory', '(value)', 'Compute the central numerical or symbolic data of a strategy.', 'professional_function_catalog.md'), + ('gameTheoryConstructCoalition', 'Game Theory', '(*args)', 'Construct a coalition from explicit inputs for Game Theory.', 'professional_function_catalog.md'), + ('gameTheoryConstructEquilibrium', 'Game Theory', '(*args)', 'Construct a equilibrium from explicit inputs for Game Theory.', 'professional_function_catalog.md'), + ('gameTheoryConstructGameMatrix', 'Game Theory', '(*args)', 'Construct a game matrix from explicit inputs for Game Theory.', 'professional_function_catalog.md'), + ('gameTheoryConstructPayoffModel', 'Game Theory', '(*args)', 'Construct a payoff model from explicit inputs for Game Theory.', 'professional_function_catalog.md'), + ('gameTheoryConstructStrategy', 'Game Theory', '(*args)', 'Construct a strategy from explicit inputs for Game Theory.', 'professional_function_catalog.md'), + ('gameTheoryDecomposeCoalition', 'Game Theory', '(value)', 'Decompose a coalition into simpler or canonical components.', 'professional_function_catalog.md'), + ('gameTheoryDecomposeEquilibrium', 'Game Theory', '(value)', 'Decompose a equilibrium into simpler or canonical components.', 'professional_function_catalog.md'), + ('gameTheoryDecomposeGameMatrix', 'Game Theory', '(value)', 'Decompose a game matrix into simpler or canonical components.', 'professional_function_catalog.md'), + ('gameTheoryDecomposePayoffModel', 'Game Theory', '(value)', 'Decompose a payoff model into simpler or canonical components.', 'professional_function_catalog.md'), + ('gameTheoryDecomposeStrategy', 'Game Theory', '(value)', 'Decompose a strategy into simpler or canonical components.', 'professional_function_catalog.md'), + ('gameTheoryDocumentCoalition', 'Game Theory', '(value)', 'Return a structured explanation of a coalition and related assumptions.', 'professional_function_catalog.md'), + ('gameTheoryDocumentEquilibrium', 'Game Theory', '(value)', 'Return a structured explanation of a equilibrium and related assumptions.', 'professional_function_catalog.md'), + ('gameTheoryDocumentGameMatrix', 'Game Theory', '(value)', 'Return a structured explanation of a game matrix and related assumptions.', 'professional_function_catalog.md'), + ('gameTheoryDocumentPayoffModel', 'Game Theory', '(value)', 'Return a structured explanation of a payoff model and related assumptions.', 'professional_function_catalog.md'), + ('gameTheoryDocumentStrategy', 'Game Theory', '(value)', 'Return a structured explanation of a strategy and related assumptions.', 'professional_function_catalog.md'), + ('gameTheoryEnumerateCoalition', 'Game Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a coalition.', 'professional_function_catalog.md'), + ('gameTheoryEnumerateEquilibrium', 'Game Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a equilibrium.', 'professional_function_catalog.md'), + ('gameTheoryEnumerateGameMatrix', 'Game Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a game matrix.', 'professional_function_catalog.md'), + ('gameTheoryEnumeratePayoffModel', 'Game Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a payoff model.', 'professional_function_catalog.md'), + ('gameTheoryEnumerateStrategy', 'Game Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a strategy.', 'professional_function_catalog.md'), + ('gameTheoryEstimateCoalition', 'Game Theory', '(value, samples=None)', 'Estimate a coalition property from finite samples or approximations.', 'professional_function_catalog.md'), + ('gameTheoryEstimateEquilibrium', 'Game Theory', '(value, samples=None)', 'Estimate a equilibrium property from finite samples or approximations.', 'professional_function_catalog.md'), + ('gameTheoryEstimateGameMatrix', 'Game Theory', '(value, samples=None)', 'Estimate a game matrix property from finite samples or approximations.', 'professional_function_catalog.md'), + ('gameTheoryEstimatePayoffModel', 'Game Theory', '(value, samples=None)', 'Estimate a payoff model property from finite samples or approximations.', 'professional_function_catalog.md'), + ('gameTheoryEstimateStrategy', 'Game Theory', '(value, samples=None)', 'Estimate a strategy property from finite samples or approximations.', 'professional_function_catalog.md'), + ('gameTheoryEvaluateCoalition', 'Game Theory', '(value, point=None)', 'Evaluate a coalition at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('gameTheoryEvaluateEquilibrium', 'Game Theory', '(value, point=None)', 'Evaluate a equilibrium at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('gameTheoryEvaluateGameMatrix', 'Game Theory', '(value, point=None)', 'Evaluate a game matrix at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('gameTheoryEvaluatePayoffModel', 'Game Theory', '(value, point=None)', 'Evaluate a payoff model at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('gameTheoryEvaluateStrategy', 'Game Theory', '(value, point=None)', 'Evaluate a strategy at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('gameTheoryFormatCoalition', 'Game Theory', '(value)', 'Format a coalition for deterministic user-facing output.', 'professional_function_catalog.md'), + ('gameTheoryFormatEquilibrium', 'Game Theory', '(value)', 'Format a equilibrium for deterministic user-facing output.', 'professional_function_catalog.md'), + ('gameTheoryFormatGameMatrix', 'Game Theory', '(value)', 'Format a game matrix for deterministic user-facing output.', 'professional_function_catalog.md'), + ('gameTheoryFormatPayoffModel', 'Game Theory', '(value)', 'Format a payoff model for deterministic user-facing output.', 'professional_function_catalog.md'), + ('gameTheoryFormatStrategy', 'Game Theory', '(value)', 'Format a strategy for deterministic user-facing output.', 'professional_function_catalog.md'), + ('gameTheoryGenerateExampleCoalition', 'Game Theory', '(size=3)', 'Generate a small documented example of a coalition.', 'professional_function_catalog.md'), + ('gameTheoryGenerateExampleEquilibrium', 'Game Theory', '(size=3)', 'Generate a small documented example of a equilibrium.', 'professional_function_catalog.md'), + ('gameTheoryGenerateExampleGameMatrix', 'Game Theory', '(size=3)', 'Generate a small documented example of a game matrix.', 'professional_function_catalog.md'), + ('gameTheoryGenerateExamplePayoffModel', 'Game Theory', '(size=3)', 'Generate a small documented example of a payoff model.', 'professional_function_catalog.md'), + ('gameTheoryGenerateExampleStrategy', 'Game Theory', '(size=3)', 'Generate a small documented example of a strategy.', 'professional_function_catalog.md'), + ('gameTheoryNormalizeCoalition', 'Game Theory', '(value)', 'Normalize a coalition into the standard Game Theory representation.', 'professional_function_catalog.md'), + ('gameTheoryNormalizeEquilibrium', 'Game Theory', '(value)', 'Normalize a equilibrium into the standard Game Theory representation.', 'professional_function_catalog.md'), + ('gameTheoryNormalizeGameMatrix', 'Game Theory', '(value)', 'Normalize a game matrix into the standard Game Theory representation.', 'professional_function_catalog.md'), + ('gameTheoryNormalizePayoffModel', 'Game Theory', '(value)', 'Normalize a payoff model into the standard Game Theory representation.', 'professional_function_catalog.md'), + ('gameTheoryNormalizeStrategy', 'Game Theory', '(value)', 'Normalize a strategy into the standard Game Theory representation.', 'professional_function_catalog.md'), + ('gameTheoryParseCoalition', 'Game Theory', '(text)', 'Parse a text or structured value into a coalition.', 'professional_function_catalog.md'), + ('gameTheoryParseEquilibrium', 'Game Theory', '(text)', 'Parse a text or structured value into a equilibrium.', 'professional_function_catalog.md'), + ('gameTheoryParseGameMatrix', 'Game Theory', '(text)', 'Parse a text or structured value into a game matrix.', 'professional_function_catalog.md'), + ('gameTheoryParsePayoffModel', 'Game Theory', '(text)', 'Parse a text or structured value into a payoff model.', 'professional_function_catalog.md'), + ('gameTheoryParseStrategy', 'Game Theory', '(text)', 'Parse a text or structured value into a strategy.', 'professional_function_catalog.md'), + ('gameTheorySimplifyCoalition', 'Game Theory', '(value)', 'Simplify a coalition without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('gameTheorySimplifyEquilibrium', 'Game Theory', '(value)', 'Simplify a equilibrium without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('gameTheorySimplifyGameMatrix', 'Game Theory', '(value)', 'Simplify a game matrix without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('gameTheorySimplifyPayoffModel', 'Game Theory', '(value)', 'Simplify a payoff model without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('gameTheorySimplifyStrategy', 'Game Theory', '(value)', 'Simplify a strategy without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('gameTheoryTestEquivalenceCoalition', 'Game Theory', '(left, right)', 'Test whether two coalition values are equivalent in Game Theory.', 'professional_function_catalog.md'), + ('gameTheoryTestEquivalenceEquilibrium', 'Game Theory', '(left, right)', 'Test whether two equilibrium values are equivalent in Game Theory.', 'professional_function_catalog.md'), + ('gameTheoryTestEquivalenceGameMatrix', 'Game Theory', '(left, right)', 'Test whether two game matrix values are equivalent in Game Theory.', 'professional_function_catalog.md'), + ('gameTheoryTestEquivalencePayoffModel', 'Game Theory', '(left, right)', 'Test whether two payoff model values are equivalent in Game Theory.', 'professional_function_catalog.md'), + ('gameTheoryTestEquivalenceStrategy', 'Game Theory', '(left, right)', 'Test whether two strategy values are equivalent in Game Theory.', 'professional_function_catalog.md'), + ('gameTheoryTransformCoalition', 'Game Theory', '(value, mapping)', 'Transform a coalition through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('gameTheoryTransformEquilibrium', 'Game Theory', '(value, mapping)', 'Transform a equilibrium through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('gameTheoryTransformGameMatrix', 'Game Theory', '(value, mapping)', 'Transform a game matrix through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('gameTheoryTransformPayoffModel', 'Game Theory', '(value, mapping)', 'Transform a payoff model through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('gameTheoryTransformStrategy', 'Game Theory', '(value, mapping)', 'Transform a strategy through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('gameTheoryValidateCoalition', 'Game Theory', '(value)', 'Validate the coalition representation and domain rules for Game Theory.', 'professional_function_catalog.md'), + ('gameTheoryValidateEquilibrium', 'Game Theory', '(value)', 'Validate the equilibrium representation and domain rules for Game Theory.', 'professional_function_catalog.md'), + ('gameTheoryValidateGameMatrix', 'Game Theory', '(value)', 'Validate the game matrix representation and domain rules for Game Theory.', 'professional_function_catalog.md'), + ('gameTheoryValidatePayoffModel', 'Game Theory', '(value)', 'Validate the payoff model representation and domain rules for Game Theory.', 'professional_function_catalog.md'), + ('gameTheoryValidateStrategy', 'Game Theory', '(value)', 'Validate the strategy representation and domain rules for Game Theory.', 'professional_function_catalog.md'), + ('minimax', 'Game Theory', '(matrix)', 'Planned roadmap function for Game Theory from upcoming.md.', 'upcoming.md'), + ('mixedStrategyExpectedPayoff', 'Game Theory', '(matrix, rowProbabilities, columnProbabilities)', 'Planned roadmap function for Game Theory from upcoming.md.', 'upcoming.md'), + ('nashEquilibria2x2', 'Game Theory', '(playerA, playerB)', 'Planned roadmap function for Game Theory from upcoming.md.', 'upcoming.md'), + ('payoff', 'Game Theory', '(matrix, rowStrategy, columnStrategy)', 'Planned roadmap function for Game Theory from upcoming.md.', 'upcoming.md'), + ('zeroSumValue', 'Game Theory', '(matrix)', 'Planned roadmap function for Game Theory from upcoming.md.', 'upcoming.md'), + ('boundaryComponents', 'Geometric Topology', '(complex)', 'Planned roadmap function for Geometric Topology from upcoming.md.', 'upcoming.md'), + ('connectedSumInvariant', 'Geometric Topology', '(surfaceA, surfaceB)', 'Planned roadmap function for Geometric Topology from upcoming.md.', 'upcoming.md'), + ('geometricTopologyApproximateEmbeddingModel', 'Geometric Topology', '(value, tolerance=1e-9)', 'Approximate a embedding model with explicit tolerance controls.', 'professional_function_catalog.md'), + ('geometricTopologyApproximateHandleDecomposition', 'Geometric Topology', '(value, tolerance=1e-9)', 'Approximate a handle decomposition with explicit tolerance controls.', 'professional_function_catalog.md'), + ('geometricTopologyApproximateManifoldComplex', 'Geometric Topology', '(value, tolerance=1e-9)', 'Approximate a manifold complex with explicit tolerance controls.', 'professional_function_catalog.md'), + ('geometricTopologyApproximateSurfaceInvariant', 'Geometric Topology', '(value, tolerance=1e-9)', 'Approximate a surface invariant with explicit tolerance controls.', 'professional_function_catalog.md'), + ('geometricTopologyApproximateTriangulatedSurface', 'Geometric Topology', '(value, tolerance=1e-9)', 'Approximate a triangulated surface with explicit tolerance controls.', 'professional_function_catalog.md'), + ('geometricTopologyCanonicalizeEmbeddingModel', 'Geometric Topology', '(value)', 'Canonicalize a embedding model so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('geometricTopologyCanonicalizeHandleDecomposition', 'Geometric Topology', '(value)', 'Canonicalize a handle decomposition so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('geometricTopologyCanonicalizeManifoldComplex', 'Geometric Topology', '(value)', 'Canonicalize a manifold complex so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('geometricTopologyCanonicalizeSurfaceInvariant', 'Geometric Topology', '(value)', 'Canonicalize a surface invariant so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('geometricTopologyCanonicalizeTriangulatedSurface', 'Geometric Topology', '(value)', 'Canonicalize a triangulated surface so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('geometricTopologyClassifyEmbeddingModel', 'Geometric Topology', '(value)', 'Classify a embedding model by its standard Geometric Topology invariants.', 'professional_function_catalog.md'), + ('geometricTopologyClassifyHandleDecomposition', 'Geometric Topology', '(value)', 'Classify a handle decomposition by its standard Geometric Topology invariants.', 'professional_function_catalog.md'), + ('geometricTopologyClassifyManifoldComplex', 'Geometric Topology', '(value)', 'Classify a manifold complex by its standard Geometric Topology invariants.', 'professional_function_catalog.md'), + ('geometricTopologyClassifySurfaceInvariant', 'Geometric Topology', '(value)', 'Classify a surface invariant by its standard Geometric Topology invariants.', 'professional_function_catalog.md'), + ('geometricTopologyClassifyTriangulatedSurface', 'Geometric Topology', '(value)', 'Classify a triangulated surface by its standard Geometric Topology invariants.', 'professional_function_catalog.md'), + ('geometricTopologyCombineEmbeddingModel', 'Geometric Topology', '(left, right)', 'Combine two embedding model values with the natural operation for Geometric Topology.', 'professional_function_catalog.md'), + ('geometricTopologyCombineHandleDecomposition', 'Geometric Topology', '(left, right)', 'Combine two handle decomposition values with the natural operation for Geometric Topology.', 'professional_function_catalog.md'), + ('geometricTopologyCombineManifoldComplex', 'Geometric Topology', '(left, right)', 'Combine two manifold complex values with the natural operation for Geometric Topology.', 'professional_function_catalog.md'), + ('geometricTopologyCombineSurfaceInvariant', 'Geometric Topology', '(left, right)', 'Combine two surface invariant values with the natural operation for Geometric Topology.', 'professional_function_catalog.md'), + ('geometricTopologyCombineTriangulatedSurface', 'Geometric Topology', '(left, right)', 'Combine two triangulated surface values with the natural operation for Geometric Topology.', 'professional_function_catalog.md'), + ('geometricTopologyCompareEmbeddingModel', 'Geometric Topology', '(left, right)', 'Compare two embedding model values under the conventions of Geometric Topology.', 'professional_function_catalog.md'), + ('geometricTopologyCompareHandleDecomposition', 'Geometric Topology', '(left, right)', 'Compare two handle decomposition values under the conventions of Geometric Topology.', 'professional_function_catalog.md'), + ('geometricTopologyCompareManifoldComplex', 'Geometric Topology', '(left, right)', 'Compare two manifold complex values under the conventions of Geometric Topology.', 'professional_function_catalog.md'), + ('geometricTopologyCompareSurfaceInvariant', 'Geometric Topology', '(left, right)', 'Compare two surface invariant values under the conventions of Geometric Topology.', 'professional_function_catalog.md'), + ('geometricTopologyCompareTriangulatedSurface', 'Geometric Topology', '(left, right)', 'Compare two triangulated surface values under the conventions of Geometric Topology.', 'professional_function_catalog.md'), + ('geometricTopologyComputeEmbeddingModel', 'Geometric Topology', '(value)', 'Compute the central numerical or symbolic data of a embedding model.', 'professional_function_catalog.md'), + ('geometricTopologyComputeHandleDecomposition', 'Geometric Topology', '(value)', 'Compute the central numerical or symbolic data of a handle decomposition.', 'professional_function_catalog.md'), + ('geometricTopologyComputeManifoldComplex', 'Geometric Topology', '(value)', 'Compute the central numerical or symbolic data of a manifold complex.', 'professional_function_catalog.md'), + ('geometricTopologyComputeSurfaceInvariant', 'Geometric Topology', '(value)', 'Compute the central numerical or symbolic data of a surface invariant.', 'professional_function_catalog.md'), + ('geometricTopologyComputeTriangulatedSurface', 'Geometric Topology', '(value)', 'Compute the central numerical or symbolic data of a triangulated surface.', 'professional_function_catalog.md'), + ('geometricTopologyConstructEmbeddingModel', 'Geometric Topology', '(*args)', 'Construct a embedding model from explicit inputs for Geometric Topology.', 'professional_function_catalog.md'), + ('geometricTopologyConstructHandleDecomposition', 'Geometric Topology', '(*args)', 'Construct a handle decomposition from explicit inputs for Geometric Topology.', 'professional_function_catalog.md'), + ('geometricTopologyConstructManifoldComplex', 'Geometric Topology', '(*args)', 'Construct a manifold complex from explicit inputs for Geometric Topology.', 'professional_function_catalog.md'), + ('geometricTopologyConstructSurfaceInvariant', 'Geometric Topology', '(*args)', 'Construct a surface invariant from explicit inputs for Geometric Topology.', 'professional_function_catalog.md'), + ('geometricTopologyConstructTriangulatedSurface', 'Geometric Topology', '(*args)', 'Construct a triangulated surface from explicit inputs for Geometric Topology.', 'professional_function_catalog.md'), + ('geometricTopologyDecomposeEmbeddingModel', 'Geometric Topology', '(value)', 'Decompose a embedding model into simpler or canonical components.', 'professional_function_catalog.md'), + ('geometricTopologyDecomposeHandleDecomposition', 'Geometric Topology', '(value)', 'Decompose a handle decomposition into simpler or canonical components.', 'professional_function_catalog.md'), + ('geometricTopologyDecomposeManifoldComplex', 'Geometric Topology', '(value)', 'Decompose a manifold complex into simpler or canonical components.', 'professional_function_catalog.md'), + ('geometricTopologyDecomposeSurfaceInvariant', 'Geometric Topology', '(value)', 'Decompose a surface invariant into simpler or canonical components.', 'professional_function_catalog.md'), + ('geometricTopologyDecomposeTriangulatedSurface', 'Geometric Topology', '(value)', 'Decompose a triangulated surface into simpler or canonical components.', 'professional_function_catalog.md'), + ('geometricTopologyDocumentEmbeddingModel', 'Geometric Topology', '(value)', 'Return a structured explanation of a embedding model and related assumptions.', 'professional_function_catalog.md'), + ('geometricTopologyDocumentHandleDecomposition', 'Geometric Topology', '(value)', 'Return a structured explanation of a handle decomposition and related assumptions.', 'professional_function_catalog.md'), + ('geometricTopologyDocumentManifoldComplex', 'Geometric Topology', '(value)', 'Return a structured explanation of a manifold complex and related assumptions.', 'professional_function_catalog.md'), + ('geometricTopologyDocumentSurfaceInvariant', 'Geometric Topology', '(value)', 'Return a structured explanation of a surface invariant and related assumptions.', 'professional_function_catalog.md'), + ('geometricTopologyDocumentTriangulatedSurface', 'Geometric Topology', '(value)', 'Return a structured explanation of a triangulated surface and related assumptions.', 'professional_function_catalog.md'), + ('geometricTopologyEnumerateEmbeddingModel', 'Geometric Topology', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a embedding model.', 'professional_function_catalog.md'), + ('geometricTopologyEnumerateHandleDecomposition', 'Geometric Topology', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a handle decomposition.', 'professional_function_catalog.md'), + ('geometricTopologyEnumerateManifoldComplex', 'Geometric Topology', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a manifold complex.', 'professional_function_catalog.md'), + ('geometricTopologyEnumerateSurfaceInvariant', 'Geometric Topology', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a surface invariant.', 'professional_function_catalog.md'), + ('geometricTopologyEnumerateTriangulatedSurface', 'Geometric Topology', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a triangulated surface.', 'professional_function_catalog.md'), + ('geometricTopologyEstimateEmbeddingModel', 'Geometric Topology', '(value, samples=None)', 'Estimate a embedding model property from finite samples or approximations.', 'professional_function_catalog.md'), + ('geometricTopologyEstimateHandleDecomposition', 'Geometric Topology', '(value, samples=None)', 'Estimate a handle decomposition property from finite samples or approximations.', 'professional_function_catalog.md'), + ('geometricTopologyEstimateManifoldComplex', 'Geometric Topology', '(value, samples=None)', 'Estimate a manifold complex property from finite samples or approximations.', 'professional_function_catalog.md'), + ('geometricTopologyEstimateSurfaceInvariant', 'Geometric Topology', '(value, samples=None)', 'Estimate a surface invariant property from finite samples or approximations.', 'professional_function_catalog.md'), + ('geometricTopologyEstimateTriangulatedSurface', 'Geometric Topology', '(value, samples=None)', 'Estimate a triangulated surface property from finite samples or approximations.', 'professional_function_catalog.md'), + ('geometricTopologyEvaluateEmbeddingModel', 'Geometric Topology', '(value, point=None)', 'Evaluate a embedding model at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('geometricTopologyEvaluateHandleDecomposition', 'Geometric Topology', '(value, point=None)', 'Evaluate a handle decomposition at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('geometricTopologyEvaluateManifoldComplex', 'Geometric Topology', '(value, point=None)', 'Evaluate a manifold complex at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('geometricTopologyEvaluateSurfaceInvariant', 'Geometric Topology', '(value, point=None)', 'Evaluate a surface invariant at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('geometricTopologyEvaluateTriangulatedSurface', 'Geometric Topology', '(value, point=None)', 'Evaluate a triangulated surface at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('geometricTopologyFormatEmbeddingModel', 'Geometric Topology', '(value)', 'Format a embedding model for deterministic user-facing output.', 'professional_function_catalog.md'), + ('geometricTopologyFormatHandleDecomposition', 'Geometric Topology', '(value)', 'Format a handle decomposition for deterministic user-facing output.', 'professional_function_catalog.md'), + ('geometricTopologyFormatManifoldComplex', 'Geometric Topology', '(value)', 'Format a manifold complex for deterministic user-facing output.', 'professional_function_catalog.md'), + ('geometricTopologyFormatSurfaceInvariant', 'Geometric Topology', '(value)', 'Format a surface invariant for deterministic user-facing output.', 'professional_function_catalog.md'), + ('geometricTopologyFormatTriangulatedSurface', 'Geometric Topology', '(value)', 'Format a triangulated surface for deterministic user-facing output.', 'professional_function_catalog.md'), + ('geometricTopologyGenerateExampleEmbeddingModel', 'Geometric Topology', '(size=3)', 'Generate a small documented example of a embedding model.', 'professional_function_catalog.md'), + ('geometricTopologyGenerateExampleHandleDecomposition', 'Geometric Topology', '(size=3)', 'Generate a small documented example of a handle decomposition.', 'professional_function_catalog.md'), + ('geometricTopologyGenerateExampleManifoldComplex', 'Geometric Topology', '(size=3)', 'Generate a small documented example of a manifold complex.', 'professional_function_catalog.md'), + ('geometricTopologyGenerateExampleSurfaceInvariant', 'Geometric Topology', '(size=3)', 'Generate a small documented example of a surface invariant.', 'professional_function_catalog.md'), + ('geometricTopologyGenerateExampleTriangulatedSurface', 'Geometric Topology', '(size=3)', 'Generate a small documented example of a triangulated surface.', 'professional_function_catalog.md'), + ('geometricTopologyNormalizeEmbeddingModel', 'Geometric Topology', '(value)', 'Normalize a embedding model into the standard Geometric Topology representation.', 'professional_function_catalog.md'), + ('geometricTopologyNormalizeHandleDecomposition', 'Geometric Topology', '(value)', 'Normalize a handle decomposition into the standard Geometric Topology representation.', 'professional_function_catalog.md'), + ('geometricTopologyNormalizeManifoldComplex', 'Geometric Topology', '(value)', 'Normalize a manifold complex into the standard Geometric Topology representation.', 'professional_function_catalog.md'), + ('geometricTopologyNormalizeSurfaceInvariant', 'Geometric Topology', '(value)', 'Normalize a surface invariant into the standard Geometric Topology representation.', 'professional_function_catalog.md'), + ('geometricTopologyNormalizeTriangulatedSurface', 'Geometric Topology', '(value)', 'Normalize a triangulated surface into the standard Geometric Topology representation.', 'professional_function_catalog.md'), + ('geometricTopologyParseEmbeddingModel', 'Geometric Topology', '(text)', 'Parse a text or structured value into a embedding model.', 'professional_function_catalog.md'), + ('geometricTopologyParseHandleDecomposition', 'Geometric Topology', '(text)', 'Parse a text or structured value into a handle decomposition.', 'professional_function_catalog.md'), + ('geometricTopologyParseManifoldComplex', 'Geometric Topology', '(text)', 'Parse a text or structured value into a manifold complex.', 'professional_function_catalog.md'), + ('geometricTopologyParseSurfaceInvariant', 'Geometric Topology', '(text)', 'Parse a text or structured value into a surface invariant.', 'professional_function_catalog.md'), + ('geometricTopologyParseTriangulatedSurface', 'Geometric Topology', '(text)', 'Parse a text or structured value into a triangulated surface.', 'professional_function_catalog.md'), + ('geometricTopologySimplifyEmbeddingModel', 'Geometric Topology', '(value)', 'Simplify a embedding model without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('geometricTopologySimplifyHandleDecomposition', 'Geometric Topology', '(value)', 'Simplify a handle decomposition without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('geometricTopologySimplifyManifoldComplex', 'Geometric Topology', '(value)', 'Simplify a manifold complex without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('geometricTopologySimplifySurfaceInvariant', 'Geometric Topology', '(value)', 'Simplify a surface invariant without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('geometricTopologySimplifyTriangulatedSurface', 'Geometric Topology', '(value)', 'Simplify a triangulated surface without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('geometricTopologyTestEquivalenceEmbeddingModel', 'Geometric Topology', '(left, right)', 'Test whether two embedding model values are equivalent in Geometric Topology.', 'professional_function_catalog.md'), + ('geometricTopologyTestEquivalenceHandleDecomposition', 'Geometric Topology', '(left, right)', 'Test whether two handle decomposition values are equivalent in Geometric Topology.', 'professional_function_catalog.md'), + ('geometricTopologyTestEquivalenceManifoldComplex', 'Geometric Topology', '(left, right)', 'Test whether two manifold complex values are equivalent in Geometric Topology.', 'professional_function_catalog.md'), + ('geometricTopologyTestEquivalenceSurfaceInvariant', 'Geometric Topology', '(left, right)', 'Test whether two surface invariant values are equivalent in Geometric Topology.', 'professional_function_catalog.md'), + ('geometricTopologyTestEquivalenceTriangulatedSurface', 'Geometric Topology', '(left, right)', 'Test whether two triangulated surface values are equivalent in Geometric Topology.', 'professional_function_catalog.md'), + ('geometricTopologyTransformEmbeddingModel', 'Geometric Topology', '(value, mapping)', 'Transform a embedding model through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('geometricTopologyTransformHandleDecomposition', 'Geometric Topology', '(value, mapping)', 'Transform a handle decomposition through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('geometricTopologyTransformManifoldComplex', 'Geometric Topology', '(value, mapping)', 'Transform a manifold complex through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('geometricTopologyTransformSurfaceInvariant', 'Geometric Topology', '(value, mapping)', 'Transform a surface invariant through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('geometricTopologyTransformTriangulatedSurface', 'Geometric Topology', '(value, mapping)', 'Transform a triangulated surface through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('geometricTopologyValidateEmbeddingModel', 'Geometric Topology', '(value)', 'Validate the embedding model representation and domain rules for Geometric Topology.', 'professional_function_catalog.md'), + ('geometricTopologyValidateHandleDecomposition', 'Geometric Topology', '(value)', 'Validate the handle decomposition representation and domain rules for Geometric Topology.', 'professional_function_catalog.md'), + ('geometricTopologyValidateManifoldComplex', 'Geometric Topology', '(value)', 'Validate the manifold complex representation and domain rules for Geometric Topology.', 'professional_function_catalog.md'), + ('geometricTopologyValidateSurfaceInvariant', 'Geometric Topology', '(value)', 'Validate the surface invariant representation and domain rules for Geometric Topology.', 'professional_function_catalog.md'), + ('geometricTopologyValidateTriangulatedSurface', 'Geometric Topology', '(value)', 'Validate the triangulated surface representation and domain rules for Geometric Topology.', 'professional_function_catalog.md'), + ('isCombinatorialManifold', 'Geometric Topology', '(complex)', 'Planned roadmap function for Geometric Topology from upcoming.md.', 'upcoming.md'), + ('isOrientableSurface', 'Geometric Topology', '(complex)', 'Planned roadmap function for Geometric Topology from upcoming.md.', 'upcoming.md'), + ('isTriangulatedSurface', 'Geometric Topology', '(complex)', 'Planned roadmap function for Geometric Topology from upcoming.md.', 'upcoming.md'), + ('orientableSurfaceGenus', 'Geometric Topology', '(vertices, edges, faces)', 'Planned roadmap function for Geometric Topology from upcoming.md.', 'upcoming.md'), + ('surfaceEulerCharacteristic', 'Geometric Topology', '(vertices, edges, faces)', 'Planned roadmap function for Geometric Topology from upcoming.md.', 'upcoming.md'), + ('vertexLink', 'Geometric Topology', '(complex, vertex)', 'Planned roadmap function for Geometric Topology from upcoming.md.', 'upcoming.md'), + ('angleBetweenVectors', 'Geometry', '(v, w)', 'Planned roadmap function for Geometry from upcoming.md.', 'upcoming.md'), + ('circleArea', 'Geometry', '(radius)', 'Planned roadmap function for Geometry from upcoming.md.', 'upcoming.md'), + ('circleCircumference', 'Geometry', '(radius)', 'Planned roadmap function for Geometry from upcoming.md.', 'upcoming.md'), + ('distance2D', 'Geometry', '(p1, p2)', 'Planned roadmap function for Geometry from upcoming.md.', 'upcoming.md'), + ('geometryApproximateCircle', 'Geometry', '(value, tolerance=1e-9)', 'Approximate a circle with explicit tolerance controls.', 'professional_function_catalog.md'), + ('geometryApproximateGeometricTransform', 'Geometry', '(value, tolerance=1e-9)', 'Approximate a geometric transform with explicit tolerance controls.', 'professional_function_catalog.md'), + ('geometryApproximateLine', 'Geometry', '(value, tolerance=1e-9)', 'Approximate a line with explicit tolerance controls.', 'professional_function_catalog.md'), + ('geometryApproximatePoint', 'Geometry', '(value, tolerance=1e-9)', 'Approximate a point with explicit tolerance controls.', 'professional_function_catalog.md'), + ('geometryApproximatePolygon', 'Geometry', '(value, tolerance=1e-9)', 'Approximate a polygon with explicit tolerance controls.', 'professional_function_catalog.md'), + ('geometryCanonicalizeCircle', 'Geometry', '(value)', 'Canonicalize a circle so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('geometryCanonicalizeGeometricTransform', 'Geometry', '(value)', 'Canonicalize a geometric transform so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('geometryCanonicalizeLine', 'Geometry', '(value)', 'Canonicalize a line so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('geometryCanonicalizePoint', 'Geometry', '(value)', 'Canonicalize a point so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('geometryCanonicalizePolygon', 'Geometry', '(value)', 'Canonicalize a polygon so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('geometryClassifyCircle', 'Geometry', '(value)', 'Classify a circle by its standard Geometry invariants.', 'professional_function_catalog.md'), + ('geometryClassifyGeometricTransform', 'Geometry', '(value)', 'Classify a geometric transform by its standard Geometry invariants.', 'professional_function_catalog.md'), + ('geometryClassifyLine', 'Geometry', '(value)', 'Classify a line by its standard Geometry invariants.', 'professional_function_catalog.md'), + ('geometryClassifyPoint', 'Geometry', '(value)', 'Classify a point by its standard Geometry invariants.', 'professional_function_catalog.md'), + ('geometryClassifyPolygon', 'Geometry', '(value)', 'Classify a polygon by its standard Geometry invariants.', 'professional_function_catalog.md'), + ('geometryCombineCircle', 'Geometry', '(left, right)', 'Combine two circle values with the natural operation for Geometry.', 'professional_function_catalog.md'), + ('geometryCombineGeometricTransform', 'Geometry', '(left, right)', 'Combine two geometric transform values with the natural operation for Geometry.', 'professional_function_catalog.md'), + ('geometryCombineLine', 'Geometry', '(left, right)', 'Combine two line values with the natural operation for Geometry.', 'professional_function_catalog.md'), + ('geometryCombinePoint', 'Geometry', '(left, right)', 'Combine two point values with the natural operation for Geometry.', 'professional_function_catalog.md'), + ('geometryCombinePolygon', 'Geometry', '(left, right)', 'Combine two polygon values with the natural operation for Geometry.', 'professional_function_catalog.md'), + ('geometryCompareCircle', 'Geometry', '(left, right)', 'Compare two circle values under the conventions of Geometry.', 'professional_function_catalog.md'), + ('geometryCompareGeometricTransform', 'Geometry', '(left, right)', 'Compare two geometric transform values under the conventions of Geometry.', 'professional_function_catalog.md'), + ('geometryCompareLine', 'Geometry', '(left, right)', 'Compare two line values under the conventions of Geometry.', 'professional_function_catalog.md'), + ('geometryComparePoint', 'Geometry', '(left, right)', 'Compare two point values under the conventions of Geometry.', 'professional_function_catalog.md'), + ('geometryComparePolygon', 'Geometry', '(left, right)', 'Compare two polygon values under the conventions of Geometry.', 'professional_function_catalog.md'), + ('geometryComputeCircle', 'Geometry', '(value)', 'Compute the central numerical or symbolic data of a circle.', 'professional_function_catalog.md'), + ('geometryComputeGeometricTransform', 'Geometry', '(value)', 'Compute the central numerical or symbolic data of a geometric transform.', 'professional_function_catalog.md'), + ('geometryComputeLine', 'Geometry', '(value)', 'Compute the central numerical or symbolic data of a line.', 'professional_function_catalog.md'), + ('geometryComputePoint', 'Geometry', '(value)', 'Compute the central numerical or symbolic data of a point.', 'professional_function_catalog.md'), + ('geometryComputePolygon', 'Geometry', '(value)', 'Compute the central numerical or symbolic data of a polygon.', 'professional_function_catalog.md'), + ('geometryConstructCircle', 'Geometry', '(*args)', 'Construct a circle from explicit inputs for Geometry.', 'professional_function_catalog.md'), + ('geometryConstructGeometricTransform', 'Geometry', '(*args)', 'Construct a geometric transform from explicit inputs for Geometry.', 'professional_function_catalog.md'), + ('geometryConstructLine', 'Geometry', '(*args)', 'Construct a line from explicit inputs for Geometry.', 'professional_function_catalog.md'), + ('geometryConstructPoint', 'Geometry', '(*args)', 'Construct a point from explicit inputs for Geometry.', 'professional_function_catalog.md'), + ('geometryConstructPolygon', 'Geometry', '(*args)', 'Construct a polygon from explicit inputs for Geometry.', 'professional_function_catalog.md'), + ('geometryDecomposeCircle', 'Geometry', '(value)', 'Decompose a circle into simpler or canonical components.', 'professional_function_catalog.md'), + ('geometryDecomposeGeometricTransform', 'Geometry', '(value)', 'Decompose a geometric transform into simpler or canonical components.', 'professional_function_catalog.md'), + ('geometryDecomposeLine', 'Geometry', '(value)', 'Decompose a line into simpler or canonical components.', 'professional_function_catalog.md'), + ('geometryDecomposePoint', 'Geometry', '(value)', 'Decompose a point into simpler or canonical components.', 'professional_function_catalog.md'), + ('geometryDecomposePolygon', 'Geometry', '(value)', 'Decompose a polygon into simpler or canonical components.', 'professional_function_catalog.md'), + ('geometryDocumentCircle', 'Geometry', '(value)', 'Return a structured explanation of a circle and related assumptions.', 'professional_function_catalog.md'), + ('geometryDocumentGeometricTransform', 'Geometry', '(value)', 'Return a structured explanation of a geometric transform and related assumptions.', 'professional_function_catalog.md'), + ('geometryDocumentLine', 'Geometry', '(value)', 'Return a structured explanation of a line and related assumptions.', 'professional_function_catalog.md'), + ('geometryDocumentPoint', 'Geometry', '(value)', 'Return a structured explanation of a point and related assumptions.', 'professional_function_catalog.md'), + ('geometryDocumentPolygon', 'Geometry', '(value)', 'Return a structured explanation of a polygon and related assumptions.', 'professional_function_catalog.md'), + ('geometryEnumerateCircle', 'Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a circle.', 'professional_function_catalog.md'), + ('geometryEnumerateGeometricTransform', 'Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a geometric transform.', 'professional_function_catalog.md'), + ('geometryEnumerateLine', 'Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a line.', 'professional_function_catalog.md'), + ('geometryEnumeratePoint', 'Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a point.', 'professional_function_catalog.md'), + ('geometryEnumeratePolygon', 'Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a polygon.', 'professional_function_catalog.md'), + ('geometryEstimateCircle', 'Geometry', '(value, samples=None)', 'Estimate a circle property from finite samples or approximations.', 'professional_function_catalog.md'), + ('geometryEstimateGeometricTransform', 'Geometry', '(value, samples=None)', 'Estimate a geometric transform property from finite samples or approximations.', 'professional_function_catalog.md'), + ('geometryEstimateLine', 'Geometry', '(value, samples=None)', 'Estimate a line property from finite samples or approximations.', 'professional_function_catalog.md'), + ('geometryEstimatePoint', 'Geometry', '(value, samples=None)', 'Estimate a point property from finite samples or approximations.', 'professional_function_catalog.md'), + ('geometryEstimatePolygon', 'Geometry', '(value, samples=None)', 'Estimate a polygon property from finite samples or approximations.', 'professional_function_catalog.md'), + ('geometryEvaluateCircle', 'Geometry', '(value, point=None)', 'Evaluate a circle at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('geometryEvaluateGeometricTransform', 'Geometry', '(value, point=None)', 'Evaluate a geometric transform at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('geometryEvaluateLine', 'Geometry', '(value, point=None)', 'Evaluate a line at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('geometryEvaluatePoint', 'Geometry', '(value, point=None)', 'Evaluate a point at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('geometryEvaluatePolygon', 'Geometry', '(value, point=None)', 'Evaluate a polygon at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('geometryFormatCircle', 'Geometry', '(value)', 'Format a circle for deterministic user-facing output.', 'professional_function_catalog.md'), + ('geometryFormatGeometricTransform', 'Geometry', '(value)', 'Format a geometric transform for deterministic user-facing output.', 'professional_function_catalog.md'), + ('geometryFormatLine', 'Geometry', '(value)', 'Format a line for deterministic user-facing output.', 'professional_function_catalog.md'), + ('geometryFormatPoint', 'Geometry', '(value)', 'Format a point for deterministic user-facing output.', 'professional_function_catalog.md'), + ('geometryFormatPolygon', 'Geometry', '(value)', 'Format a polygon for deterministic user-facing output.', 'professional_function_catalog.md'), + ('geometryGenerateExampleCircle', 'Geometry', '(size=3)', 'Generate a small documented example of a circle.', 'professional_function_catalog.md'), + ('geometryGenerateExampleGeometricTransform', 'Geometry', '(size=3)', 'Generate a small documented example of a geometric transform.', 'professional_function_catalog.md'), + ('geometryGenerateExampleLine', 'Geometry', '(size=3)', 'Generate a small documented example of a line.', 'professional_function_catalog.md'), + ('geometryGenerateExamplePoint', 'Geometry', '(size=3)', 'Generate a small documented example of a point.', 'professional_function_catalog.md'), + ('geometryGenerateExamplePolygon', 'Geometry', '(size=3)', 'Generate a small documented example of a polygon.', 'professional_function_catalog.md'), + ('geometryNormalizeCircle', 'Geometry', '(value)', 'Normalize a circle into the standard Geometry representation.', 'professional_function_catalog.md'), + ('geometryNormalizeGeometricTransform', 'Geometry', '(value)', 'Normalize a geometric transform into the standard Geometry representation.', 'professional_function_catalog.md'), + ('geometryNormalizeLine', 'Geometry', '(value)', 'Normalize a line into the standard Geometry representation.', 'professional_function_catalog.md'), + ('geometryNormalizePoint', 'Geometry', '(value)', 'Normalize a point into the standard Geometry representation.', 'professional_function_catalog.md'), + ('geometryNormalizePolygon', 'Geometry', '(value)', 'Normalize a polygon into the standard Geometry representation.', 'professional_function_catalog.md'), + ('geometryParseCircle', 'Geometry', '(text)', 'Parse a text or structured value into a circle.', 'professional_function_catalog.md'), + ('geometryParseGeometricTransform', 'Geometry', '(text)', 'Parse a text or structured value into a geometric transform.', 'professional_function_catalog.md'), + ('geometryParseLine', 'Geometry', '(text)', 'Parse a text or structured value into a line.', 'professional_function_catalog.md'), + ('geometryParsePoint', 'Geometry', '(text)', 'Parse a text or structured value into a point.', 'professional_function_catalog.md'), + ('geometryParsePolygon', 'Geometry', '(text)', 'Parse a text or structured value into a polygon.', 'professional_function_catalog.md'), + ('geometrySimplifyCircle', 'Geometry', '(value)', 'Simplify a circle without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('geometrySimplifyGeometricTransform', 'Geometry', '(value)', 'Simplify a geometric transform without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('geometrySimplifyLine', 'Geometry', '(value)', 'Simplify a line without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('geometrySimplifyPoint', 'Geometry', '(value)', 'Simplify a point without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('geometrySimplifyPolygon', 'Geometry', '(value)', 'Simplify a polygon without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('geometryTestEquivalenceCircle', 'Geometry', '(left, right)', 'Test whether two circle values are equivalent in Geometry.', 'professional_function_catalog.md'), + ('geometryTestEquivalenceGeometricTransform', 'Geometry', '(left, right)', 'Test whether two geometric transform values are equivalent in Geometry.', 'professional_function_catalog.md'), + ('geometryTestEquivalenceLine', 'Geometry', '(left, right)', 'Test whether two line values are equivalent in Geometry.', 'professional_function_catalog.md'), + ('geometryTestEquivalencePoint', 'Geometry', '(left, right)', 'Test whether two point values are equivalent in Geometry.', 'professional_function_catalog.md'), + ('geometryTestEquivalencePolygon', 'Geometry', '(left, right)', 'Test whether two polygon values are equivalent in Geometry.', 'professional_function_catalog.md'), + ('geometryTransformCircle', 'Geometry', '(value, mapping)', 'Transform a circle through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('geometryTransformGeometricTransform', 'Geometry', '(value, mapping)', 'Transform a geometric transform through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('geometryTransformLine', 'Geometry', '(value, mapping)', 'Transform a line through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('geometryTransformPoint', 'Geometry', '(value, mapping)', 'Transform a point through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('geometryTransformPolygon', 'Geometry', '(value, mapping)', 'Transform a polygon through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('geometryValidateCircle', 'Geometry', '(value)', 'Validate the circle representation and domain rules for Geometry.', 'professional_function_catalog.md'), + ('geometryValidateGeometricTransform', 'Geometry', '(value)', 'Validate the geometric transform representation and domain rules for Geometry.', 'professional_function_catalog.md'), + ('geometryValidateLine', 'Geometry', '(value)', 'Validate the line representation and domain rules for Geometry.', 'professional_function_catalog.md'), + ('geometryValidatePoint', 'Geometry', '(value)', 'Validate the point representation and domain rules for Geometry.', 'professional_function_catalog.md'), + ('geometryValidatePolygon', 'Geometry', '(value)', 'Validate the polygon representation and domain rules for Geometry.', 'professional_function_catalog.md'), + ('isCollinear', 'Geometry', '(points)', 'Planned roadmap function for Geometry from upcoming.md.', 'upcoming.md'), + ('lineIntersection', 'Geometry', '(line1, line2)', 'Planned roadmap function for Geometry from upcoming.md.', 'upcoming.md'), + ('midpoint', 'Geometry', '(p1, p2)', 'Planned roadmap function for Geometry from upcoming.md.', 'upcoming.md'), + ('polygonArea', 'Geometry', '(points)', 'Planned roadmap function for Geometry from upcoming.md.', 'upcoming.md'), + ('slope', 'Geometry', '(p1, p2)', 'Planned roadmap function for Geometry from upcoming.md.', 'upcoming.md'), + ('triangleArea', 'Geometry', '(a, b, c)', 'Planned roadmap function for Geometry from upcoming.md.', 'upcoming.md'), + ('adjacencyMatrix', 'Graph Theory and Discrete Math', '(graph)', 'Planned roadmap function for Graph Theory and Discrete Math from upcoming.md.', 'upcoming.md'), + ('breadthFirstSearch', 'Graph Theory and Discrete Math', '(graph, start)', 'Planned roadmap function for Graph Theory and Discrete Math from upcoming.md.', 'upcoming.md'), + ('degree', 'Graph Theory and Discrete Math', '(graph, vertex)', 'Planned roadmap function for Graph Theory and Discrete Math from upcoming.md.', 'upcoming.md'), + ('depthFirstSearch', 'Graph Theory and Discrete Math', '(graph, start)', 'Planned roadmap function for Graph Theory and Discrete Math from upcoming.md.', 'upcoming.md'), + ('edges', 'Graph Theory and Discrete Math', '(graph)', 'Planned roadmap function for Graph Theory and Discrete Math from upcoming.md.', 'upcoming.md'), + ('graphColoringGreedy', 'Graph Theory and Discrete Math', '(graph)', 'Planned roadmap function for Graph Theory and Discrete Math from upcoming.md.', 'upcoming.md'), + ('graphTheoryAndDiscreteMathApproximateEdgeSet', 'Graph Theory and Discrete Math', '(value, tolerance=1e-9)', 'Approximate a edge set with explicit tolerance controls.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathApproximateGraph', 'Graph Theory and Discrete Math', '(value, tolerance=1e-9)', 'Approximate a graph with explicit tolerance controls.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathApproximateGraphInvariant', 'Graph Theory and Discrete Math', '(value, tolerance=1e-9)', 'Approximate a graph invariant with explicit tolerance controls.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathApproximateVertexSet', 'Graph Theory and Discrete Math', '(value, tolerance=1e-9)', 'Approximate a vertex set with explicit tolerance controls.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathApproximateWalk', 'Graph Theory and Discrete Math', '(value, tolerance=1e-9)', 'Approximate a walk with explicit tolerance controls.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathCanonicalizeEdgeSet', 'Graph Theory and Discrete Math', '(value)', 'Canonicalize a edge set so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathCanonicalizeGraph', 'Graph Theory and Discrete Math', '(value)', 'Canonicalize a graph so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathCanonicalizeGraphInvariant', 'Graph Theory and Discrete Math', '(value)', 'Canonicalize a graph invariant so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathCanonicalizeVertexSet', 'Graph Theory and Discrete Math', '(value)', 'Canonicalize a vertex set so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathCanonicalizeWalk', 'Graph Theory and Discrete Math', '(value)', 'Canonicalize a walk so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathClassifyEdgeSet', 'Graph Theory and Discrete Math', '(value)', 'Classify a edge set by its standard Graph Theory and Discrete Math invariants.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathClassifyGraph', 'Graph Theory and Discrete Math', '(value)', 'Classify a graph by its standard Graph Theory and Discrete Math invariants.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathClassifyGraphInvariant', 'Graph Theory and Discrete Math', '(value)', 'Classify a graph invariant by its standard Graph Theory and Discrete Math invariants.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathClassifyVertexSet', 'Graph Theory and Discrete Math', '(value)', 'Classify a vertex set by its standard Graph Theory and Discrete Math invariants.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathClassifyWalk', 'Graph Theory and Discrete Math', '(value)', 'Classify a walk by its standard Graph Theory and Discrete Math invariants.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathCombineEdgeSet', 'Graph Theory and Discrete Math', '(left, right)', 'Combine two edge set values with the natural operation for Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathCombineGraph', 'Graph Theory and Discrete Math', '(left, right)', 'Combine two graph values with the natural operation for Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathCombineGraphInvariant', 'Graph Theory and Discrete Math', '(left, right)', 'Combine two graph invariant values with the natural operation for Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathCombineVertexSet', 'Graph Theory and Discrete Math', '(left, right)', 'Combine two vertex set values with the natural operation for Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathCombineWalk', 'Graph Theory and Discrete Math', '(left, right)', 'Combine two walk values with the natural operation for Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathCompareEdgeSet', 'Graph Theory and Discrete Math', '(left, right)', 'Compare two edge set values under the conventions of Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathCompareGraph', 'Graph Theory and Discrete Math', '(left, right)', 'Compare two graph values under the conventions of Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathCompareGraphInvariant', 'Graph Theory and Discrete Math', '(left, right)', 'Compare two graph invariant values under the conventions of Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathCompareVertexSet', 'Graph Theory and Discrete Math', '(left, right)', 'Compare two vertex set values under the conventions of Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathCompareWalk', 'Graph Theory and Discrete Math', '(left, right)', 'Compare two walk values under the conventions of Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathComputeEdgeSet', 'Graph Theory and Discrete Math', '(value)', 'Compute the central numerical or symbolic data of a edge set.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathComputeGraph', 'Graph Theory and Discrete Math', '(value)', 'Compute the central numerical or symbolic data of a graph.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathComputeGraphInvariant', 'Graph Theory and Discrete Math', '(value)', 'Compute the central numerical or symbolic data of a graph invariant.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathComputeVertexSet', 'Graph Theory and Discrete Math', '(value)', 'Compute the central numerical or symbolic data of a vertex set.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathComputeWalk', 'Graph Theory and Discrete Math', '(value)', 'Compute the central numerical or symbolic data of a walk.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathConstructEdgeSet', 'Graph Theory and Discrete Math', '(*args)', 'Construct a edge set from explicit inputs for Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathConstructGraph', 'Graph Theory and Discrete Math', '(*args)', 'Construct a graph from explicit inputs for Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathConstructGraphInvariant', 'Graph Theory and Discrete Math', '(*args)', 'Construct a graph invariant from explicit inputs for Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathConstructVertexSet', 'Graph Theory and Discrete Math', '(*args)', 'Construct a vertex set from explicit inputs for Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathConstructWalk', 'Graph Theory and Discrete Math', '(*args)', 'Construct a walk from explicit inputs for Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathDecomposeEdgeSet', 'Graph Theory and Discrete Math', '(value)', 'Decompose a edge set into simpler or canonical components.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathDecomposeGraph', 'Graph Theory and Discrete Math', '(value)', 'Decompose a graph into simpler or canonical components.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathDecomposeGraphInvariant', 'Graph Theory and Discrete Math', '(value)', 'Decompose a graph invariant into simpler or canonical components.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathDecomposeVertexSet', 'Graph Theory and Discrete Math', '(value)', 'Decompose a vertex set into simpler or canonical components.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathDecomposeWalk', 'Graph Theory and Discrete Math', '(value)', 'Decompose a walk into simpler or canonical components.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathDocumentEdgeSet', 'Graph Theory and Discrete Math', '(value)', 'Return a structured explanation of a edge set and related assumptions.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathDocumentGraph', 'Graph Theory and Discrete Math', '(value)', 'Return a structured explanation of a graph and related assumptions.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathDocumentGraphInvariant', 'Graph Theory and Discrete Math', '(value)', 'Return a structured explanation of a graph invariant and related assumptions.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathDocumentVertexSet', 'Graph Theory and Discrete Math', '(value)', 'Return a structured explanation of a vertex set and related assumptions.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathDocumentWalk', 'Graph Theory and Discrete Math', '(value)', 'Return a structured explanation of a walk and related assumptions.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathEnumerateEdgeSet', 'Graph Theory and Discrete Math', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a edge set.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathEnumerateGraph', 'Graph Theory and Discrete Math', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a graph.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathEnumerateGraphInvariant', 'Graph Theory and Discrete Math', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a graph invariant.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathEnumerateVertexSet', 'Graph Theory and Discrete Math', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a vertex set.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathEnumerateWalk', 'Graph Theory and Discrete Math', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a walk.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathEstimateEdgeSet', 'Graph Theory and Discrete Math', '(value, samples=None)', 'Estimate a edge set property from finite samples or approximations.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathEstimateGraph', 'Graph Theory and Discrete Math', '(value, samples=None)', 'Estimate a graph property from finite samples or approximations.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathEstimateGraphInvariant', 'Graph Theory and Discrete Math', '(value, samples=None)', 'Estimate a graph invariant property from finite samples or approximations.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathEstimateVertexSet', 'Graph Theory and Discrete Math', '(value, samples=None)', 'Estimate a vertex set property from finite samples or approximations.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathEstimateWalk', 'Graph Theory and Discrete Math', '(value, samples=None)', 'Estimate a walk property from finite samples or approximations.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathEvaluateEdgeSet', 'Graph Theory and Discrete Math', '(value, point=None)', 'Evaluate a edge set at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathEvaluateGraph', 'Graph Theory and Discrete Math', '(value, point=None)', 'Evaluate a graph at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathEvaluateGraphInvariant', 'Graph Theory and Discrete Math', '(value, point=None)', 'Evaluate a graph invariant at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathEvaluateVertexSet', 'Graph Theory and Discrete Math', '(value, point=None)', 'Evaluate a vertex set at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathEvaluateWalk', 'Graph Theory and Discrete Math', '(value, point=None)', 'Evaluate a walk at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathFormatEdgeSet', 'Graph Theory and Discrete Math', '(value)', 'Format a edge set for deterministic user-facing output.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathFormatGraph', 'Graph Theory and Discrete Math', '(value)', 'Format a graph for deterministic user-facing output.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathFormatGraphInvariant', 'Graph Theory and Discrete Math', '(value)', 'Format a graph invariant for deterministic user-facing output.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathFormatVertexSet', 'Graph Theory and Discrete Math', '(value)', 'Format a vertex set for deterministic user-facing output.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathFormatWalk', 'Graph Theory and Discrete Math', '(value)', 'Format a walk for deterministic user-facing output.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathGenerateExampleEdgeSet', 'Graph Theory and Discrete Math', '(size=3)', 'Generate a small documented example of a edge set.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathGenerateExampleGraph', 'Graph Theory and Discrete Math', '(size=3)', 'Generate a small documented example of a graph.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathGenerateExampleGraphInvariant', 'Graph Theory and Discrete Math', '(size=3)', 'Generate a small documented example of a graph invariant.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathGenerateExampleVertexSet', 'Graph Theory and Discrete Math', '(size=3)', 'Generate a small documented example of a vertex set.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathGenerateExampleWalk', 'Graph Theory and Discrete Math', '(size=3)', 'Generate a small documented example of a walk.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathNormalizeEdgeSet', 'Graph Theory and Discrete Math', '(value)', 'Normalize a edge set into the standard Graph Theory and Discrete Math representation.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathNormalizeGraph', 'Graph Theory and Discrete Math', '(value)', 'Normalize a graph into the standard Graph Theory and Discrete Math representation.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathNormalizeGraphInvariant', 'Graph Theory and Discrete Math', '(value)', 'Normalize a graph invariant into the standard Graph Theory and Discrete Math representation.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathNormalizeVertexSet', 'Graph Theory and Discrete Math', '(value)', 'Normalize a vertex set into the standard Graph Theory and Discrete Math representation.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathNormalizeWalk', 'Graph Theory and Discrete Math', '(value)', 'Normalize a walk into the standard Graph Theory and Discrete Math representation.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathParseEdgeSet', 'Graph Theory and Discrete Math', '(text)', 'Parse a text or structured value into a edge set.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathParseGraph', 'Graph Theory and Discrete Math', '(text)', 'Parse a text or structured value into a graph.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathParseGraphInvariant', 'Graph Theory and Discrete Math', '(text)', 'Parse a text or structured value into a graph invariant.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathParseVertexSet', 'Graph Theory and Discrete Math', '(text)', 'Parse a text or structured value into a vertex set.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathParseWalk', 'Graph Theory and Discrete Math', '(text)', 'Parse a text or structured value into a walk.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathSimplifyEdgeSet', 'Graph Theory and Discrete Math', '(value)', 'Simplify a edge set without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathSimplifyGraph', 'Graph Theory and Discrete Math', '(value)', 'Simplify a graph without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathSimplifyGraphInvariant', 'Graph Theory and Discrete Math', '(value)', 'Simplify a graph invariant without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathSimplifyVertexSet', 'Graph Theory and Discrete Math', '(value)', 'Simplify a vertex set without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathSimplifyWalk', 'Graph Theory and Discrete Math', '(value)', 'Simplify a walk without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathTestEquivalenceEdgeSet', 'Graph Theory and Discrete Math', '(left, right)', 'Test whether two edge set values are equivalent in Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathTestEquivalenceGraph', 'Graph Theory and Discrete Math', '(left, right)', 'Test whether two graph values are equivalent in Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathTestEquivalenceGraphInvariant', 'Graph Theory and Discrete Math', '(left, right)', 'Test whether two graph invariant values are equivalent in Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathTestEquivalenceVertexSet', 'Graph Theory and Discrete Math', '(left, right)', 'Test whether two vertex set values are equivalent in Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathTestEquivalenceWalk', 'Graph Theory and Discrete Math', '(left, right)', 'Test whether two walk values are equivalent in Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathTransformEdgeSet', 'Graph Theory and Discrete Math', '(value, mapping)', 'Transform a edge set through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathTransformGraph', 'Graph Theory and Discrete Math', '(value, mapping)', 'Transform a graph through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathTransformGraphInvariant', 'Graph Theory and Discrete Math', '(value, mapping)', 'Transform a graph invariant through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathTransformVertexSet', 'Graph Theory and Discrete Math', '(value, mapping)', 'Transform a vertex set through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathTransformWalk', 'Graph Theory and Discrete Math', '(value, mapping)', 'Transform a walk through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathValidateEdgeSet', 'Graph Theory and Discrete Math', '(value)', 'Validate the edge set representation and domain rules for Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathValidateGraph', 'Graph Theory and Discrete Math', '(value)', 'Validate the graph representation and domain rules for Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathValidateGraphInvariant', 'Graph Theory and Discrete Math', '(value)', 'Validate the graph invariant representation and domain rules for Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathValidateVertexSet', 'Graph Theory and Discrete Math', '(value)', 'Validate the vertex set representation and domain rules for Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('graphTheoryAndDiscreteMathValidateWalk', 'Graph Theory and Discrete Math', '(value)', 'Validate the walk representation and domain rules for Graph Theory and Discrete Math.', 'professional_function_catalog.md'), + ('hasCycle', 'Graph Theory and Discrete Math', '(graph)', 'Planned roadmap function for Graph Theory and Discrete Math from upcoming.md.', 'upcoming.md'), + ('isConnectedGraph', 'Graph Theory and Discrete Math', '(graph)', 'Planned roadmap function for Graph Theory and Discrete Math from upcoming.md.', 'upcoming.md'), + ('isTree', 'Graph Theory and Discrete Math', '(graph)', 'Planned roadmap function for Graph Theory and Discrete Math from upcoming.md.', 'upcoming.md'), + ('minimumSpanningTree', 'Graph Theory and Discrete Math', '(graph)', 'Planned roadmap function for Graph Theory and Discrete Math from upcoming.md.', 'upcoming.md'), + ('shortestPath', 'Graph Theory and Discrete Math', '(graph, start, end)', 'Planned roadmap function for Graph Theory and Discrete Math from upcoming.md.', 'upcoming.md'), + ('vertices', 'Graph Theory and Discrete Math', '(graph)', 'Planned roadmap function for Graph Theory and Discrete Math from upcoming.md.', 'upcoming.md'), + ('circularConvolution', 'Harmonic Analysis', '(a, b)', 'Planned roadmap function for Harmonic Analysis from upcoming.md.', 'upcoming.md'), + ('correlationSignal', 'Harmonic Analysis', '(a, b)', 'Planned roadmap function for Harmonic Analysis from upcoming.md.', 'upcoming.md'), + ('dirichletKernel', 'Harmonic Analysis', '(n, x)', 'Planned roadmap function for Harmonic Analysis from upcoming.md.', 'upcoming.md'), + ('fourierMagnitude', 'Harmonic Analysis', '(values)', 'Planned roadmap function for Harmonic Analysis from upcoming.md.', 'upcoming.md'), + ('fourierPhase', 'Harmonic Analysis', '(values)', 'Planned roadmap function for Harmonic Analysis from upcoming.md.', 'upcoming.md'), + ('harmonicAnalysisApproximateBasisExpansion', 'Harmonic Analysis', '(value, tolerance=1e-9)', 'Approximate a basis expansion with explicit tolerance controls.', 'professional_function_catalog.md'), + ('harmonicAnalysisApproximateConvolutionOperator', 'Harmonic Analysis', '(value, tolerance=1e-9)', 'Approximate a convolution operator with explicit tolerance controls.', 'professional_function_catalog.md'), + ('harmonicAnalysisApproximateFrequencyBand', 'Harmonic Analysis', '(value, tolerance=1e-9)', 'Approximate a frequency band with explicit tolerance controls.', 'professional_function_catalog.md'), + ('harmonicAnalysisApproximateHarmonicSignal', 'Harmonic Analysis', '(value, tolerance=1e-9)', 'Approximate a harmonic signal with explicit tolerance controls.', 'professional_function_catalog.md'), + ('harmonicAnalysisApproximateKernel', 'Harmonic Analysis', '(value, tolerance=1e-9)', 'Approximate a kernel with explicit tolerance controls.', 'professional_function_catalog.md'), + ('harmonicAnalysisCanonicalizeBasisExpansion', 'Harmonic Analysis', '(value)', 'Canonicalize a basis expansion so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('harmonicAnalysisCanonicalizeConvolutionOperator', 'Harmonic Analysis', '(value)', 'Canonicalize a convolution operator so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('harmonicAnalysisCanonicalizeFrequencyBand', 'Harmonic Analysis', '(value)', 'Canonicalize a frequency band so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('harmonicAnalysisCanonicalizeHarmonicSignal', 'Harmonic Analysis', '(value)', 'Canonicalize a harmonic signal so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('harmonicAnalysisCanonicalizeKernel', 'Harmonic Analysis', '(value)', 'Canonicalize a kernel so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('harmonicAnalysisClassifyBasisExpansion', 'Harmonic Analysis', '(value)', 'Classify a basis expansion by its standard Harmonic Analysis invariants.', 'professional_function_catalog.md'), + ('harmonicAnalysisClassifyConvolutionOperator', 'Harmonic Analysis', '(value)', 'Classify a convolution operator by its standard Harmonic Analysis invariants.', 'professional_function_catalog.md'), + ('harmonicAnalysisClassifyFrequencyBand', 'Harmonic Analysis', '(value)', 'Classify a frequency band by its standard Harmonic Analysis invariants.', 'professional_function_catalog.md'), + ('harmonicAnalysisClassifyHarmonicSignal', 'Harmonic Analysis', '(value)', 'Classify a harmonic signal by its standard Harmonic Analysis invariants.', 'professional_function_catalog.md'), + ('harmonicAnalysisClassifyKernel', 'Harmonic Analysis', '(value)', 'Classify a kernel by its standard Harmonic Analysis invariants.', 'professional_function_catalog.md'), + ('harmonicAnalysisCombineBasisExpansion', 'Harmonic Analysis', '(left, right)', 'Combine two basis expansion values with the natural operation for Harmonic Analysis.', 'professional_function_catalog.md'), + ('harmonicAnalysisCombineConvolutionOperator', 'Harmonic Analysis', '(left, right)', 'Combine two convolution operator values with the natural operation for Harmonic Analysis.', 'professional_function_catalog.md'), + ('harmonicAnalysisCombineFrequencyBand', 'Harmonic Analysis', '(left, right)', 'Combine two frequency band values with the natural operation for Harmonic Analysis.', 'professional_function_catalog.md'), + ('harmonicAnalysisCombineHarmonicSignal', 'Harmonic Analysis', '(left, right)', 'Combine two harmonic signal values with the natural operation for Harmonic Analysis.', 'professional_function_catalog.md'), + ('harmonicAnalysisCombineKernel', 'Harmonic Analysis', '(left, right)', 'Combine two kernel values with the natural operation for Harmonic Analysis.', 'professional_function_catalog.md'), + ('harmonicAnalysisCompareBasisExpansion', 'Harmonic Analysis', '(left, right)', 'Compare two basis expansion values under the conventions of Harmonic Analysis.', 'professional_function_catalog.md'), + ('harmonicAnalysisCompareConvolutionOperator', 'Harmonic Analysis', '(left, right)', 'Compare two convolution operator values under the conventions of Harmonic Analysis.', 'professional_function_catalog.md'), + ('harmonicAnalysisCompareFrequencyBand', 'Harmonic Analysis', '(left, right)', 'Compare two frequency band values under the conventions of Harmonic Analysis.', 'professional_function_catalog.md'), + ('harmonicAnalysisCompareHarmonicSignal', 'Harmonic Analysis', '(left, right)', 'Compare two harmonic signal values under the conventions of Harmonic Analysis.', 'professional_function_catalog.md'), + ('harmonicAnalysisCompareKernel', 'Harmonic Analysis', '(left, right)', 'Compare two kernel values under the conventions of Harmonic Analysis.', 'professional_function_catalog.md'), + ('harmonicAnalysisComputeBasisExpansion', 'Harmonic Analysis', '(value)', 'Compute the central numerical or symbolic data of a basis expansion.', 'professional_function_catalog.md'), + ('harmonicAnalysisComputeConvolutionOperator', 'Harmonic Analysis', '(value)', 'Compute the central numerical or symbolic data of a convolution operator.', 'professional_function_catalog.md'), + ('harmonicAnalysisComputeFrequencyBand', 'Harmonic Analysis', '(value)', 'Compute the central numerical or symbolic data of a frequency band.', 'professional_function_catalog.md'), + ('harmonicAnalysisComputeHarmonicSignal', 'Harmonic Analysis', '(value)', 'Compute the central numerical or symbolic data of a harmonic signal.', 'professional_function_catalog.md'), + ('harmonicAnalysisComputeKernel', 'Harmonic Analysis', '(value)', 'Compute the central numerical or symbolic data of a kernel.', 'professional_function_catalog.md'), + ('harmonicAnalysisConstructBasisExpansion', 'Harmonic Analysis', '(*args)', 'Construct a basis expansion from explicit inputs for Harmonic Analysis.', 'professional_function_catalog.md'), + ('harmonicAnalysisConstructConvolutionOperator', 'Harmonic Analysis', '(*args)', 'Construct a convolution operator from explicit inputs for Harmonic Analysis.', 'professional_function_catalog.md'), + ('harmonicAnalysisConstructFrequencyBand', 'Harmonic Analysis', '(*args)', 'Construct a frequency band from explicit inputs for Harmonic Analysis.', 'professional_function_catalog.md'), + ('harmonicAnalysisConstructHarmonicSignal', 'Harmonic Analysis', '(*args)', 'Construct a harmonic signal from explicit inputs for Harmonic Analysis.', 'professional_function_catalog.md'), + ('harmonicAnalysisConstructKernel', 'Harmonic Analysis', '(*args)', 'Construct a kernel from explicit inputs for Harmonic Analysis.', 'professional_function_catalog.md'), + ('harmonicAnalysisDecomposeBasisExpansion', 'Harmonic Analysis', '(value)', 'Decompose a basis expansion into simpler or canonical components.', 'professional_function_catalog.md'), + ('harmonicAnalysisDecomposeConvolutionOperator', 'Harmonic Analysis', '(value)', 'Decompose a convolution operator into simpler or canonical components.', 'professional_function_catalog.md'), + ('harmonicAnalysisDecomposeFrequencyBand', 'Harmonic Analysis', '(value)', 'Decompose a frequency band into simpler or canonical components.', 'professional_function_catalog.md'), + ('harmonicAnalysisDecomposeHarmonicSignal', 'Harmonic Analysis', '(value)', 'Decompose a harmonic signal into simpler or canonical components.', 'professional_function_catalog.md'), + ('harmonicAnalysisDecomposeKernel', 'Harmonic Analysis', '(value)', 'Decompose a kernel into simpler or canonical components.', 'professional_function_catalog.md'), + ('harmonicAnalysisDocumentBasisExpansion', 'Harmonic Analysis', '(value)', 'Return a structured explanation of a basis expansion and related assumptions.', 'professional_function_catalog.md'), + ('harmonicAnalysisDocumentConvolutionOperator', 'Harmonic Analysis', '(value)', 'Return a structured explanation of a convolution operator and related assumptions.', 'professional_function_catalog.md'), + ('harmonicAnalysisDocumentFrequencyBand', 'Harmonic Analysis', '(value)', 'Return a structured explanation of a frequency band and related assumptions.', 'professional_function_catalog.md'), + ('harmonicAnalysisDocumentHarmonicSignal', 'Harmonic Analysis', '(value)', 'Return a structured explanation of a harmonic signal and related assumptions.', 'professional_function_catalog.md'), + ('harmonicAnalysisDocumentKernel', 'Harmonic Analysis', '(value)', 'Return a structured explanation of a kernel and related assumptions.', 'professional_function_catalog.md'), + ('harmonicAnalysisEnumerateBasisExpansion', 'Harmonic Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a basis expansion.', 'professional_function_catalog.md'), + ('harmonicAnalysisEnumerateConvolutionOperator', 'Harmonic Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a convolution operator.', 'professional_function_catalog.md'), + ('harmonicAnalysisEnumerateFrequencyBand', 'Harmonic Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a frequency band.', 'professional_function_catalog.md'), + ('harmonicAnalysisEnumerateHarmonicSignal', 'Harmonic Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a harmonic signal.', 'professional_function_catalog.md'), + ('harmonicAnalysisEnumerateKernel', 'Harmonic Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a kernel.', 'professional_function_catalog.md'), + ('harmonicAnalysisEstimateBasisExpansion', 'Harmonic Analysis', '(value, samples=None)', 'Estimate a basis expansion property from finite samples or approximations.', 'professional_function_catalog.md'), + ('harmonicAnalysisEstimateConvolutionOperator', 'Harmonic Analysis', '(value, samples=None)', 'Estimate a convolution operator property from finite samples or approximations.', 'professional_function_catalog.md'), + ('harmonicAnalysisEstimateFrequencyBand', 'Harmonic Analysis', '(value, samples=None)', 'Estimate a frequency band property from finite samples or approximations.', 'professional_function_catalog.md'), + ('harmonicAnalysisEstimateHarmonicSignal', 'Harmonic Analysis', '(value, samples=None)', 'Estimate a harmonic signal property from finite samples or approximations.', 'professional_function_catalog.md'), + ('harmonicAnalysisEstimateKernel', 'Harmonic Analysis', '(value, samples=None)', 'Estimate a kernel property from finite samples or approximations.', 'professional_function_catalog.md'), + ('harmonicAnalysisEvaluateBasisExpansion', 'Harmonic Analysis', '(value, point=None)', 'Evaluate a basis expansion at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('harmonicAnalysisEvaluateConvolutionOperator', 'Harmonic Analysis', '(value, point=None)', 'Evaluate a convolution operator at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('harmonicAnalysisEvaluateFrequencyBand', 'Harmonic Analysis', '(value, point=None)', 'Evaluate a frequency band at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('harmonicAnalysisEvaluateHarmonicSignal', 'Harmonic Analysis', '(value, point=None)', 'Evaluate a harmonic signal at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('harmonicAnalysisEvaluateKernel', 'Harmonic Analysis', '(value, point=None)', 'Evaluate a kernel at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('harmonicAnalysisFormatBasisExpansion', 'Harmonic Analysis', '(value)', 'Format a basis expansion for deterministic user-facing output.', 'professional_function_catalog.md'), + ('harmonicAnalysisFormatConvolutionOperator', 'Harmonic Analysis', '(value)', 'Format a convolution operator for deterministic user-facing output.', 'professional_function_catalog.md'), + ('harmonicAnalysisFormatFrequencyBand', 'Harmonic Analysis', '(value)', 'Format a frequency band for deterministic user-facing output.', 'professional_function_catalog.md'), + ('harmonicAnalysisFormatHarmonicSignal', 'Harmonic Analysis', '(value)', 'Format a harmonic signal for deterministic user-facing output.', 'professional_function_catalog.md'), + ('harmonicAnalysisFormatKernel', 'Harmonic Analysis', '(value)', 'Format a kernel for deterministic user-facing output.', 'professional_function_catalog.md'), + ('harmonicAnalysisGenerateExampleBasisExpansion', 'Harmonic Analysis', '(size=3)', 'Generate a small documented example of a basis expansion.', 'professional_function_catalog.md'), + ('harmonicAnalysisGenerateExampleConvolutionOperator', 'Harmonic Analysis', '(size=3)', 'Generate a small documented example of a convolution operator.', 'professional_function_catalog.md'), + ('harmonicAnalysisGenerateExampleFrequencyBand', 'Harmonic Analysis', '(size=3)', 'Generate a small documented example of a frequency band.', 'professional_function_catalog.md'), + ('harmonicAnalysisGenerateExampleHarmonicSignal', 'Harmonic Analysis', '(size=3)', 'Generate a small documented example of a harmonic signal.', 'professional_function_catalog.md'), + ('harmonicAnalysisGenerateExampleKernel', 'Harmonic Analysis', '(size=3)', 'Generate a small documented example of a kernel.', 'professional_function_catalog.md'), + ('harmonicAnalysisNormalizeBasisExpansion', 'Harmonic Analysis', '(value)', 'Normalize a basis expansion into the standard Harmonic Analysis representation.', 'professional_function_catalog.md'), + ('harmonicAnalysisNormalizeConvolutionOperator', 'Harmonic Analysis', '(value)', 'Normalize a convolution operator into the standard Harmonic Analysis representation.', 'professional_function_catalog.md'), + ('harmonicAnalysisNormalizeFrequencyBand', 'Harmonic Analysis', '(value)', 'Normalize a frequency band into the standard Harmonic Analysis representation.', 'professional_function_catalog.md'), + ('harmonicAnalysisNormalizeHarmonicSignal', 'Harmonic Analysis', '(value)', 'Normalize a harmonic signal into the standard Harmonic Analysis representation.', 'professional_function_catalog.md'), + ('harmonicAnalysisNormalizeKernel', 'Harmonic Analysis', '(value)', 'Normalize a kernel into the standard Harmonic Analysis representation.', 'professional_function_catalog.md'), + ('harmonicAnalysisParseBasisExpansion', 'Harmonic Analysis', '(text)', 'Parse a text or structured value into a basis expansion.', 'professional_function_catalog.md'), + ('harmonicAnalysisParseConvolutionOperator', 'Harmonic Analysis', '(text)', 'Parse a text or structured value into a convolution operator.', 'professional_function_catalog.md'), + ('harmonicAnalysisParseFrequencyBand', 'Harmonic Analysis', '(text)', 'Parse a text or structured value into a frequency band.', 'professional_function_catalog.md'), + ('harmonicAnalysisParseHarmonicSignal', 'Harmonic Analysis', '(text)', 'Parse a text or structured value into a harmonic signal.', 'professional_function_catalog.md'), + ('harmonicAnalysisParseKernel', 'Harmonic Analysis', '(text)', 'Parse a text or structured value into a kernel.', 'professional_function_catalog.md'), + ('harmonicAnalysisSimplifyBasisExpansion', 'Harmonic Analysis', '(value)', 'Simplify a basis expansion without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('harmonicAnalysisSimplifyConvolutionOperator', 'Harmonic Analysis', '(value)', 'Simplify a convolution operator without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('harmonicAnalysisSimplifyFrequencyBand', 'Harmonic Analysis', '(value)', 'Simplify a frequency band without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('harmonicAnalysisSimplifyHarmonicSignal', 'Harmonic Analysis', '(value)', 'Simplify a harmonic signal without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('harmonicAnalysisSimplifyKernel', 'Harmonic Analysis', '(value)', 'Simplify a kernel without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('harmonicAnalysisTestEquivalenceBasisExpansion', 'Harmonic Analysis', '(left, right)', 'Test whether two basis expansion values are equivalent in Harmonic Analysis.', 'professional_function_catalog.md'), + ('harmonicAnalysisTestEquivalenceConvolutionOperator', 'Harmonic Analysis', '(left, right)', 'Test whether two convolution operator values are equivalent in Harmonic Analysis.', 'professional_function_catalog.md'), + ('harmonicAnalysisTestEquivalenceFrequencyBand', 'Harmonic Analysis', '(left, right)', 'Test whether two frequency band values are equivalent in Harmonic Analysis.', 'professional_function_catalog.md'), + ('harmonicAnalysisTestEquivalenceHarmonicSignal', 'Harmonic Analysis', '(left, right)', 'Test whether two harmonic signal values are equivalent in Harmonic Analysis.', 'professional_function_catalog.md'), + ('harmonicAnalysisTestEquivalenceKernel', 'Harmonic Analysis', '(left, right)', 'Test whether two kernel values are equivalent in Harmonic Analysis.', 'professional_function_catalog.md'), + ('harmonicAnalysisTransformBasisExpansion', 'Harmonic Analysis', '(value, mapping)', 'Transform a basis expansion through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('harmonicAnalysisTransformConvolutionOperator', 'Harmonic Analysis', '(value, mapping)', 'Transform a convolution operator through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('harmonicAnalysisTransformFrequencyBand', 'Harmonic Analysis', '(value, mapping)', 'Transform a frequency band through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('harmonicAnalysisTransformHarmonicSignal', 'Harmonic Analysis', '(value, mapping)', 'Transform a harmonic signal through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('harmonicAnalysisTransformKernel', 'Harmonic Analysis', '(value, mapping)', 'Transform a kernel through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('harmonicAnalysisValidateBasisExpansion', 'Harmonic Analysis', '(value)', 'Validate the basis expansion representation and domain rules for Harmonic Analysis.', 'professional_function_catalog.md'), + ('harmonicAnalysisValidateConvolutionOperator', 'Harmonic Analysis', '(value)', 'Validate the convolution operator representation and domain rules for Harmonic Analysis.', 'professional_function_catalog.md'), + ('harmonicAnalysisValidateFrequencyBand', 'Harmonic Analysis', '(value)', 'Validate the frequency band representation and domain rules for Harmonic Analysis.', 'professional_function_catalog.md'), + ('harmonicAnalysisValidateHarmonicSignal', 'Harmonic Analysis', '(value)', 'Validate the harmonic signal representation and domain rules for Harmonic Analysis.', 'professional_function_catalog.md'), + ('harmonicAnalysisValidateKernel', 'Harmonic Analysis', '(value)', 'Validate the kernel representation and domain rules for Harmonic Analysis.', 'professional_function_catalog.md'), + ('highPassFilter', 'Harmonic Analysis', '(values, cutoff)', 'Planned roadmap function for Harmonic Analysis from upcoming.md.', 'upcoming.md'), + ('lowPassFilter', 'Harmonic Analysis', '(values, cutoff)', 'Planned roadmap function for Harmonic Analysis from upcoming.md.', 'upcoming.md'), + ('normalizeSignal', 'Harmonic Analysis', '(values)', 'Planned roadmap function for Harmonic Analysis from upcoming.md.', 'upcoming.md'), + ('chainMap', 'Homological Algebra', '(complexA, complexB, maps)', 'Planned roadmap function for Homological Algebra from upcoming.md.', 'upcoming.md'), + ('homologicalAlgebraApproximateChainComplex', 'Homological Algebra', '(value, tolerance=1e-9)', 'Approximate a chain complex with explicit tolerance controls.', 'professional_function_catalog.md'), + ('homologicalAlgebraApproximateChainMap', 'Homological Algebra', '(value, tolerance=1e-9)', 'Approximate a chain map with explicit tolerance controls.', 'professional_function_catalog.md'), + ('homologicalAlgebraApproximateDerivedFunctor', 'Homological Algebra', '(value, tolerance=1e-9)', 'Approximate a derived functor with explicit tolerance controls.', 'professional_function_catalog.md'), + ('homologicalAlgebraApproximateExactSequence', 'Homological Algebra', '(value, tolerance=1e-9)', 'Approximate a exact sequence with explicit tolerance controls.', 'professional_function_catalog.md'), + ('homologicalAlgebraApproximateHomologyObject', 'Homological Algebra', '(value, tolerance=1e-9)', 'Approximate a homology object with explicit tolerance controls.', 'professional_function_catalog.md'), + ('homologicalAlgebraCanonicalizeChainComplex', 'Homological Algebra', '(value)', 'Canonicalize a chain complex so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('homologicalAlgebraCanonicalizeChainMap', 'Homological Algebra', '(value)', 'Canonicalize a chain map so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('homologicalAlgebraCanonicalizeDerivedFunctor', 'Homological Algebra', '(value)', 'Canonicalize a derived functor so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('homologicalAlgebraCanonicalizeExactSequence', 'Homological Algebra', '(value)', 'Canonicalize a exact sequence so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('homologicalAlgebraCanonicalizeHomologyObject', 'Homological Algebra', '(value)', 'Canonicalize a homology object so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('homologicalAlgebraClassifyChainComplex', 'Homological Algebra', '(value)', 'Classify a chain complex by its standard Homological Algebra invariants.', 'professional_function_catalog.md'), + ('homologicalAlgebraClassifyChainMap', 'Homological Algebra', '(value)', 'Classify a chain map by its standard Homological Algebra invariants.', 'professional_function_catalog.md'), + ('homologicalAlgebraClassifyDerivedFunctor', 'Homological Algebra', '(value)', 'Classify a derived functor by its standard Homological Algebra invariants.', 'professional_function_catalog.md'), + ('homologicalAlgebraClassifyExactSequence', 'Homological Algebra', '(value)', 'Classify a exact sequence by its standard Homological Algebra invariants.', 'professional_function_catalog.md'), + ('homologicalAlgebraClassifyHomologyObject', 'Homological Algebra', '(value)', 'Classify a homology object by its standard Homological Algebra invariants.', 'professional_function_catalog.md'), + ('homologicalAlgebraCombineChainComplex', 'Homological Algebra', '(left, right)', 'Combine two chain complex values with the natural operation for Homological Algebra.', 'professional_function_catalog.md'), + ('homologicalAlgebraCombineChainMap', 'Homological Algebra', '(left, right)', 'Combine two chain map values with the natural operation for Homological Algebra.', 'professional_function_catalog.md'), + ('homologicalAlgebraCombineDerivedFunctor', 'Homological Algebra', '(left, right)', 'Combine two derived functor values with the natural operation for Homological Algebra.', 'professional_function_catalog.md'), + ('homologicalAlgebraCombineExactSequence', 'Homological Algebra', '(left, right)', 'Combine two exact sequence values with the natural operation for Homological Algebra.', 'professional_function_catalog.md'), + ('homologicalAlgebraCombineHomologyObject', 'Homological Algebra', '(left, right)', 'Combine two homology object values with the natural operation for Homological Algebra.', 'professional_function_catalog.md'), + ('homologicalAlgebraCompareChainComplex', 'Homological Algebra', '(left, right)', 'Compare two chain complex values under the conventions of Homological Algebra.', 'professional_function_catalog.md'), + ('homologicalAlgebraCompareChainMap', 'Homological Algebra', '(left, right)', 'Compare two chain map values under the conventions of Homological Algebra.', 'professional_function_catalog.md'), + ('homologicalAlgebraCompareDerivedFunctor', 'Homological Algebra', '(left, right)', 'Compare two derived functor values under the conventions of Homological Algebra.', 'professional_function_catalog.md'), + ('homologicalAlgebraCompareExactSequence', 'Homological Algebra', '(left, right)', 'Compare two exact sequence values under the conventions of Homological Algebra.', 'professional_function_catalog.md'), + ('homologicalAlgebraCompareHomologyObject', 'Homological Algebra', '(left, right)', 'Compare two homology object values under the conventions of Homological Algebra.', 'professional_function_catalog.md'), + ('homologicalAlgebraComputeChainComplex', 'Homological Algebra', '(value)', 'Compute the central numerical or symbolic data of a chain complex.', 'professional_function_catalog.md'), + ('homologicalAlgebraComputeChainMap', 'Homological Algebra', '(value)', 'Compute the central numerical or symbolic data of a chain map.', 'professional_function_catalog.md'), + ('homologicalAlgebraComputeDerivedFunctor', 'Homological Algebra', '(value)', 'Compute the central numerical or symbolic data of a derived functor.', 'professional_function_catalog.md'), + ('homologicalAlgebraComputeExactSequence', 'Homological Algebra', '(value)', 'Compute the central numerical or symbolic data of a exact sequence.', 'professional_function_catalog.md'), + ('homologicalAlgebraComputeHomologyObject', 'Homological Algebra', '(value)', 'Compute the central numerical or symbolic data of a homology object.', 'professional_function_catalog.md'), + ('homologicalAlgebraConstructChainComplex', 'Homological Algebra', '(*args)', 'Construct a chain complex from explicit inputs for Homological Algebra.', 'professional_function_catalog.md'), + ('homologicalAlgebraConstructChainMap', 'Homological Algebra', '(*args)', 'Construct a chain map from explicit inputs for Homological Algebra.', 'professional_function_catalog.md'), + ('homologicalAlgebraConstructDerivedFunctor', 'Homological Algebra', '(*args)', 'Construct a derived functor from explicit inputs for Homological Algebra.', 'professional_function_catalog.md'), + ('homologicalAlgebraConstructExactSequence', 'Homological Algebra', '(*args)', 'Construct a exact sequence from explicit inputs for Homological Algebra.', 'professional_function_catalog.md'), + ('homologicalAlgebraConstructHomologyObject', 'Homological Algebra', '(*args)', 'Construct a homology object from explicit inputs for Homological Algebra.', 'professional_function_catalog.md'), + ('homologicalAlgebraDecomposeChainComplex', 'Homological Algebra', '(value)', 'Decompose a chain complex into simpler or canonical components.', 'professional_function_catalog.md'), + ('homologicalAlgebraDecomposeChainMap', 'Homological Algebra', '(value)', 'Decompose a chain map into simpler or canonical components.', 'professional_function_catalog.md'), + ('homologicalAlgebraDecomposeDerivedFunctor', 'Homological Algebra', '(value)', 'Decompose a derived functor into simpler or canonical components.', 'professional_function_catalog.md'), + ('homologicalAlgebraDecomposeExactSequence', 'Homological Algebra', '(value)', 'Decompose a exact sequence into simpler or canonical components.', 'professional_function_catalog.md'), + ('homologicalAlgebraDecomposeHomologyObject', 'Homological Algebra', '(value)', 'Decompose a homology object into simpler or canonical components.', 'professional_function_catalog.md'), + ('homologicalAlgebraDocumentChainComplex', 'Homological Algebra', '(value)', 'Return a structured explanation of a chain complex and related assumptions.', 'professional_function_catalog.md'), + ('homologicalAlgebraDocumentChainMap', 'Homological Algebra', '(value)', 'Return a structured explanation of a chain map and related assumptions.', 'professional_function_catalog.md'), + ('homologicalAlgebraDocumentDerivedFunctor', 'Homological Algebra', '(value)', 'Return a structured explanation of a derived functor and related assumptions.', 'professional_function_catalog.md'), + ('homologicalAlgebraDocumentExactSequence', 'Homological Algebra', '(value)', 'Return a structured explanation of a exact sequence and related assumptions.', 'professional_function_catalog.md'), + ('homologicalAlgebraDocumentHomologyObject', 'Homological Algebra', '(value)', 'Return a structured explanation of a homology object and related assumptions.', 'professional_function_catalog.md'), + ('homologicalAlgebraEnumerateChainComplex', 'Homological Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a chain complex.', 'professional_function_catalog.md'), + ('homologicalAlgebraEnumerateChainMap', 'Homological Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a chain map.', 'professional_function_catalog.md'), + ('homologicalAlgebraEnumerateDerivedFunctor', 'Homological Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a derived functor.', 'professional_function_catalog.md'), + ('homologicalAlgebraEnumerateExactSequence', 'Homological Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a exact sequence.', 'professional_function_catalog.md'), + ('homologicalAlgebraEnumerateHomologyObject', 'Homological Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a homology object.', 'professional_function_catalog.md'), + ('homologicalAlgebraEstimateChainComplex', 'Homological Algebra', '(value, samples=None)', 'Estimate a chain complex property from finite samples or approximations.', 'professional_function_catalog.md'), + ('homologicalAlgebraEstimateChainMap', 'Homological Algebra', '(value, samples=None)', 'Estimate a chain map property from finite samples or approximations.', 'professional_function_catalog.md'), + ('homologicalAlgebraEstimateDerivedFunctor', 'Homological Algebra', '(value, samples=None)', 'Estimate a derived functor property from finite samples or approximations.', 'professional_function_catalog.md'), + ('homologicalAlgebraEstimateExactSequence', 'Homological Algebra', '(value, samples=None)', 'Estimate a exact sequence property from finite samples or approximations.', 'professional_function_catalog.md'), + ('homologicalAlgebraEstimateHomologyObject', 'Homological Algebra', '(value, samples=None)', 'Estimate a homology object property from finite samples or approximations.', 'professional_function_catalog.md'), + ('homologicalAlgebraEvaluateChainComplex', 'Homological Algebra', '(value, point=None)', 'Evaluate a chain complex at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('homologicalAlgebraEvaluateChainMap', 'Homological Algebra', '(value, point=None)', 'Evaluate a chain map at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('homologicalAlgebraEvaluateDerivedFunctor', 'Homological Algebra', '(value, point=None)', 'Evaluate a derived functor at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('homologicalAlgebraEvaluateExactSequence', 'Homological Algebra', '(value, point=None)', 'Evaluate a exact sequence at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('homologicalAlgebraEvaluateHomologyObject', 'Homological Algebra', '(value, point=None)', 'Evaluate a homology object at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('homologicalAlgebraFormatChainComplex', 'Homological Algebra', '(value)', 'Format a chain complex for deterministic user-facing output.', 'professional_function_catalog.md'), + ('homologicalAlgebraFormatChainMap', 'Homological Algebra', '(value)', 'Format a chain map for deterministic user-facing output.', 'professional_function_catalog.md'), + ('homologicalAlgebraFormatDerivedFunctor', 'Homological Algebra', '(value)', 'Format a derived functor for deterministic user-facing output.', 'professional_function_catalog.md'), + ('homologicalAlgebraFormatExactSequence', 'Homological Algebra', '(value)', 'Format a exact sequence for deterministic user-facing output.', 'professional_function_catalog.md'), + ('homologicalAlgebraFormatHomologyObject', 'Homological Algebra', '(value)', 'Format a homology object for deterministic user-facing output.', 'professional_function_catalog.md'), + ('homologicalAlgebraGenerateExampleChainComplex', 'Homological Algebra', '(size=3)', 'Generate a small documented example of a chain complex.', 'professional_function_catalog.md'), + ('homologicalAlgebraGenerateExampleChainMap', 'Homological Algebra', '(size=3)', 'Generate a small documented example of a chain map.', 'professional_function_catalog.md'), + ('homologicalAlgebraGenerateExampleDerivedFunctor', 'Homological Algebra', '(size=3)', 'Generate a small documented example of a derived functor.', 'professional_function_catalog.md'), + ('homologicalAlgebraGenerateExampleExactSequence', 'Homological Algebra', '(size=3)', 'Generate a small documented example of a exact sequence.', 'professional_function_catalog.md'), + ('homologicalAlgebraGenerateExampleHomologyObject', 'Homological Algebra', '(size=3)', 'Generate a small documented example of a homology object.', 'professional_function_catalog.md'), + ('homologicalAlgebraNormalizeChainComplex', 'Homological Algebra', '(value)', 'Normalize a chain complex into the standard Homological Algebra representation.', 'professional_function_catalog.md'), + ('homologicalAlgebraNormalizeChainMap', 'Homological Algebra', '(value)', 'Normalize a chain map into the standard Homological Algebra representation.', 'professional_function_catalog.md'), + ('homologicalAlgebraNormalizeDerivedFunctor', 'Homological Algebra', '(value)', 'Normalize a derived functor into the standard Homological Algebra representation.', 'professional_function_catalog.md'), + ('homologicalAlgebraNormalizeExactSequence', 'Homological Algebra', '(value)', 'Normalize a exact sequence into the standard Homological Algebra representation.', 'professional_function_catalog.md'), + ('homologicalAlgebraNormalizeHomologyObject', 'Homological Algebra', '(value)', 'Normalize a homology object into the standard Homological Algebra representation.', 'professional_function_catalog.md'), + ('homologicalAlgebraParseChainComplex', 'Homological Algebra', '(text)', 'Parse a text or structured value into a chain complex.', 'professional_function_catalog.md'), + ('homologicalAlgebraParseChainMap', 'Homological Algebra', '(text)', 'Parse a text or structured value into a chain map.', 'professional_function_catalog.md'), + ('homologicalAlgebraParseDerivedFunctor', 'Homological Algebra', '(text)', 'Parse a text or structured value into a derived functor.', 'professional_function_catalog.md'), + ('homologicalAlgebraParseExactSequence', 'Homological Algebra', '(text)', 'Parse a text or structured value into a exact sequence.', 'professional_function_catalog.md'), + ('homologicalAlgebraParseHomologyObject', 'Homological Algebra', '(text)', 'Parse a text or structured value into a homology object.', 'professional_function_catalog.md'), + ('homologicalAlgebraSimplifyChainComplex', 'Homological Algebra', '(value)', 'Simplify a chain complex without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('homologicalAlgebraSimplifyChainMap', 'Homological Algebra', '(value)', 'Simplify a chain map without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('homologicalAlgebraSimplifyDerivedFunctor', 'Homological Algebra', '(value)', 'Simplify a derived functor without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('homologicalAlgebraSimplifyExactSequence', 'Homological Algebra', '(value)', 'Simplify a exact sequence without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('homologicalAlgebraSimplifyHomologyObject', 'Homological Algebra', '(value)', 'Simplify a homology object without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('homologicalAlgebraTestEquivalenceChainComplex', 'Homological Algebra', '(left, right)', 'Test whether two chain complex values are equivalent in Homological Algebra.', 'professional_function_catalog.md'), + ('homologicalAlgebraTestEquivalenceChainMap', 'Homological Algebra', '(left, right)', 'Test whether two chain map values are equivalent in Homological Algebra.', 'professional_function_catalog.md'), + ('homologicalAlgebraTestEquivalenceDerivedFunctor', 'Homological Algebra', '(left, right)', 'Test whether two derived functor values are equivalent in Homological Algebra.', 'professional_function_catalog.md'), + ('homologicalAlgebraTestEquivalenceExactSequence', 'Homological Algebra', '(left, right)', 'Test whether two exact sequence values are equivalent in Homological Algebra.', 'professional_function_catalog.md'), + ('homologicalAlgebraTestEquivalenceHomologyObject', 'Homological Algebra', '(left, right)', 'Test whether two homology object values are equivalent in Homological Algebra.', 'professional_function_catalog.md'), + ('homologicalAlgebraTransformChainComplex', 'Homological Algebra', '(value, mapping)', 'Transform a chain complex through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('homologicalAlgebraTransformChainMap', 'Homological Algebra', '(value, mapping)', 'Transform a chain map through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('homologicalAlgebraTransformDerivedFunctor', 'Homological Algebra', '(value, mapping)', 'Transform a derived functor through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('homologicalAlgebraTransformExactSequence', 'Homological Algebra', '(value, mapping)', 'Transform a exact sequence through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('homologicalAlgebraTransformHomologyObject', 'Homological Algebra', '(value, mapping)', 'Transform a homology object through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('homologicalAlgebraValidateChainComplex', 'Homological Algebra', '(value)', 'Validate the chain complex representation and domain rules for Homological Algebra.', 'professional_function_catalog.md'), + ('homologicalAlgebraValidateChainMap', 'Homological Algebra', '(value)', 'Validate the chain map representation and domain rules for Homological Algebra.', 'professional_function_catalog.md'), + ('homologicalAlgebraValidateDerivedFunctor', 'Homological Algebra', '(value)', 'Validate the derived functor representation and domain rules for Homological Algebra.', 'professional_function_catalog.md'), + ('homologicalAlgebraValidateExactSequence', 'Homological Algebra', '(value)', 'Validate the exact sequence representation and domain rules for Homological Algebra.', 'professional_function_catalog.md'), + ('homologicalAlgebraValidateHomologyObject', 'Homological Algebra', '(value)', 'Validate the homology object representation and domain rules for Homological Algebra.', 'professional_function_catalog.md'), + ('homologyDimension', 'Homological Algebra', '(boundaryN, boundaryNext)', 'Planned roadmap function for Homological Algebra from upcoming.md.', 'upcoming.md'), + ('imageDimension', 'Homological Algebra', '(matrix)', 'Planned roadmap function for Homological Algebra from upcoming.md.', 'upcoming.md'), + ('isChainComplex', 'Homological Algebra', '(boundaryMatrices)', 'Planned roadmap function for Homological Algebra from upcoming.md.', 'upcoming.md'), + ('isExactAt', 'Homological Algebra', '(mapA, mapB)', 'Planned roadmap function for Homological Algebra from upcoming.md.', 'upcoming.md'), + ('kernelDimension', 'Homological Algebra', '(matrix)', 'Planned roadmap function for Homological Algebra from upcoming.md.', 'upcoming.md'), + ('longExactSequenceRanks', 'Homological Algebra', '(data)', 'Planned roadmap function for Homological Algebra from upcoming.md.', 'upcoming.md'), + ('mappingCone', 'Homological Algebra', '(chainMap)', 'Planned roadmap function for Homological Algebra from upcoming.md.', 'upcoming.md'), + ('composePaths', 'Homotopy Theory', '(path1, path2)', 'Planned roadmap function for Homotopy Theory from upcoming.md.', 'upcoming.md'), + ('contractible', 'Homotopy Theory', '(space)', 'Planned roadmap function for Homotopy Theory from upcoming.md.', 'upcoming.md'), + ('coveringMap', 'Homotopy Theory', '(domain, codomain, mapping)', 'Planned roadmap function for Homotopy Theory from upcoming.md.', 'upcoming.md'), + ('eulerCharacteristic', 'Homotopy Theory', '(complex)', 'Planned roadmap function for Homotopy Theory from upcoming.md.', 'upcoming.md'), + ('fundamentalGroupFinite', 'Homotopy Theory', '(space, basePoint)', 'Planned roadmap function for Homotopy Theory from upcoming.md.', 'upcoming.md'), + ('homotopyEquivalent', 'Homotopy Theory', '(space1, space2)', 'Planned roadmap function for Homotopy Theory from upcoming.md.', 'upcoming.md'), + ('homotopyTheoryApproximateHomotopy', 'Homotopy Theory', '(value, tolerance=1e-9)', 'Approximate a homotopy with explicit tolerance controls.', 'professional_function_catalog.md'), + ('homotopyTheoryApproximateHomotopyInvariant', 'Homotopy Theory', '(value, tolerance=1e-9)', 'Approximate a homotopy invariant with explicit tolerance controls.', 'professional_function_catalog.md'), + ('homotopyTheoryApproximateLoopSpace', 'Homotopy Theory', '(value, tolerance=1e-9)', 'Approximate a loop space with explicit tolerance controls.', 'professional_function_catalog.md'), + ('homotopyTheoryApproximatePath', 'Homotopy Theory', '(value, tolerance=1e-9)', 'Approximate a path with explicit tolerance controls.', 'professional_function_catalog.md'), + ('homotopyTheoryApproximateSimplicialComplex', 'Homotopy Theory', '(value, tolerance=1e-9)', 'Approximate a simplicial complex with explicit tolerance controls.', 'professional_function_catalog.md'), + ('homotopyTheoryCanonicalizeHomotopy', 'Homotopy Theory', '(value)', 'Canonicalize a homotopy so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('homotopyTheoryCanonicalizeHomotopyInvariant', 'Homotopy Theory', '(value)', 'Canonicalize a homotopy invariant so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('homotopyTheoryCanonicalizeLoopSpace', 'Homotopy Theory', '(value)', 'Canonicalize a loop space so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('homotopyTheoryCanonicalizePath', 'Homotopy Theory', '(value)', 'Canonicalize a path so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('homotopyTheoryCanonicalizeSimplicialComplex', 'Homotopy Theory', '(value)', 'Canonicalize a simplicial complex so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('homotopyTheoryClassifyHomotopy', 'Homotopy Theory', '(value)', 'Classify a homotopy by its standard Homotopy Theory invariants.', 'professional_function_catalog.md'), + ('homotopyTheoryClassifyHomotopyInvariant', 'Homotopy Theory', '(value)', 'Classify a homotopy invariant by its standard Homotopy Theory invariants.', 'professional_function_catalog.md'), + ('homotopyTheoryClassifyLoopSpace', 'Homotopy Theory', '(value)', 'Classify a loop space by its standard Homotopy Theory invariants.', 'professional_function_catalog.md'), + ('homotopyTheoryClassifyPath', 'Homotopy Theory', '(value)', 'Classify a path by its standard Homotopy Theory invariants.', 'professional_function_catalog.md'), + ('homotopyTheoryClassifySimplicialComplex', 'Homotopy Theory', '(value)', 'Classify a simplicial complex by its standard Homotopy Theory invariants.', 'professional_function_catalog.md'), + ('homotopyTheoryCombineHomotopy', 'Homotopy Theory', '(left, right)', 'Combine two homotopy values with the natural operation for Homotopy Theory.', 'professional_function_catalog.md'), + ('homotopyTheoryCombineHomotopyInvariant', 'Homotopy Theory', '(left, right)', 'Combine two homotopy invariant values with the natural operation for Homotopy Theory.', 'professional_function_catalog.md'), + ('homotopyTheoryCombineLoopSpace', 'Homotopy Theory', '(left, right)', 'Combine two loop space values with the natural operation for Homotopy Theory.', 'professional_function_catalog.md'), + ('homotopyTheoryCombinePath', 'Homotopy Theory', '(left, right)', 'Combine two path values with the natural operation for Homotopy Theory.', 'professional_function_catalog.md'), + ('homotopyTheoryCombineSimplicialComplex', 'Homotopy Theory', '(left, right)', 'Combine two simplicial complex values with the natural operation for Homotopy Theory.', 'professional_function_catalog.md'), + ('homotopyTheoryCompareHomotopy', 'Homotopy Theory', '(left, right)', 'Compare two homotopy values under the conventions of Homotopy Theory.', 'professional_function_catalog.md'), + ('homotopyTheoryCompareHomotopyInvariant', 'Homotopy Theory', '(left, right)', 'Compare two homotopy invariant values under the conventions of Homotopy Theory.', 'professional_function_catalog.md'), + ('homotopyTheoryCompareLoopSpace', 'Homotopy Theory', '(left, right)', 'Compare two loop space values under the conventions of Homotopy Theory.', 'professional_function_catalog.md'), + ('homotopyTheoryComparePath', 'Homotopy Theory', '(left, right)', 'Compare two path values under the conventions of Homotopy Theory.', 'professional_function_catalog.md'), + ('homotopyTheoryCompareSimplicialComplex', 'Homotopy Theory', '(left, right)', 'Compare two simplicial complex values under the conventions of Homotopy Theory.', 'professional_function_catalog.md'), + ('homotopyTheoryComputeHomotopy', 'Homotopy Theory', '(value)', 'Compute the central numerical or symbolic data of a homotopy.', 'professional_function_catalog.md'), + ('homotopyTheoryComputeHomotopyInvariant', 'Homotopy Theory', '(value)', 'Compute the central numerical or symbolic data of a homotopy invariant.', 'professional_function_catalog.md'), + ('homotopyTheoryComputeLoopSpace', 'Homotopy Theory', '(value)', 'Compute the central numerical or symbolic data of a loop space.', 'professional_function_catalog.md'), + ('homotopyTheoryComputePath', 'Homotopy Theory', '(value)', 'Compute the central numerical or symbolic data of a path.', 'professional_function_catalog.md'), + ('homotopyTheoryComputeSimplicialComplex', 'Homotopy Theory', '(value)', 'Compute the central numerical or symbolic data of a simplicial complex.', 'professional_function_catalog.md'), + ('homotopyTheoryConstructHomotopy', 'Homotopy Theory', '(*args)', 'Construct a homotopy from explicit inputs for Homotopy Theory.', 'professional_function_catalog.md'), + ('homotopyTheoryConstructHomotopyInvariant', 'Homotopy Theory', '(*args)', 'Construct a homotopy invariant from explicit inputs for Homotopy Theory.', 'professional_function_catalog.md'), + ('homotopyTheoryConstructLoopSpace', 'Homotopy Theory', '(*args)', 'Construct a loop space from explicit inputs for Homotopy Theory.', 'professional_function_catalog.md'), + ('homotopyTheoryConstructPath', 'Homotopy Theory', '(*args)', 'Construct a path from explicit inputs for Homotopy Theory.', 'professional_function_catalog.md'), + ('homotopyTheoryConstructSimplicialComplex', 'Homotopy Theory', '(*args)', 'Construct a simplicial complex from explicit inputs for Homotopy Theory.', 'professional_function_catalog.md'), + ('homotopyTheoryDecomposeHomotopy', 'Homotopy Theory', '(value)', 'Decompose a homotopy into simpler or canonical components.', 'professional_function_catalog.md'), + ('homotopyTheoryDecomposeHomotopyInvariant', 'Homotopy Theory', '(value)', 'Decompose a homotopy invariant into simpler or canonical components.', 'professional_function_catalog.md'), + ('homotopyTheoryDecomposeLoopSpace', 'Homotopy Theory', '(value)', 'Decompose a loop space into simpler or canonical components.', 'professional_function_catalog.md'), + ('homotopyTheoryDecomposePath', 'Homotopy Theory', '(value)', 'Decompose a path into simpler or canonical components.', 'professional_function_catalog.md'), + ('homotopyTheoryDecomposeSimplicialComplex', 'Homotopy Theory', '(value)', 'Decompose a simplicial complex into simpler or canonical components.', 'professional_function_catalog.md'), + ('homotopyTheoryDocumentHomotopy', 'Homotopy Theory', '(value)', 'Return a structured explanation of a homotopy and related assumptions.', 'professional_function_catalog.md'), + ('homotopyTheoryDocumentHomotopyInvariant', 'Homotopy Theory', '(value)', 'Return a structured explanation of a homotopy invariant and related assumptions.', 'professional_function_catalog.md'), + ('homotopyTheoryDocumentLoopSpace', 'Homotopy Theory', '(value)', 'Return a structured explanation of a loop space and related assumptions.', 'professional_function_catalog.md'), + ('homotopyTheoryDocumentPath', 'Homotopy Theory', '(value)', 'Return a structured explanation of a path and related assumptions.', 'professional_function_catalog.md'), + ('homotopyTheoryDocumentSimplicialComplex', 'Homotopy Theory', '(value)', 'Return a structured explanation of a simplicial complex and related assumptions.', 'professional_function_catalog.md'), + ('homotopyTheoryEnumerateHomotopy', 'Homotopy Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a homotopy.', 'professional_function_catalog.md'), + ('homotopyTheoryEnumerateHomotopyInvariant', 'Homotopy Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a homotopy invariant.', 'professional_function_catalog.md'), + ('homotopyTheoryEnumerateLoopSpace', 'Homotopy Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a loop space.', 'professional_function_catalog.md'), + ('homotopyTheoryEnumeratePath', 'Homotopy Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a path.', 'professional_function_catalog.md'), + ('homotopyTheoryEnumerateSimplicialComplex', 'Homotopy Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a simplicial complex.', 'professional_function_catalog.md'), + ('homotopyTheoryEstimateHomotopy', 'Homotopy Theory', '(value, samples=None)', 'Estimate a homotopy property from finite samples or approximations.', 'professional_function_catalog.md'), + ('homotopyTheoryEstimateHomotopyInvariant', 'Homotopy Theory', '(value, samples=None)', 'Estimate a homotopy invariant property from finite samples or approximations.', 'professional_function_catalog.md'), + ('homotopyTheoryEstimateLoopSpace', 'Homotopy Theory', '(value, samples=None)', 'Estimate a loop space property from finite samples or approximations.', 'professional_function_catalog.md'), + ('homotopyTheoryEstimatePath', 'Homotopy Theory', '(value, samples=None)', 'Estimate a path property from finite samples or approximations.', 'professional_function_catalog.md'), + ('homotopyTheoryEstimateSimplicialComplex', 'Homotopy Theory', '(value, samples=None)', 'Estimate a simplicial complex property from finite samples or approximations.', 'professional_function_catalog.md'), + ('homotopyTheoryEvaluateHomotopy', 'Homotopy Theory', '(value, point=None)', 'Evaluate a homotopy at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('homotopyTheoryEvaluateHomotopyInvariant', 'Homotopy Theory', '(value, point=None)', 'Evaluate a homotopy invariant at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('homotopyTheoryEvaluateLoopSpace', 'Homotopy Theory', '(value, point=None)', 'Evaluate a loop space at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('homotopyTheoryEvaluatePath', 'Homotopy Theory', '(value, point=None)', 'Evaluate a path at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('homotopyTheoryEvaluateSimplicialComplex', 'Homotopy Theory', '(value, point=None)', 'Evaluate a simplicial complex at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('homotopyTheoryFormatHomotopy', 'Homotopy Theory', '(value)', 'Format a homotopy for deterministic user-facing output.', 'professional_function_catalog.md'), + ('homotopyTheoryFormatHomotopyInvariant', 'Homotopy Theory', '(value)', 'Format a homotopy invariant for deterministic user-facing output.', 'professional_function_catalog.md'), + ('homotopyTheoryFormatLoopSpace', 'Homotopy Theory', '(value)', 'Format a loop space for deterministic user-facing output.', 'professional_function_catalog.md'), + ('homotopyTheoryFormatPath', 'Homotopy Theory', '(value)', 'Format a path for deterministic user-facing output.', 'professional_function_catalog.md'), + ('homotopyTheoryFormatSimplicialComplex', 'Homotopy Theory', '(value)', 'Format a simplicial complex for deterministic user-facing output.', 'professional_function_catalog.md'), + ('homotopyTheoryGenerateExampleHomotopy', 'Homotopy Theory', '(size=3)', 'Generate a small documented example of a homotopy.', 'professional_function_catalog.md'), + ('homotopyTheoryGenerateExampleHomotopyInvariant', 'Homotopy Theory', '(size=3)', 'Generate a small documented example of a homotopy invariant.', 'professional_function_catalog.md'), + ('homotopyTheoryGenerateExampleLoopSpace', 'Homotopy Theory', '(size=3)', 'Generate a small documented example of a loop space.', 'professional_function_catalog.md'), + ('homotopyTheoryGenerateExamplePath', 'Homotopy Theory', '(size=3)', 'Generate a small documented example of a path.', 'professional_function_catalog.md'), + ('homotopyTheoryGenerateExampleSimplicialComplex', 'Homotopy Theory', '(size=3)', 'Generate a small documented example of a simplicial complex.', 'professional_function_catalog.md'), + ('homotopyTheoryNormalizeHomotopy', 'Homotopy Theory', '(value)', 'Normalize a homotopy into the standard Homotopy Theory representation.', 'professional_function_catalog.md'), + ('homotopyTheoryNormalizeHomotopyInvariant', 'Homotopy Theory', '(value)', 'Normalize a homotopy invariant into the standard Homotopy Theory representation.', 'professional_function_catalog.md'), + ('homotopyTheoryNormalizeLoopSpace', 'Homotopy Theory', '(value)', 'Normalize a loop space into the standard Homotopy Theory representation.', 'professional_function_catalog.md'), + ('homotopyTheoryNormalizePath', 'Homotopy Theory', '(value)', 'Normalize a path into the standard Homotopy Theory representation.', 'professional_function_catalog.md'), + ('homotopyTheoryNormalizeSimplicialComplex', 'Homotopy Theory', '(value)', 'Normalize a simplicial complex into the standard Homotopy Theory representation.', 'professional_function_catalog.md'), + ('homotopyTheoryParseHomotopy', 'Homotopy Theory', '(text)', 'Parse a text or structured value into a homotopy.', 'professional_function_catalog.md'), + ('homotopyTheoryParseHomotopyInvariant', 'Homotopy Theory', '(text)', 'Parse a text or structured value into a homotopy invariant.', 'professional_function_catalog.md'), + ('homotopyTheoryParseLoopSpace', 'Homotopy Theory', '(text)', 'Parse a text or structured value into a loop space.', 'professional_function_catalog.md'), + ('homotopyTheoryParsePath', 'Homotopy Theory', '(text)', 'Parse a text or structured value into a path.', 'professional_function_catalog.md'), + ('homotopyTheoryParseSimplicialComplex', 'Homotopy Theory', '(text)', 'Parse a text or structured value into a simplicial complex.', 'professional_function_catalog.md'), + ('homotopyTheorySimplifyHomotopy', 'Homotopy Theory', '(value)', 'Simplify a homotopy without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('homotopyTheorySimplifyHomotopyInvariant', 'Homotopy Theory', '(value)', 'Simplify a homotopy invariant without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('homotopyTheorySimplifyLoopSpace', 'Homotopy Theory', '(value)', 'Simplify a loop space without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('homotopyTheorySimplifyPath', 'Homotopy Theory', '(value)', 'Simplify a path without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('homotopyTheorySimplifySimplicialComplex', 'Homotopy Theory', '(value)', 'Simplify a simplicial complex without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('homotopyTheoryTestEquivalenceHomotopy', 'Homotopy Theory', '(left, right)', 'Test whether two homotopy values are equivalent in Homotopy Theory.', 'professional_function_catalog.md'), + ('homotopyTheoryTestEquivalenceHomotopyInvariant', 'Homotopy Theory', '(left, right)', 'Test whether two homotopy invariant values are equivalent in Homotopy Theory.', 'professional_function_catalog.md'), + ('homotopyTheoryTestEquivalenceLoopSpace', 'Homotopy Theory', '(left, right)', 'Test whether two loop space values are equivalent in Homotopy Theory.', 'professional_function_catalog.md'), + ('homotopyTheoryTestEquivalencePath', 'Homotopy Theory', '(left, right)', 'Test whether two path values are equivalent in Homotopy Theory.', 'professional_function_catalog.md'), + ('homotopyTheoryTestEquivalenceSimplicialComplex', 'Homotopy Theory', '(left, right)', 'Test whether two simplicial complex values are equivalent in Homotopy Theory.', 'professional_function_catalog.md'), + ('homotopyTheoryTransformHomotopy', 'Homotopy Theory', '(value, mapping)', 'Transform a homotopy through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('homotopyTheoryTransformHomotopyInvariant', 'Homotopy Theory', '(value, mapping)', 'Transform a homotopy invariant through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('homotopyTheoryTransformLoopSpace', 'Homotopy Theory', '(value, mapping)', 'Transform a loop space through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('homotopyTheoryTransformPath', 'Homotopy Theory', '(value, mapping)', 'Transform a path through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('homotopyTheoryTransformSimplicialComplex', 'Homotopy Theory', '(value, mapping)', 'Transform a simplicial complex through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('homotopyTheoryValidateHomotopy', 'Homotopy Theory', '(value)', 'Validate the homotopy representation and domain rules for Homotopy Theory.', 'professional_function_catalog.md'), + ('homotopyTheoryValidateHomotopyInvariant', 'Homotopy Theory', '(value)', 'Validate the homotopy invariant representation and domain rules for Homotopy Theory.', 'professional_function_catalog.md'), + ('homotopyTheoryValidateLoopSpace', 'Homotopy Theory', '(value)', 'Validate the loop space representation and domain rules for Homotopy Theory.', 'professional_function_catalog.md'), + ('homotopyTheoryValidatePath', 'Homotopy Theory', '(value)', 'Validate the path representation and domain rules for Homotopy Theory.', 'professional_function_catalog.md'), + ('homotopyTheoryValidateSimplicialComplex', 'Homotopy Theory', '(value)', 'Validate the simplicial complex representation and domain rules for Homotopy Theory.', 'professional_function_catalog.md'), + ('path', 'Homotopy Theory', '(points)', 'Planned roadmap function for Homotopy Theory from upcoming.md.', 'upcoming.md'), + ('pathHomotopic', 'Homotopy Theory', '(path1, path2, adjacency)', 'Planned roadmap function for Homotopy Theory from upcoming.md.', 'upcoming.md'), + ('reversePath', 'Homotopy Theory', '(path)', 'Planned roadmap function for Homotopy Theory from upcoming.md.', 'upcoming.md'), + ('simplicialComplex', 'Homotopy Theory', '(faces)', 'Planned roadmap function for Homotopy Theory from upcoming.md.', 'upcoming.md'), + ('crossEntropy', 'Information Theory', '(p, q)', 'Planned roadmap function for Information Theory from upcoming.md.', 'upcoming.md'), + ('entropy', 'Information Theory', '(probabilities)', 'Planned roadmap function for Information Theory from upcoming.md.', 'upcoming.md'), + ('giniImpurity', 'Information Theory', '(probabilities)', 'Planned roadmap function for Information Theory from upcoming.md.', 'upcoming.md'), + ('informationContent', 'Information Theory', '(probability)', 'Planned roadmap function for Information Theory from upcoming.md.', 'upcoming.md'), + ('informationTheoryApproximateChannel', 'Information Theory', '(value, tolerance=1e-9)', 'Approximate a channel with explicit tolerance controls.', 'professional_function_catalog.md'), + ('informationTheoryApproximateCodeDistribution', 'Information Theory', '(value, tolerance=1e-9)', 'Approximate a code distribution with explicit tolerance controls.', 'professional_function_catalog.md'), + ('informationTheoryApproximateEntropyMeasure', 'Information Theory', '(value, tolerance=1e-9)', 'Approximate a entropy measure with explicit tolerance controls.', 'professional_function_catalog.md'), + ('informationTheoryApproximateInformationDivergence', 'Information Theory', '(value, tolerance=1e-9)', 'Approximate a information divergence with explicit tolerance controls.', 'professional_function_catalog.md'), + ('informationTheoryApproximateProbabilityVector', 'Information Theory', '(value, tolerance=1e-9)', 'Approximate a probability vector with explicit tolerance controls.', 'professional_function_catalog.md'), + ('informationTheoryCanonicalizeChannel', 'Information Theory', '(value)', 'Canonicalize a channel so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('informationTheoryCanonicalizeCodeDistribution', 'Information Theory', '(value)', 'Canonicalize a code distribution so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('informationTheoryCanonicalizeEntropyMeasure', 'Information Theory', '(value)', 'Canonicalize a entropy measure so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('informationTheoryCanonicalizeInformationDivergence', 'Information Theory', '(value)', 'Canonicalize a information divergence so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('informationTheoryCanonicalizeProbabilityVector', 'Information Theory', '(value)', 'Canonicalize a probability vector so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('informationTheoryClassifyChannel', 'Information Theory', '(value)', 'Classify a channel by its standard Information Theory invariants.', 'professional_function_catalog.md'), + ('informationTheoryClassifyCodeDistribution', 'Information Theory', '(value)', 'Classify a code distribution by its standard Information Theory invariants.', 'professional_function_catalog.md'), + ('informationTheoryClassifyEntropyMeasure', 'Information Theory', '(value)', 'Classify a entropy measure by its standard Information Theory invariants.', 'professional_function_catalog.md'), + ('informationTheoryClassifyInformationDivergence', 'Information Theory', '(value)', 'Classify a information divergence by its standard Information Theory invariants.', 'professional_function_catalog.md'), + ('informationTheoryClassifyProbabilityVector', 'Information Theory', '(value)', 'Classify a probability vector by its standard Information Theory invariants.', 'professional_function_catalog.md'), + ('informationTheoryCombineChannel', 'Information Theory', '(left, right)', 'Combine two channel values with the natural operation for Information Theory.', 'professional_function_catalog.md'), + ('informationTheoryCombineCodeDistribution', 'Information Theory', '(left, right)', 'Combine two code distribution values with the natural operation for Information Theory.', 'professional_function_catalog.md'), + ('informationTheoryCombineEntropyMeasure', 'Information Theory', '(left, right)', 'Combine two entropy measure values with the natural operation for Information Theory.', 'professional_function_catalog.md'), + ('informationTheoryCombineInformationDivergence', 'Information Theory', '(left, right)', 'Combine two information divergence values with the natural operation for Information Theory.', 'professional_function_catalog.md'), + ('informationTheoryCombineProbabilityVector', 'Information Theory', '(left, right)', 'Combine two probability vector values with the natural operation for Information Theory.', 'professional_function_catalog.md'), + ('informationTheoryCompareChannel', 'Information Theory', '(left, right)', 'Compare two channel values under the conventions of Information Theory.', 'professional_function_catalog.md'), + ('informationTheoryCompareCodeDistribution', 'Information Theory', '(left, right)', 'Compare two code distribution values under the conventions of Information Theory.', 'professional_function_catalog.md'), + ('informationTheoryCompareEntropyMeasure', 'Information Theory', '(left, right)', 'Compare two entropy measure values under the conventions of Information Theory.', 'professional_function_catalog.md'), + ('informationTheoryCompareInformationDivergence', 'Information Theory', '(left, right)', 'Compare two information divergence values under the conventions of Information Theory.', 'professional_function_catalog.md'), + ('informationTheoryCompareProbabilityVector', 'Information Theory', '(left, right)', 'Compare two probability vector values under the conventions of Information Theory.', 'professional_function_catalog.md'), + ('informationTheoryComputeChannel', 'Information Theory', '(value)', 'Compute the central numerical or symbolic data of a channel.', 'professional_function_catalog.md'), + ('informationTheoryComputeCodeDistribution', 'Information Theory', '(value)', 'Compute the central numerical or symbolic data of a code distribution.', 'professional_function_catalog.md'), + ('informationTheoryComputeEntropyMeasure', 'Information Theory', '(value)', 'Compute the central numerical or symbolic data of a entropy measure.', 'professional_function_catalog.md'), + ('informationTheoryComputeInformationDivergence', 'Information Theory', '(value)', 'Compute the central numerical or symbolic data of a information divergence.', 'professional_function_catalog.md'), + ('informationTheoryComputeProbabilityVector', 'Information Theory', '(value)', 'Compute the central numerical or symbolic data of a probability vector.', 'professional_function_catalog.md'), + ('informationTheoryConstructChannel', 'Information Theory', '(*args)', 'Construct a channel from explicit inputs for Information Theory.', 'professional_function_catalog.md'), + ('informationTheoryConstructCodeDistribution', 'Information Theory', '(*args)', 'Construct a code distribution from explicit inputs for Information Theory.', 'professional_function_catalog.md'), + ('informationTheoryConstructEntropyMeasure', 'Information Theory', '(*args)', 'Construct a entropy measure from explicit inputs for Information Theory.', 'professional_function_catalog.md'), + ('informationTheoryConstructInformationDivergence', 'Information Theory', '(*args)', 'Construct a information divergence from explicit inputs for Information Theory.', 'professional_function_catalog.md'), + ('informationTheoryConstructProbabilityVector', 'Information Theory', '(*args)', 'Construct a probability vector from explicit inputs for Information Theory.', 'professional_function_catalog.md'), + ('informationTheoryDecomposeChannel', 'Information Theory', '(value)', 'Decompose a channel into simpler or canonical components.', 'professional_function_catalog.md'), + ('informationTheoryDecomposeCodeDistribution', 'Information Theory', '(value)', 'Decompose a code distribution into simpler or canonical components.', 'professional_function_catalog.md'), + ('informationTheoryDecomposeEntropyMeasure', 'Information Theory', '(value)', 'Decompose a entropy measure into simpler or canonical components.', 'professional_function_catalog.md'), + ('informationTheoryDecomposeInformationDivergence', 'Information Theory', '(value)', 'Decompose a information divergence into simpler or canonical components.', 'professional_function_catalog.md'), + ('informationTheoryDecomposeProbabilityVector', 'Information Theory', '(value)', 'Decompose a probability vector into simpler or canonical components.', 'professional_function_catalog.md'), + ('informationTheoryDocumentChannel', 'Information Theory', '(value)', 'Return a structured explanation of a channel and related assumptions.', 'professional_function_catalog.md'), + ('informationTheoryDocumentCodeDistribution', 'Information Theory', '(value)', 'Return a structured explanation of a code distribution and related assumptions.', 'professional_function_catalog.md'), + ('informationTheoryDocumentEntropyMeasure', 'Information Theory', '(value)', 'Return a structured explanation of a entropy measure and related assumptions.', 'professional_function_catalog.md'), + ('informationTheoryDocumentInformationDivergence', 'Information Theory', '(value)', 'Return a structured explanation of a information divergence and related assumptions.', 'professional_function_catalog.md'), + ('informationTheoryDocumentProbabilityVector', 'Information Theory', '(value)', 'Return a structured explanation of a probability vector and related assumptions.', 'professional_function_catalog.md'), + ('informationTheoryEnumerateChannel', 'Information Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a channel.', 'professional_function_catalog.md'), + ('informationTheoryEnumerateCodeDistribution', 'Information Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a code distribution.', 'professional_function_catalog.md'), + ('informationTheoryEnumerateEntropyMeasure', 'Information Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a entropy measure.', 'professional_function_catalog.md'), + ('informationTheoryEnumerateInformationDivergence', 'Information Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a information divergence.', 'professional_function_catalog.md'), + ('informationTheoryEnumerateProbabilityVector', 'Information Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a probability vector.', 'professional_function_catalog.md'), + ('informationTheoryEstimateChannel', 'Information Theory', '(value, samples=None)', 'Estimate a channel property from finite samples or approximations.', 'professional_function_catalog.md'), + ('informationTheoryEstimateCodeDistribution', 'Information Theory', '(value, samples=None)', 'Estimate a code distribution property from finite samples or approximations.', 'professional_function_catalog.md'), + ('informationTheoryEstimateEntropyMeasure', 'Information Theory', '(value, samples=None)', 'Estimate a entropy measure property from finite samples or approximations.', 'professional_function_catalog.md'), + ('informationTheoryEstimateInformationDivergence', 'Information Theory', '(value, samples=None)', 'Estimate a information divergence property from finite samples or approximations.', 'professional_function_catalog.md'), + ('informationTheoryEstimateProbabilityVector', 'Information Theory', '(value, samples=None)', 'Estimate a probability vector property from finite samples or approximations.', 'professional_function_catalog.md'), + ('informationTheoryEvaluateChannel', 'Information Theory', '(value, point=None)', 'Evaluate a channel at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('informationTheoryEvaluateCodeDistribution', 'Information Theory', '(value, point=None)', 'Evaluate a code distribution at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('informationTheoryEvaluateEntropyMeasure', 'Information Theory', '(value, point=None)', 'Evaluate a entropy measure at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('informationTheoryEvaluateInformationDivergence', 'Information Theory', '(value, point=None)', 'Evaluate a information divergence at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('informationTheoryEvaluateProbabilityVector', 'Information Theory', '(value, point=None)', 'Evaluate a probability vector at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('informationTheoryFormatChannel', 'Information Theory', '(value)', 'Format a channel for deterministic user-facing output.', 'professional_function_catalog.md'), + ('informationTheoryFormatCodeDistribution', 'Information Theory', '(value)', 'Format a code distribution for deterministic user-facing output.', 'professional_function_catalog.md'), + ('informationTheoryFormatEntropyMeasure', 'Information Theory', '(value)', 'Format a entropy measure for deterministic user-facing output.', 'professional_function_catalog.md'), + ('informationTheoryFormatInformationDivergence', 'Information Theory', '(value)', 'Format a information divergence for deterministic user-facing output.', 'professional_function_catalog.md'), + ('informationTheoryFormatProbabilityVector', 'Information Theory', '(value)', 'Format a probability vector for deterministic user-facing output.', 'professional_function_catalog.md'), + ('informationTheoryGenerateExampleChannel', 'Information Theory', '(size=3)', 'Generate a small documented example of a channel.', 'professional_function_catalog.md'), + ('informationTheoryGenerateExampleCodeDistribution', 'Information Theory', '(size=3)', 'Generate a small documented example of a code distribution.', 'professional_function_catalog.md'), + ('informationTheoryGenerateExampleEntropyMeasure', 'Information Theory', '(size=3)', 'Generate a small documented example of a entropy measure.', 'professional_function_catalog.md'), + ('informationTheoryGenerateExampleInformationDivergence', 'Information Theory', '(size=3)', 'Generate a small documented example of a information divergence.', 'professional_function_catalog.md'), + ('informationTheoryGenerateExampleProbabilityVector', 'Information Theory', '(size=3)', 'Generate a small documented example of a probability vector.', 'professional_function_catalog.md'), + ('informationTheoryNormalizeChannel', 'Information Theory', '(value)', 'Normalize a channel into the standard Information Theory representation.', 'professional_function_catalog.md'), + ('informationTheoryNormalizeCodeDistribution', 'Information Theory', '(value)', 'Normalize a code distribution into the standard Information Theory representation.', 'professional_function_catalog.md'), + ('informationTheoryNormalizeEntropyMeasure', 'Information Theory', '(value)', 'Normalize a entropy measure into the standard Information Theory representation.', 'professional_function_catalog.md'), + ('informationTheoryNormalizeInformationDivergence', 'Information Theory', '(value)', 'Normalize a information divergence into the standard Information Theory representation.', 'professional_function_catalog.md'), + ('informationTheoryNormalizeProbabilityVector', 'Information Theory', '(value)', 'Normalize a probability vector into the standard Information Theory representation.', 'professional_function_catalog.md'), + ('informationTheoryParseChannel', 'Information Theory', '(text)', 'Parse a text or structured value into a channel.', 'professional_function_catalog.md'), + ('informationTheoryParseCodeDistribution', 'Information Theory', '(text)', 'Parse a text or structured value into a code distribution.', 'professional_function_catalog.md'), + ('informationTheoryParseEntropyMeasure', 'Information Theory', '(text)', 'Parse a text or structured value into a entropy measure.', 'professional_function_catalog.md'), + ('informationTheoryParseInformationDivergence', 'Information Theory', '(text)', 'Parse a text or structured value into a information divergence.', 'professional_function_catalog.md'), + ('informationTheoryParseProbabilityVector', 'Information Theory', '(text)', 'Parse a text or structured value into a probability vector.', 'professional_function_catalog.md'), + ('informationTheorySimplifyChannel', 'Information Theory', '(value)', 'Simplify a channel without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('informationTheorySimplifyCodeDistribution', 'Information Theory', '(value)', 'Simplify a code distribution without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('informationTheorySimplifyEntropyMeasure', 'Information Theory', '(value)', 'Simplify a entropy measure without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('informationTheorySimplifyInformationDivergence', 'Information Theory', '(value)', 'Simplify a information divergence without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('informationTheorySimplifyProbabilityVector', 'Information Theory', '(value)', 'Simplify a probability vector without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('informationTheoryTestEquivalenceChannel', 'Information Theory', '(left, right)', 'Test whether two channel values are equivalent in Information Theory.', 'professional_function_catalog.md'), + ('informationTheoryTestEquivalenceCodeDistribution', 'Information Theory', '(left, right)', 'Test whether two code distribution values are equivalent in Information Theory.', 'professional_function_catalog.md'), + ('informationTheoryTestEquivalenceEntropyMeasure', 'Information Theory', '(left, right)', 'Test whether two entropy measure values are equivalent in Information Theory.', 'professional_function_catalog.md'), + ('informationTheoryTestEquivalenceInformationDivergence', 'Information Theory', '(left, right)', 'Test whether two information divergence values are equivalent in Information Theory.', 'professional_function_catalog.md'), + ('informationTheoryTestEquivalenceProbabilityVector', 'Information Theory', '(left, right)', 'Test whether two probability vector values are equivalent in Information Theory.', 'professional_function_catalog.md'), + ('informationTheoryTransformChannel', 'Information Theory', '(value, mapping)', 'Transform a channel through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('informationTheoryTransformCodeDistribution', 'Information Theory', '(value, mapping)', 'Transform a code distribution through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('informationTheoryTransformEntropyMeasure', 'Information Theory', '(value, mapping)', 'Transform a entropy measure through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('informationTheoryTransformInformationDivergence', 'Information Theory', '(value, mapping)', 'Transform a information divergence through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('informationTheoryTransformProbabilityVector', 'Information Theory', '(value, mapping)', 'Transform a probability vector through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('informationTheoryValidateChannel', 'Information Theory', '(value)', 'Validate the channel representation and domain rules for Information Theory.', 'professional_function_catalog.md'), + ('informationTheoryValidateCodeDistribution', 'Information Theory', '(value)', 'Validate the code distribution representation and domain rules for Information Theory.', 'professional_function_catalog.md'), + ('informationTheoryValidateEntropyMeasure', 'Information Theory', '(value)', 'Validate the entropy measure representation and domain rules for Information Theory.', 'professional_function_catalog.md'), + ('informationTheoryValidateInformationDivergence', 'Information Theory', '(value)', 'Validate the information divergence representation and domain rules for Information Theory.', 'professional_function_catalog.md'), + ('informationTheoryValidateProbabilityVector', 'Information Theory', '(value)', 'Validate the probability vector representation and domain rules for Information Theory.', 'professional_function_catalog.md'), + ('klDivergence', 'Information Theory', '(p, q)', 'Planned roadmap function for Information Theory from upcoming.md.', 'upcoming.md'), + ('mutualInformation', 'Information Theory', '(jointDistribution)', 'Planned roadmap function for Information Theory from upcoming.md.', 'upcoming.md'), + ('alexanderPolynomialSimple', 'Knot Theory', '(diagram)', 'Planned roadmap function for Knot Theory from upcoming.md.', 'upcoming.md'), + ('isAlternating', 'Knot Theory', '(diagram)', 'Planned roadmap function for Knot Theory from upcoming.md.', 'upcoming.md'), + ('knotCrossingNumber', 'Knot Theory', '(diagram)', 'Planned roadmap function for Knot Theory from upcoming.md.', 'upcoming.md'), + ('knotTheoryApproximateCrossing', 'Knot Theory', '(value, tolerance=1e-9)', 'Approximate a crossing with explicit tolerance controls.', 'professional_function_catalog.md'), + ('knotTheoryApproximateKnotDiagram', 'Knot Theory', '(value, tolerance=1e-9)', 'Approximate a knot diagram with explicit tolerance controls.', 'professional_function_catalog.md'), + ('knotTheoryApproximateKnotInvariant', 'Knot Theory', '(value, tolerance=1e-9)', 'Approximate a knot invariant with explicit tolerance controls.', 'professional_function_catalog.md'), + ('knotTheoryApproximateLinkDiagram', 'Knot Theory', '(value, tolerance=1e-9)', 'Approximate a link diagram with explicit tolerance controls.', 'professional_function_catalog.md'), + ('knotTheoryApproximateReidemeisterMove', 'Knot Theory', '(value, tolerance=1e-9)', 'Approximate a Reidemeister move with explicit tolerance controls.', 'professional_function_catalog.md'), + ('knotTheoryCanonicalizeCrossing', 'Knot Theory', '(value)', 'Canonicalize a crossing so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('knotTheoryCanonicalizeKnotDiagram', 'Knot Theory', '(value)', 'Canonicalize a knot diagram so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('knotTheoryCanonicalizeKnotInvariant', 'Knot Theory', '(value)', 'Canonicalize a knot invariant so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('knotTheoryCanonicalizeLinkDiagram', 'Knot Theory', '(value)', 'Canonicalize a link diagram so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('knotTheoryCanonicalizeReidemeisterMove', 'Knot Theory', '(value)', 'Canonicalize a Reidemeister move so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('knotTheoryClassifyCrossing', 'Knot Theory', '(value)', 'Classify a crossing by its standard Knot Theory invariants.', 'professional_function_catalog.md'), + ('knotTheoryClassifyKnotDiagram', 'Knot Theory', '(value)', 'Classify a knot diagram by its standard Knot Theory invariants.', 'professional_function_catalog.md'), + ('knotTheoryClassifyKnotInvariant', 'Knot Theory', '(value)', 'Classify a knot invariant by its standard Knot Theory invariants.', 'professional_function_catalog.md'), + ('knotTheoryClassifyLinkDiagram', 'Knot Theory', '(value)', 'Classify a link diagram by its standard Knot Theory invariants.', 'professional_function_catalog.md'), + ('knotTheoryClassifyReidemeisterMove', 'Knot Theory', '(value)', 'Classify a Reidemeister move by its standard Knot Theory invariants.', 'professional_function_catalog.md'), + ('knotTheoryCombineCrossing', 'Knot Theory', '(left, right)', 'Combine two crossing values with the natural operation for Knot Theory.', 'professional_function_catalog.md'), + ('knotTheoryCombineKnotDiagram', 'Knot Theory', '(left, right)', 'Combine two knot diagram values with the natural operation for Knot Theory.', 'professional_function_catalog.md'), + ('knotTheoryCombineKnotInvariant', 'Knot Theory', '(left, right)', 'Combine two knot invariant values with the natural operation for Knot Theory.', 'professional_function_catalog.md'), + ('knotTheoryCombineLinkDiagram', 'Knot Theory', '(left, right)', 'Combine two link diagram values with the natural operation for Knot Theory.', 'professional_function_catalog.md'), + ('knotTheoryCombineReidemeisterMove', 'Knot Theory', '(left, right)', 'Combine two Reidemeister move values with the natural operation for Knot Theory.', 'professional_function_catalog.md'), + ('knotTheoryCompareCrossing', 'Knot Theory', '(left, right)', 'Compare two crossing values under the conventions of Knot Theory.', 'professional_function_catalog.md'), + ('knotTheoryCompareKnotDiagram', 'Knot Theory', '(left, right)', 'Compare two knot diagram values under the conventions of Knot Theory.', 'professional_function_catalog.md'), + ('knotTheoryCompareKnotInvariant', 'Knot Theory', '(left, right)', 'Compare two knot invariant values under the conventions of Knot Theory.', 'professional_function_catalog.md'), + ('knotTheoryCompareLinkDiagram', 'Knot Theory', '(left, right)', 'Compare two link diagram values under the conventions of Knot Theory.', 'professional_function_catalog.md'), + ('knotTheoryCompareReidemeisterMove', 'Knot Theory', '(left, right)', 'Compare two Reidemeister move values under the conventions of Knot Theory.', 'professional_function_catalog.md'), + ('knotTheoryComputeCrossing', 'Knot Theory', '(value)', 'Compute the central numerical or symbolic data of a crossing.', 'professional_function_catalog.md'), + ('knotTheoryComputeKnotDiagram', 'Knot Theory', '(value)', 'Compute the central numerical or symbolic data of a knot diagram.', 'professional_function_catalog.md'), + ('knotTheoryComputeKnotInvariant', 'Knot Theory', '(value)', 'Compute the central numerical or symbolic data of a knot invariant.', 'professional_function_catalog.md'), + ('knotTheoryComputeLinkDiagram', 'Knot Theory', '(value)', 'Compute the central numerical or symbolic data of a link diagram.', 'professional_function_catalog.md'), + ('knotTheoryComputeReidemeisterMove', 'Knot Theory', '(value)', 'Compute the central numerical or symbolic data of a Reidemeister move.', 'professional_function_catalog.md'), + ('knotTheoryConstructCrossing', 'Knot Theory', '(*args)', 'Construct a crossing from explicit inputs for Knot Theory.', 'professional_function_catalog.md'), + ('knotTheoryConstructKnotDiagram', 'Knot Theory', '(*args)', 'Construct a knot diagram from explicit inputs for Knot Theory.', 'professional_function_catalog.md'), + ('knotTheoryConstructKnotInvariant', 'Knot Theory', '(*args)', 'Construct a knot invariant from explicit inputs for Knot Theory.', 'professional_function_catalog.md'), + ('knotTheoryConstructLinkDiagram', 'Knot Theory', '(*args)', 'Construct a link diagram from explicit inputs for Knot Theory.', 'professional_function_catalog.md'), + ('knotTheoryConstructReidemeisterMove', 'Knot Theory', '(*args)', 'Construct a Reidemeister move from explicit inputs for Knot Theory.', 'professional_function_catalog.md'), + ('knotTheoryDecomposeCrossing', 'Knot Theory', '(value)', 'Decompose a crossing into simpler or canonical components.', 'professional_function_catalog.md'), + ('knotTheoryDecomposeKnotDiagram', 'Knot Theory', '(value)', 'Decompose a knot diagram into simpler or canonical components.', 'professional_function_catalog.md'), + ('knotTheoryDecomposeKnotInvariant', 'Knot Theory', '(value)', 'Decompose a knot invariant into simpler or canonical components.', 'professional_function_catalog.md'), + ('knotTheoryDecomposeLinkDiagram', 'Knot Theory', '(value)', 'Decompose a link diagram into simpler or canonical components.', 'professional_function_catalog.md'), + ('knotTheoryDecomposeReidemeisterMove', 'Knot Theory', '(value)', 'Decompose a Reidemeister move into simpler or canonical components.', 'professional_function_catalog.md'), + ('knotTheoryDocumentCrossing', 'Knot Theory', '(value)', 'Return a structured explanation of a crossing and related assumptions.', 'professional_function_catalog.md'), + ('knotTheoryDocumentKnotDiagram', 'Knot Theory', '(value)', 'Return a structured explanation of a knot diagram and related assumptions.', 'professional_function_catalog.md'), + ('knotTheoryDocumentKnotInvariant', 'Knot Theory', '(value)', 'Return a structured explanation of a knot invariant and related assumptions.', 'professional_function_catalog.md'), + ('knotTheoryDocumentLinkDiagram', 'Knot Theory', '(value)', 'Return a structured explanation of a link diagram and related assumptions.', 'professional_function_catalog.md'), + ('knotTheoryDocumentReidemeisterMove', 'Knot Theory', '(value)', 'Return a structured explanation of a Reidemeister move and related assumptions.', 'professional_function_catalog.md'), + ('knotTheoryEnumerateCrossing', 'Knot Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a crossing.', 'professional_function_catalog.md'), + ('knotTheoryEnumerateKnotDiagram', 'Knot Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a knot diagram.', 'professional_function_catalog.md'), + ('knotTheoryEnumerateKnotInvariant', 'Knot Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a knot invariant.', 'professional_function_catalog.md'), + ('knotTheoryEnumerateLinkDiagram', 'Knot Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a link diagram.', 'professional_function_catalog.md'), + ('knotTheoryEnumerateReidemeisterMove', 'Knot Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a Reidemeister move.', 'professional_function_catalog.md'), + ('knotTheoryEstimateCrossing', 'Knot Theory', '(value, samples=None)', 'Estimate a crossing property from finite samples or approximations.', 'professional_function_catalog.md'), + ('knotTheoryEstimateKnotDiagram', 'Knot Theory', '(value, samples=None)', 'Estimate a knot diagram property from finite samples or approximations.', 'professional_function_catalog.md'), + ('knotTheoryEstimateKnotInvariant', 'Knot Theory', '(value, samples=None)', 'Estimate a knot invariant property from finite samples or approximations.', 'professional_function_catalog.md'), + ('knotTheoryEstimateLinkDiagram', 'Knot Theory', '(value, samples=None)', 'Estimate a link diagram property from finite samples or approximations.', 'professional_function_catalog.md'), + ('knotTheoryEstimateReidemeisterMove', 'Knot Theory', '(value, samples=None)', 'Estimate a Reidemeister move property from finite samples or approximations.', 'professional_function_catalog.md'), + ('knotTheoryEvaluateCrossing', 'Knot Theory', '(value, point=None)', 'Evaluate a crossing at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('knotTheoryEvaluateKnotDiagram', 'Knot Theory', '(value, point=None)', 'Evaluate a knot diagram at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('knotTheoryEvaluateKnotInvariant', 'Knot Theory', '(value, point=None)', 'Evaluate a knot invariant at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('knotTheoryEvaluateLinkDiagram', 'Knot Theory', '(value, point=None)', 'Evaluate a link diagram at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('knotTheoryEvaluateReidemeisterMove', 'Knot Theory', '(value, point=None)', 'Evaluate a Reidemeister move at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('knotTheoryFormatCrossing', 'Knot Theory', '(value)', 'Format a crossing for deterministic user-facing output.', 'professional_function_catalog.md'), + ('knotTheoryFormatKnotDiagram', 'Knot Theory', '(value)', 'Format a knot diagram for deterministic user-facing output.', 'professional_function_catalog.md'), + ('knotTheoryFormatKnotInvariant', 'Knot Theory', '(value)', 'Format a knot invariant for deterministic user-facing output.', 'professional_function_catalog.md'), + ('knotTheoryFormatLinkDiagram', 'Knot Theory', '(value)', 'Format a link diagram for deterministic user-facing output.', 'professional_function_catalog.md'), + ('knotTheoryFormatReidemeisterMove', 'Knot Theory', '(value)', 'Format a Reidemeister move for deterministic user-facing output.', 'professional_function_catalog.md'), + ('knotTheoryGenerateExampleCrossing', 'Knot Theory', '(size=3)', 'Generate a small documented example of a crossing.', 'professional_function_catalog.md'), + ('knotTheoryGenerateExampleKnotDiagram', 'Knot Theory', '(size=3)', 'Generate a small documented example of a knot diagram.', 'professional_function_catalog.md'), + ('knotTheoryGenerateExampleKnotInvariant', 'Knot Theory', '(size=3)', 'Generate a small documented example of a knot invariant.', 'professional_function_catalog.md'), + ('knotTheoryGenerateExampleLinkDiagram', 'Knot Theory', '(size=3)', 'Generate a small documented example of a link diagram.', 'professional_function_catalog.md'), + ('knotTheoryGenerateExampleReidemeisterMove', 'Knot Theory', '(size=3)', 'Generate a small documented example of a Reidemeister move.', 'professional_function_catalog.md'), + ('knotTheoryNormalizeCrossing', 'Knot Theory', '(value)', 'Normalize a crossing into the standard Knot Theory representation.', 'professional_function_catalog.md'), + ('knotTheoryNormalizeKnotDiagram', 'Knot Theory', '(value)', 'Normalize a knot diagram into the standard Knot Theory representation.', 'professional_function_catalog.md'), + ('knotTheoryNormalizeKnotInvariant', 'Knot Theory', '(value)', 'Normalize a knot invariant into the standard Knot Theory representation.', 'professional_function_catalog.md'), + ('knotTheoryNormalizeLinkDiagram', 'Knot Theory', '(value)', 'Normalize a link diagram into the standard Knot Theory representation.', 'professional_function_catalog.md'), + ('knotTheoryNormalizeReidemeisterMove', 'Knot Theory', '(value)', 'Normalize a Reidemeister move into the standard Knot Theory representation.', 'professional_function_catalog.md'), + ('knotTheoryParseCrossing', 'Knot Theory', '(text)', 'Parse a text or structured value into a crossing.', 'professional_function_catalog.md'), + ('knotTheoryParseKnotDiagram', 'Knot Theory', '(text)', 'Parse a text or structured value into a knot diagram.', 'professional_function_catalog.md'), + ('knotTheoryParseKnotInvariant', 'Knot Theory', '(text)', 'Parse a text or structured value into a knot invariant.', 'professional_function_catalog.md'), + ('knotTheoryParseLinkDiagram', 'Knot Theory', '(text)', 'Parse a text or structured value into a link diagram.', 'professional_function_catalog.md'), + ('knotTheoryParseReidemeisterMove', 'Knot Theory', '(text)', 'Parse a text or structured value into a Reidemeister move.', 'professional_function_catalog.md'), + ('knotTheorySimplifyCrossing', 'Knot Theory', '(value)', 'Simplify a crossing without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('knotTheorySimplifyKnotDiagram', 'Knot Theory', '(value)', 'Simplify a knot diagram without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('knotTheorySimplifyKnotInvariant', 'Knot Theory', '(value)', 'Simplify a knot invariant without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('knotTheorySimplifyLinkDiagram', 'Knot Theory', '(value)', 'Simplify a link diagram without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('knotTheorySimplifyReidemeisterMove', 'Knot Theory', '(value)', 'Simplify a Reidemeister move without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('knotTheoryTestEquivalenceCrossing', 'Knot Theory', '(left, right)', 'Test whether two crossing values are equivalent in Knot Theory.', 'professional_function_catalog.md'), + ('knotTheoryTestEquivalenceKnotDiagram', 'Knot Theory', '(left, right)', 'Test whether two knot diagram values are equivalent in Knot Theory.', 'professional_function_catalog.md'), + ('knotTheoryTestEquivalenceKnotInvariant', 'Knot Theory', '(left, right)', 'Test whether two knot invariant values are equivalent in Knot Theory.', 'professional_function_catalog.md'), + ('knotTheoryTestEquivalenceLinkDiagram', 'Knot Theory', '(left, right)', 'Test whether two link diagram values are equivalent in Knot Theory.', 'professional_function_catalog.md'), + ('knotTheoryTestEquivalenceReidemeisterMove', 'Knot Theory', '(left, right)', 'Test whether two Reidemeister move values are equivalent in Knot Theory.', 'professional_function_catalog.md'), + ('knotTheoryTransformCrossing', 'Knot Theory', '(value, mapping)', 'Transform a crossing through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('knotTheoryTransformKnotDiagram', 'Knot Theory', '(value, mapping)', 'Transform a knot diagram through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('knotTheoryTransformKnotInvariant', 'Knot Theory', '(value, mapping)', 'Transform a knot invariant through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('knotTheoryTransformLinkDiagram', 'Knot Theory', '(value, mapping)', 'Transform a link diagram through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('knotTheoryTransformReidemeisterMove', 'Knot Theory', '(value, mapping)', 'Transform a Reidemeister move through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('knotTheoryValidateCrossing', 'Knot Theory', '(value)', 'Validate the crossing representation and domain rules for Knot Theory.', 'professional_function_catalog.md'), + ('knotTheoryValidateKnotDiagram', 'Knot Theory', '(value)', 'Validate the knot diagram representation and domain rules for Knot Theory.', 'professional_function_catalog.md'), + ('knotTheoryValidateKnotInvariant', 'Knot Theory', '(value)', 'Validate the knot invariant representation and domain rules for Knot Theory.', 'professional_function_catalog.md'), + ('knotTheoryValidateLinkDiagram', 'Knot Theory', '(value)', 'Validate the link diagram representation and domain rules for Knot Theory.', 'professional_function_catalog.md'), + ('knotTheoryValidateReidemeisterMove', 'Knot Theory', '(value)', 'Validate the Reidemeister move representation and domain rules for Knot Theory.', 'professional_function_catalog.md'), + ('linkingNumber', 'Knot Theory', '(linkDiagram)', 'Planned roadmap function for Knot Theory from upcoming.md.', 'upcoming.md'), + ('mirrorKnot', 'Knot Theory', '(diagram)', 'Planned roadmap function for Knot Theory from upcoming.md.', 'upcoming.md'), + ('reidemeisterMoveOne', 'Knot Theory', '(diagram, index)', 'Planned roadmap function for Knot Theory from upcoming.md.', 'upcoming.md'), + ('reidemeisterMoveThree', 'Knot Theory', '(diagram, index)', 'Planned roadmap function for Knot Theory from upcoming.md.', 'upcoming.md'), + ('reidemeisterMoveTwo', 'Knot Theory', '(diagram, index)', 'Planned roadmap function for Knot Theory from upcoming.md.', 'upcoming.md'), + ('reverseKnot', 'Knot Theory', '(diagram)', 'Planned roadmap function for Knot Theory from upcoming.md.', 'upcoming.md'), + ('writhe', 'Knot Theory', '(diagram)', 'Planned roadmap function for Knot Theory from upcoming.md.', 'upcoming.md'), + ('greatestElement', 'Lattice Theory', '(elements, orderRelation)', 'Planned roadmap function for Lattice Theory from upcoming.md.', 'upcoming.md'), + ('hasseDiagram', 'Lattice Theory', '(elements, orderRelation)', 'Planned roadmap function for Lattice Theory from upcoming.md.', 'upcoming.md'), + ('isCompleteLattice', 'Lattice Theory', '(elements, orderRelation)', 'Planned roadmap function for Lattice Theory from upcoming.md.', 'upcoming.md'), + ('isDistributiveLattice', 'Lattice Theory', '(elements, meetOperation, joinOperation)', 'Planned roadmap function for Lattice Theory from upcoming.md.', 'upcoming.md'), + ('isLattice', 'Lattice Theory', '(elements, orderRelation)', 'Planned roadmap function for Lattice Theory from upcoming.md.', 'upcoming.md'), + ('join', 'Lattice Theory', '(a, b, orderRelation, elements)', 'Planned roadmap function for Lattice Theory from upcoming.md.', 'upcoming.md'), + ('latticeTheoryApproximateCompleteLattice', 'Lattice Theory', '(value, tolerance=1e-9)', 'Approximate a complete lattice with explicit tolerance controls.', 'professional_function_catalog.md'), + ('latticeTheoryApproximateJoinOperation', 'Lattice Theory', '(value, tolerance=1e-9)', 'Approximate a join operation with explicit tolerance controls.', 'professional_function_catalog.md'), + ('latticeTheoryApproximateLattice', 'Lattice Theory', '(value, tolerance=1e-9)', 'Approximate a lattice with explicit tolerance controls.', 'professional_function_catalog.md'), + ('latticeTheoryApproximateMeetOperation', 'Lattice Theory', '(value, tolerance=1e-9)', 'Approximate a meet operation with explicit tolerance controls.', 'professional_function_catalog.md'), + ('latticeTheoryApproximatePoset', 'Lattice Theory', '(value, tolerance=1e-9)', 'Approximate a poset with explicit tolerance controls.', 'professional_function_catalog.md'), + ('latticeTheoryCanonicalizeCompleteLattice', 'Lattice Theory', '(value)', 'Canonicalize a complete lattice so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('latticeTheoryCanonicalizeJoinOperation', 'Lattice Theory', '(value)', 'Canonicalize a join operation so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('latticeTheoryCanonicalizeLattice', 'Lattice Theory', '(value)', 'Canonicalize a lattice so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('latticeTheoryCanonicalizeMeetOperation', 'Lattice Theory', '(value)', 'Canonicalize a meet operation so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('latticeTheoryCanonicalizePoset', 'Lattice Theory', '(value)', 'Canonicalize a poset so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('latticeTheoryClassifyCompleteLattice', 'Lattice Theory', '(value)', 'Classify a complete lattice by its standard Lattice Theory invariants.', 'professional_function_catalog.md'), + ('latticeTheoryClassifyJoinOperation', 'Lattice Theory', '(value)', 'Classify a join operation by its standard Lattice Theory invariants.', 'professional_function_catalog.md'), + ('latticeTheoryClassifyLattice', 'Lattice Theory', '(value)', 'Classify a lattice by its standard Lattice Theory invariants.', 'professional_function_catalog.md'), + ('latticeTheoryClassifyMeetOperation', 'Lattice Theory', '(value)', 'Classify a meet operation by its standard Lattice Theory invariants.', 'professional_function_catalog.md'), + ('latticeTheoryClassifyPoset', 'Lattice Theory', '(value)', 'Classify a poset by its standard Lattice Theory invariants.', 'professional_function_catalog.md'), + ('latticeTheoryCombineCompleteLattice', 'Lattice Theory', '(left, right)', 'Combine two complete lattice values with the natural operation for Lattice Theory.', 'professional_function_catalog.md'), + ('latticeTheoryCombineJoinOperation', 'Lattice Theory', '(left, right)', 'Combine two join operation values with the natural operation for Lattice Theory.', 'professional_function_catalog.md'), + ('latticeTheoryCombineLattice', 'Lattice Theory', '(left, right)', 'Combine two lattice values with the natural operation for Lattice Theory.', 'professional_function_catalog.md'), + ('latticeTheoryCombineMeetOperation', 'Lattice Theory', '(left, right)', 'Combine two meet operation values with the natural operation for Lattice Theory.', 'professional_function_catalog.md'), + ('latticeTheoryCombinePoset', 'Lattice Theory', '(left, right)', 'Combine two poset values with the natural operation for Lattice Theory.', 'professional_function_catalog.md'), + ('latticeTheoryCompareCompleteLattice', 'Lattice Theory', '(left, right)', 'Compare two complete lattice values under the conventions of Lattice Theory.', 'professional_function_catalog.md'), + ('latticeTheoryCompareJoinOperation', 'Lattice Theory', '(left, right)', 'Compare two join operation values under the conventions of Lattice Theory.', 'professional_function_catalog.md'), + ('latticeTheoryCompareLattice', 'Lattice Theory', '(left, right)', 'Compare two lattice values under the conventions of Lattice Theory.', 'professional_function_catalog.md'), + ('latticeTheoryCompareMeetOperation', 'Lattice Theory', '(left, right)', 'Compare two meet operation values under the conventions of Lattice Theory.', 'professional_function_catalog.md'), + ('latticeTheoryComparePoset', 'Lattice Theory', '(left, right)', 'Compare two poset values under the conventions of Lattice Theory.', 'professional_function_catalog.md'), + ('latticeTheoryComputeCompleteLattice', 'Lattice Theory', '(value)', 'Compute the central numerical or symbolic data of a complete lattice.', 'professional_function_catalog.md'), + ('latticeTheoryComputeJoinOperation', 'Lattice Theory', '(value)', 'Compute the central numerical or symbolic data of a join operation.', 'professional_function_catalog.md'), + ('latticeTheoryComputeLattice', 'Lattice Theory', '(value)', 'Compute the central numerical or symbolic data of a lattice.', 'professional_function_catalog.md'), + ('latticeTheoryComputeMeetOperation', 'Lattice Theory', '(value)', 'Compute the central numerical or symbolic data of a meet operation.', 'professional_function_catalog.md'), + ('latticeTheoryComputePoset', 'Lattice Theory', '(value)', 'Compute the central numerical or symbolic data of a poset.', 'professional_function_catalog.md'), + ('latticeTheoryConstructCompleteLattice', 'Lattice Theory', '(*args)', 'Construct a complete lattice from explicit inputs for Lattice Theory.', 'professional_function_catalog.md'), + ('latticeTheoryConstructJoinOperation', 'Lattice Theory', '(*args)', 'Construct a join operation from explicit inputs for Lattice Theory.', 'professional_function_catalog.md'), + ('latticeTheoryConstructLattice', 'Lattice Theory', '(*args)', 'Construct a lattice from explicit inputs for Lattice Theory.', 'professional_function_catalog.md'), + ('latticeTheoryConstructMeetOperation', 'Lattice Theory', '(*args)', 'Construct a meet operation from explicit inputs for Lattice Theory.', 'professional_function_catalog.md'), + ('latticeTheoryConstructPoset', 'Lattice Theory', '(*args)', 'Construct a poset from explicit inputs for Lattice Theory.', 'professional_function_catalog.md'), + ('latticeTheoryDecomposeCompleteLattice', 'Lattice Theory', '(value)', 'Decompose a complete lattice into simpler or canonical components.', 'professional_function_catalog.md'), + ('latticeTheoryDecomposeJoinOperation', 'Lattice Theory', '(value)', 'Decompose a join operation into simpler or canonical components.', 'professional_function_catalog.md'), + ('latticeTheoryDecomposeLattice', 'Lattice Theory', '(value)', 'Decompose a lattice into simpler or canonical components.', 'professional_function_catalog.md'), + ('latticeTheoryDecomposeMeetOperation', 'Lattice Theory', '(value)', 'Decompose a meet operation into simpler or canonical components.', 'professional_function_catalog.md'), + ('latticeTheoryDecomposePoset', 'Lattice Theory', '(value)', 'Decompose a poset into simpler or canonical components.', 'professional_function_catalog.md'), + ('latticeTheoryDocumentCompleteLattice', 'Lattice Theory', '(value)', 'Return a structured explanation of a complete lattice and related assumptions.', 'professional_function_catalog.md'), + ('latticeTheoryDocumentJoinOperation', 'Lattice Theory', '(value)', 'Return a structured explanation of a join operation and related assumptions.', 'professional_function_catalog.md'), + ('latticeTheoryDocumentLattice', 'Lattice Theory', '(value)', 'Return a structured explanation of a lattice and related assumptions.', 'professional_function_catalog.md'), + ('latticeTheoryDocumentMeetOperation', 'Lattice Theory', '(value)', 'Return a structured explanation of a meet operation and related assumptions.', 'professional_function_catalog.md'), + ('latticeTheoryDocumentPoset', 'Lattice Theory', '(value)', 'Return a structured explanation of a poset and related assumptions.', 'professional_function_catalog.md'), + ('latticeTheoryEnumerateCompleteLattice', 'Lattice Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a complete lattice.', 'professional_function_catalog.md'), + ('latticeTheoryEnumerateJoinOperation', 'Lattice Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a join operation.', 'professional_function_catalog.md'), + ('latticeTheoryEnumerateLattice', 'Lattice Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a lattice.', 'professional_function_catalog.md'), + ('latticeTheoryEnumerateMeetOperation', 'Lattice Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a meet operation.', 'professional_function_catalog.md'), + ('latticeTheoryEnumeratePoset', 'Lattice Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a poset.', 'professional_function_catalog.md'), + ('latticeTheoryEstimateCompleteLattice', 'Lattice Theory', '(value, samples=None)', 'Estimate a complete lattice property from finite samples or approximations.', 'professional_function_catalog.md'), + ('latticeTheoryEstimateJoinOperation', 'Lattice Theory', '(value, samples=None)', 'Estimate a join operation property from finite samples or approximations.', 'professional_function_catalog.md'), + ('latticeTheoryEstimateLattice', 'Lattice Theory', '(value, samples=None)', 'Estimate a lattice property from finite samples or approximations.', 'professional_function_catalog.md'), + ('latticeTheoryEstimateMeetOperation', 'Lattice Theory', '(value, samples=None)', 'Estimate a meet operation property from finite samples or approximations.', 'professional_function_catalog.md'), + ('latticeTheoryEstimatePoset', 'Lattice Theory', '(value, samples=None)', 'Estimate a poset property from finite samples or approximations.', 'professional_function_catalog.md'), + ('latticeTheoryEvaluateCompleteLattice', 'Lattice Theory', '(value, point=None)', 'Evaluate a complete lattice at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('latticeTheoryEvaluateJoinOperation', 'Lattice Theory', '(value, point=None)', 'Evaluate a join operation at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('latticeTheoryEvaluateLattice', 'Lattice Theory', '(value, point=None)', 'Evaluate a lattice at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('latticeTheoryEvaluateMeetOperation', 'Lattice Theory', '(value, point=None)', 'Evaluate a meet operation at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('latticeTheoryEvaluatePoset', 'Lattice Theory', '(value, point=None)', 'Evaluate a poset at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('latticeTheoryFormatCompleteLattice', 'Lattice Theory', '(value)', 'Format a complete lattice for deterministic user-facing output.', 'professional_function_catalog.md'), + ('latticeTheoryFormatJoinOperation', 'Lattice Theory', '(value)', 'Format a join operation for deterministic user-facing output.', 'professional_function_catalog.md'), + ('latticeTheoryFormatLattice', 'Lattice Theory', '(value)', 'Format a lattice for deterministic user-facing output.', 'professional_function_catalog.md'), + ('latticeTheoryFormatMeetOperation', 'Lattice Theory', '(value)', 'Format a meet operation for deterministic user-facing output.', 'professional_function_catalog.md'), + ('latticeTheoryFormatPoset', 'Lattice Theory', '(value)', 'Format a poset for deterministic user-facing output.', 'professional_function_catalog.md'), + ('latticeTheoryGenerateExampleCompleteLattice', 'Lattice Theory', '(size=3)', 'Generate a small documented example of a complete lattice.', 'professional_function_catalog.md'), + ('latticeTheoryGenerateExampleJoinOperation', 'Lattice Theory', '(size=3)', 'Generate a small documented example of a join operation.', 'professional_function_catalog.md'), + ('latticeTheoryGenerateExampleLattice', 'Lattice Theory', '(size=3)', 'Generate a small documented example of a lattice.', 'professional_function_catalog.md'), + ('latticeTheoryGenerateExampleMeetOperation', 'Lattice Theory', '(size=3)', 'Generate a small documented example of a meet operation.', 'professional_function_catalog.md'), + ('latticeTheoryGenerateExamplePoset', 'Lattice Theory', '(size=3)', 'Generate a small documented example of a poset.', 'professional_function_catalog.md'), + ('latticeTheoryNormalizeCompleteLattice', 'Lattice Theory', '(value)', 'Normalize a complete lattice into the standard Lattice Theory representation.', 'professional_function_catalog.md'), + ('latticeTheoryNormalizeJoinOperation', 'Lattice Theory', '(value)', 'Normalize a join operation into the standard Lattice Theory representation.', 'professional_function_catalog.md'), + ('latticeTheoryNormalizeLattice', 'Lattice Theory', '(value)', 'Normalize a lattice into the standard Lattice Theory representation.', 'professional_function_catalog.md'), + ('latticeTheoryNormalizeMeetOperation', 'Lattice Theory', '(value)', 'Normalize a meet operation into the standard Lattice Theory representation.', 'professional_function_catalog.md'), + ('latticeTheoryNormalizePoset', 'Lattice Theory', '(value)', 'Normalize a poset into the standard Lattice Theory representation.', 'professional_function_catalog.md'), + ('latticeTheoryParseCompleteLattice', 'Lattice Theory', '(text)', 'Parse a text or structured value into a complete lattice.', 'professional_function_catalog.md'), + ('latticeTheoryParseJoinOperation', 'Lattice Theory', '(text)', 'Parse a text or structured value into a join operation.', 'professional_function_catalog.md'), + ('latticeTheoryParseLattice', 'Lattice Theory', '(text)', 'Parse a text or structured value into a lattice.', 'professional_function_catalog.md'), + ('latticeTheoryParseMeetOperation', 'Lattice Theory', '(text)', 'Parse a text or structured value into a meet operation.', 'professional_function_catalog.md'), + ('latticeTheoryParsePoset', 'Lattice Theory', '(text)', 'Parse a text or structured value into a poset.', 'professional_function_catalog.md'), + ('latticeTheorySimplifyCompleteLattice', 'Lattice Theory', '(value)', 'Simplify a complete lattice without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('latticeTheorySimplifyJoinOperation', 'Lattice Theory', '(value)', 'Simplify a join operation without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('latticeTheorySimplifyLattice', 'Lattice Theory', '(value)', 'Simplify a lattice without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('latticeTheorySimplifyMeetOperation', 'Lattice Theory', '(value)', 'Simplify a meet operation without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('latticeTheorySimplifyPoset', 'Lattice Theory', '(value)', 'Simplify a poset without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('latticeTheoryTestEquivalenceCompleteLattice', 'Lattice Theory', '(left, right)', 'Test whether two complete lattice values are equivalent in Lattice Theory.', 'professional_function_catalog.md'), + ('latticeTheoryTestEquivalenceJoinOperation', 'Lattice Theory', '(left, right)', 'Test whether two join operation values are equivalent in Lattice Theory.', 'professional_function_catalog.md'), + ('latticeTheoryTestEquivalenceLattice', 'Lattice Theory', '(left, right)', 'Test whether two lattice values are equivalent in Lattice Theory.', 'professional_function_catalog.md'), + ('latticeTheoryTestEquivalenceMeetOperation', 'Lattice Theory', '(left, right)', 'Test whether two meet operation values are equivalent in Lattice Theory.', 'professional_function_catalog.md'), + ('latticeTheoryTestEquivalencePoset', 'Lattice Theory', '(left, right)', 'Test whether two poset values are equivalent in Lattice Theory.', 'professional_function_catalog.md'), + ('latticeTheoryTransformCompleteLattice', 'Lattice Theory', '(value, mapping)', 'Transform a complete lattice through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('latticeTheoryTransformJoinOperation', 'Lattice Theory', '(value, mapping)', 'Transform a join operation through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('latticeTheoryTransformLattice', 'Lattice Theory', '(value, mapping)', 'Transform a lattice through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('latticeTheoryTransformMeetOperation', 'Lattice Theory', '(value, mapping)', 'Transform a meet operation through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('latticeTheoryTransformPoset', 'Lattice Theory', '(value, mapping)', 'Transform a poset through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('latticeTheoryValidateCompleteLattice', 'Lattice Theory', '(value)', 'Validate the complete lattice representation and domain rules for Lattice Theory.', 'professional_function_catalog.md'), + ('latticeTheoryValidateJoinOperation', 'Lattice Theory', '(value)', 'Validate the join operation representation and domain rules for Lattice Theory.', 'professional_function_catalog.md'), + ('latticeTheoryValidateLattice', 'Lattice Theory', '(value)', 'Validate the lattice representation and domain rules for Lattice Theory.', 'professional_function_catalog.md'), + ('latticeTheoryValidateMeetOperation', 'Lattice Theory', '(value)', 'Validate the meet operation representation and domain rules for Lattice Theory.', 'professional_function_catalog.md'), + ('latticeTheoryValidatePoset', 'Lattice Theory', '(value)', 'Validate the poset representation and domain rules for Lattice Theory.', 'professional_function_catalog.md'), + ('leastElement', 'Lattice Theory', '(elements, orderRelation)', 'Planned roadmap function for Lattice Theory from upcoming.md.', 'upcoming.md'), + ('meet', 'Lattice Theory', '(a, b, orderRelation, elements)', 'Planned roadmap function for Lattice Theory from upcoming.md.', 'upcoming.md'), + ('adjointRepresentation', 'Lie Theory', '(element, algebra)', 'Planned roadmap function for Lie Theory from upcoming.md.', 'upcoming.md'), + ('bakerCampbellHausdorff', 'Lie Theory', '(A, B, terms=3)', 'Planned roadmap function for Lie Theory from upcoming.md.', 'upcoming.md'), + ('isLieAlgebra', 'Lie Theory', '(elements, bracket)', 'Planned roadmap function for Lie Theory from upcoming.md.', 'upcoming.md'), + ('isSkewSymmetric', 'Lie Theory', '(matrix)', 'Planned roadmap function for Lie Theory from upcoming.md.', 'upcoming.md'), + ('lieBracket', 'Lie Theory', '(A, B)', 'Planned roadmap function for Lie Theory from upcoming.md.', 'upcoming.md'), + ('lieTheoryApproximateBracket', 'Lie Theory', '(value, tolerance=1e-9)', 'Approximate a bracket with explicit tolerance controls.', 'professional_function_catalog.md'), + ('lieTheoryApproximateExponentialMap', 'Lie Theory', '(value, tolerance=1e-9)', 'Approximate a exponential map with explicit tolerance controls.', 'professional_function_catalog.md'), + ('lieTheoryApproximateLieAlgebra', 'Lie Theory', '(value, tolerance=1e-9)', 'Approximate a Lie algebra with explicit tolerance controls.', 'professional_function_catalog.md'), + ('lieTheoryApproximateLieGroup', 'Lie Theory', '(value, tolerance=1e-9)', 'Approximate a Lie group with explicit tolerance controls.', 'professional_function_catalog.md'), + ('lieTheoryApproximateRepresentation', 'Lie Theory', '(value, tolerance=1e-9)', 'Approximate a representation with explicit tolerance controls.', 'professional_function_catalog.md'), + ('lieTheoryCanonicalizeBracket', 'Lie Theory', '(value)', 'Canonicalize a bracket so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('lieTheoryCanonicalizeExponentialMap', 'Lie Theory', '(value)', 'Canonicalize a exponential map so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('lieTheoryCanonicalizeLieAlgebra', 'Lie Theory', '(value)', 'Canonicalize a Lie algebra so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('lieTheoryCanonicalizeLieGroup', 'Lie Theory', '(value)', 'Canonicalize a Lie group so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('lieTheoryCanonicalizeRepresentation', 'Lie Theory', '(value)', 'Canonicalize a representation so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('lieTheoryClassifyBracket', 'Lie Theory', '(value)', 'Classify a bracket by its standard Lie Theory invariants.', 'professional_function_catalog.md'), + ('lieTheoryClassifyExponentialMap', 'Lie Theory', '(value)', 'Classify a exponential map by its standard Lie Theory invariants.', 'professional_function_catalog.md'), + ('lieTheoryClassifyLieAlgebra', 'Lie Theory', '(value)', 'Classify a Lie algebra by its standard Lie Theory invariants.', 'professional_function_catalog.md'), + ('lieTheoryClassifyLieGroup', 'Lie Theory', '(value)', 'Classify a Lie group by its standard Lie Theory invariants.', 'professional_function_catalog.md'), + ('lieTheoryClassifyRepresentation', 'Lie Theory', '(value)', 'Classify a representation by its standard Lie Theory invariants.', 'professional_function_catalog.md'), + ('lieTheoryCombineBracket', 'Lie Theory', '(left, right)', 'Combine two bracket values with the natural operation for Lie Theory.', 'professional_function_catalog.md'), + ('lieTheoryCombineExponentialMap', 'Lie Theory', '(left, right)', 'Combine two exponential map values with the natural operation for Lie Theory.', 'professional_function_catalog.md'), + ('lieTheoryCombineLieAlgebra', 'Lie Theory', '(left, right)', 'Combine two Lie algebra values with the natural operation for Lie Theory.', 'professional_function_catalog.md'), + ('lieTheoryCombineLieGroup', 'Lie Theory', '(left, right)', 'Combine two Lie group values with the natural operation for Lie Theory.', 'professional_function_catalog.md'), + ('lieTheoryCombineRepresentation', 'Lie Theory', '(left, right)', 'Combine two representation values with the natural operation for Lie Theory.', 'professional_function_catalog.md'), + ('lieTheoryCompareBracket', 'Lie Theory', '(left, right)', 'Compare two bracket values under the conventions of Lie Theory.', 'professional_function_catalog.md'), + ('lieTheoryCompareExponentialMap', 'Lie Theory', '(left, right)', 'Compare two exponential map values under the conventions of Lie Theory.', 'professional_function_catalog.md'), + ('lieTheoryCompareLieAlgebra', 'Lie Theory', '(left, right)', 'Compare two Lie algebra values under the conventions of Lie Theory.', 'professional_function_catalog.md'), + ('lieTheoryCompareLieGroup', 'Lie Theory', '(left, right)', 'Compare two Lie group values under the conventions of Lie Theory.', 'professional_function_catalog.md'), + ('lieTheoryCompareRepresentation', 'Lie Theory', '(left, right)', 'Compare two representation values under the conventions of Lie Theory.', 'professional_function_catalog.md'), + ('lieTheoryComputeBracket', 'Lie Theory', '(value)', 'Compute the central numerical or symbolic data of a bracket.', 'professional_function_catalog.md'), + ('lieTheoryComputeExponentialMap', 'Lie Theory', '(value)', 'Compute the central numerical or symbolic data of a exponential map.', 'professional_function_catalog.md'), + ('lieTheoryComputeLieAlgebra', 'Lie Theory', '(value)', 'Compute the central numerical or symbolic data of a Lie algebra.', 'professional_function_catalog.md'), + ('lieTheoryComputeLieGroup', 'Lie Theory', '(value)', 'Compute the central numerical or symbolic data of a Lie group.', 'professional_function_catalog.md'), + ('lieTheoryComputeRepresentation', 'Lie Theory', '(value)', 'Compute the central numerical or symbolic data of a representation.', 'professional_function_catalog.md'), + ('lieTheoryConstructBracket', 'Lie Theory', '(*args)', 'Construct a bracket from explicit inputs for Lie Theory.', 'professional_function_catalog.md'), + ('lieTheoryConstructExponentialMap', 'Lie Theory', '(*args)', 'Construct a exponential map from explicit inputs for Lie Theory.', 'professional_function_catalog.md'), + ('lieTheoryConstructLieAlgebra', 'Lie Theory', '(*args)', 'Construct a Lie algebra from explicit inputs for Lie Theory.', 'professional_function_catalog.md'), + ('lieTheoryConstructLieGroup', 'Lie Theory', '(*args)', 'Construct a Lie group from explicit inputs for Lie Theory.', 'professional_function_catalog.md'), + ('lieTheoryConstructRepresentation', 'Lie Theory', '(*args)', 'Construct a representation from explicit inputs for Lie Theory.', 'professional_function_catalog.md'), + ('lieTheoryDecomposeBracket', 'Lie Theory', '(value)', 'Decompose a bracket into simpler or canonical components.', 'professional_function_catalog.md'), + ('lieTheoryDecomposeExponentialMap', 'Lie Theory', '(value)', 'Decompose a exponential map into simpler or canonical components.', 'professional_function_catalog.md'), + ('lieTheoryDecomposeLieAlgebra', 'Lie Theory', '(value)', 'Decompose a Lie algebra into simpler or canonical components.', 'professional_function_catalog.md'), + ('lieTheoryDecomposeLieGroup', 'Lie Theory', '(value)', 'Decompose a Lie group into simpler or canonical components.', 'professional_function_catalog.md'), + ('lieTheoryDecomposeRepresentation', 'Lie Theory', '(value)', 'Decompose a representation into simpler or canonical components.', 'professional_function_catalog.md'), + ('lieTheoryDocumentBracket', 'Lie Theory', '(value)', 'Return a structured explanation of a bracket and related assumptions.', 'professional_function_catalog.md'), + ('lieTheoryDocumentExponentialMap', 'Lie Theory', '(value)', 'Return a structured explanation of a exponential map and related assumptions.', 'professional_function_catalog.md'), + ('lieTheoryDocumentLieAlgebra', 'Lie Theory', '(value)', 'Return a structured explanation of a Lie algebra and related assumptions.', 'professional_function_catalog.md'), + ('lieTheoryDocumentLieGroup', 'Lie Theory', '(value)', 'Return a structured explanation of a Lie group and related assumptions.', 'professional_function_catalog.md'), + ('lieTheoryDocumentRepresentation', 'Lie Theory', '(value)', 'Return a structured explanation of a representation and related assumptions.', 'professional_function_catalog.md'), + ('lieTheoryEnumerateBracket', 'Lie Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a bracket.', 'professional_function_catalog.md'), + ('lieTheoryEnumerateExponentialMap', 'Lie Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a exponential map.', 'professional_function_catalog.md'), + ('lieTheoryEnumerateLieAlgebra', 'Lie Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a Lie algebra.', 'professional_function_catalog.md'), + ('lieTheoryEnumerateLieGroup', 'Lie Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a Lie group.', 'professional_function_catalog.md'), + ('lieTheoryEnumerateRepresentation', 'Lie Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a representation.', 'professional_function_catalog.md'), + ('lieTheoryEstimateBracket', 'Lie Theory', '(value, samples=None)', 'Estimate a bracket property from finite samples or approximations.', 'professional_function_catalog.md'), + ('lieTheoryEstimateExponentialMap', 'Lie Theory', '(value, samples=None)', 'Estimate a exponential map property from finite samples or approximations.', 'professional_function_catalog.md'), + ('lieTheoryEstimateLieAlgebra', 'Lie Theory', '(value, samples=None)', 'Estimate a Lie algebra property from finite samples or approximations.', 'professional_function_catalog.md'), + ('lieTheoryEstimateLieGroup', 'Lie Theory', '(value, samples=None)', 'Estimate a Lie group property from finite samples or approximations.', 'professional_function_catalog.md'), + ('lieTheoryEstimateRepresentation', 'Lie Theory', '(value, samples=None)', 'Estimate a representation property from finite samples or approximations.', 'professional_function_catalog.md'), + ('lieTheoryEvaluateBracket', 'Lie Theory', '(value, point=None)', 'Evaluate a bracket at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('lieTheoryEvaluateExponentialMap', 'Lie Theory', '(value, point=None)', 'Evaluate a exponential map at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('lieTheoryEvaluateLieAlgebra', 'Lie Theory', '(value, point=None)', 'Evaluate a Lie algebra at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('lieTheoryEvaluateLieGroup', 'Lie Theory', '(value, point=None)', 'Evaluate a Lie group at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('lieTheoryEvaluateRepresentation', 'Lie Theory', '(value, point=None)', 'Evaluate a representation at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('lieTheoryFormatBracket', 'Lie Theory', '(value)', 'Format a bracket for deterministic user-facing output.', 'professional_function_catalog.md'), + ('lieTheoryFormatExponentialMap', 'Lie Theory', '(value)', 'Format a exponential map for deterministic user-facing output.', 'professional_function_catalog.md'), + ('lieTheoryFormatLieAlgebra', 'Lie Theory', '(value)', 'Format a Lie algebra for deterministic user-facing output.', 'professional_function_catalog.md'), + ('lieTheoryFormatLieGroup', 'Lie Theory', '(value)', 'Format a Lie group for deterministic user-facing output.', 'professional_function_catalog.md'), + ('lieTheoryFormatRepresentation', 'Lie Theory', '(value)', 'Format a representation for deterministic user-facing output.', 'professional_function_catalog.md'), + ('lieTheoryGenerateExampleBracket', 'Lie Theory', '(size=3)', 'Generate a small documented example of a bracket.', 'professional_function_catalog.md'), + ('lieTheoryGenerateExampleExponentialMap', 'Lie Theory', '(size=3)', 'Generate a small documented example of a exponential map.', 'professional_function_catalog.md'), + ('lieTheoryGenerateExampleLieAlgebra', 'Lie Theory', '(size=3)', 'Generate a small documented example of a Lie algebra.', 'professional_function_catalog.md'), + ('lieTheoryGenerateExampleLieGroup', 'Lie Theory', '(size=3)', 'Generate a small documented example of a Lie group.', 'professional_function_catalog.md'), + ('lieTheoryGenerateExampleRepresentation', 'Lie Theory', '(size=3)', 'Generate a small documented example of a representation.', 'professional_function_catalog.md'), + ('lieTheoryNormalizeBracket', 'Lie Theory', '(value)', 'Normalize a bracket into the standard Lie Theory representation.', 'professional_function_catalog.md'), + ('lieTheoryNormalizeExponentialMap', 'Lie Theory', '(value)', 'Normalize a exponential map into the standard Lie Theory representation.', 'professional_function_catalog.md'), + ('lieTheoryNormalizeLieAlgebra', 'Lie Theory', '(value)', 'Normalize a Lie algebra into the standard Lie Theory representation.', 'professional_function_catalog.md'), + ('lieTheoryNormalizeLieGroup', 'Lie Theory', '(value)', 'Normalize a Lie group into the standard Lie Theory representation.', 'professional_function_catalog.md'), + ('lieTheoryNormalizeRepresentation', 'Lie Theory', '(value)', 'Normalize a representation into the standard Lie Theory representation.', 'professional_function_catalog.md'), + ('lieTheoryParseBracket', 'Lie Theory', '(text)', 'Parse a text or structured value into a bracket.', 'professional_function_catalog.md'), + ('lieTheoryParseExponentialMap', 'Lie Theory', '(text)', 'Parse a text or structured value into a exponential map.', 'professional_function_catalog.md'), + ('lieTheoryParseLieAlgebra', 'Lie Theory', '(text)', 'Parse a text or structured value into a Lie algebra.', 'professional_function_catalog.md'), + ('lieTheoryParseLieGroup', 'Lie Theory', '(text)', 'Parse a text or structured value into a Lie group.', 'professional_function_catalog.md'), + ('lieTheoryParseRepresentation', 'Lie Theory', '(text)', 'Parse a text or structured value into a representation.', 'professional_function_catalog.md'), + ('lieTheorySimplifyBracket', 'Lie Theory', '(value)', 'Simplify a bracket without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('lieTheorySimplifyExponentialMap', 'Lie Theory', '(value)', 'Simplify a exponential map without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('lieTheorySimplifyLieAlgebra', 'Lie Theory', '(value)', 'Simplify a Lie algebra without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('lieTheorySimplifyLieGroup', 'Lie Theory', '(value)', 'Simplify a Lie group without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('lieTheorySimplifyRepresentation', 'Lie Theory', '(value)', 'Simplify a representation without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('lieTheoryTestEquivalenceBracket', 'Lie Theory', '(left, right)', 'Test whether two bracket values are equivalent in Lie Theory.', 'professional_function_catalog.md'), + ('lieTheoryTestEquivalenceExponentialMap', 'Lie Theory', '(left, right)', 'Test whether two exponential map values are equivalent in Lie Theory.', 'professional_function_catalog.md'), + ('lieTheoryTestEquivalenceLieAlgebra', 'Lie Theory', '(left, right)', 'Test whether two Lie algebra values are equivalent in Lie Theory.', 'professional_function_catalog.md'), + ('lieTheoryTestEquivalenceLieGroup', 'Lie Theory', '(left, right)', 'Test whether two Lie group values are equivalent in Lie Theory.', 'professional_function_catalog.md'), + ('lieTheoryTestEquivalenceRepresentation', 'Lie Theory', '(left, right)', 'Test whether two representation values are equivalent in Lie Theory.', 'professional_function_catalog.md'), + ('lieTheoryTransformBracket', 'Lie Theory', '(value, mapping)', 'Transform a bracket through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('lieTheoryTransformExponentialMap', 'Lie Theory', '(value, mapping)', 'Transform a exponential map through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('lieTheoryTransformLieAlgebra', 'Lie Theory', '(value, mapping)', 'Transform a Lie algebra through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('lieTheoryTransformLieGroup', 'Lie Theory', '(value, mapping)', 'Transform a Lie group through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('lieTheoryTransformRepresentation', 'Lie Theory', '(value, mapping)', 'Transform a representation through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('lieTheoryValidateBracket', 'Lie Theory', '(value)', 'Validate the bracket representation and domain rules for Lie Theory.', 'professional_function_catalog.md'), + ('lieTheoryValidateExponentialMap', 'Lie Theory', '(value)', 'Validate the exponential map representation and domain rules for Lie Theory.', 'professional_function_catalog.md'), + ('lieTheoryValidateLieAlgebra', 'Lie Theory', '(value)', 'Validate the Lie algebra representation and domain rules for Lie Theory.', 'professional_function_catalog.md'), + ('lieTheoryValidateLieGroup', 'Lie Theory', '(value)', 'Validate the Lie group representation and domain rules for Lie Theory.', 'professional_function_catalog.md'), + ('lieTheoryValidateRepresentation', 'Lie Theory', '(value)', 'Validate the representation representation and domain rules for Lie Theory.', 'professional_function_catalog.md'), + ('matrixCommutator', 'Lie Theory', '(A, B)', 'Planned roadmap function for Lie Theory from upcoming.md.', 'upcoming.md'), + ('matrixExponential', 'Lie Theory', '(matrix, terms=20)', 'Planned roadmap function for Lie Theory from upcoming.md.', 'upcoming.md'), + ('specialOrthogonal2', 'Lie Theory', '(theta)', 'Planned roadmap function for Lie Theory from upcoming.md.', 'upcoming.md'), + ('cofactorMatrix', 'Linear Algebra', '(matrix)', 'Planned roadmap function for Linear Algebra from upcoming.md.', 'upcoming.md'), + ('crossProduct', 'Linear Algebra', '(v, w)', 'Planned roadmap function for Linear Algebra from upcoming.md.', 'upcoming.md'), + ('dotProduct', 'Linear Algebra', '(v, w)', 'Planned roadmap function for Linear Algebra from upcoming.md.', 'upcoming.md'), + ('eigenvalues2x2', 'Linear Algebra', '(matrix)', 'Planned roadmap function for Linear Algebra from upcoming.md.', 'upcoming.md'), + ('identityMatrix', 'Linear Algebra', '(n)', 'Planned roadmap function for Linear Algebra from upcoming.md.', 'upcoming.md'), + ('inverseMatrix', 'Linear Algebra', '(matrix)', 'Planned roadmap function for Linear Algebra from upcoming.md.', 'upcoming.md'), + ('linearAlgebraApproximateDecomposition', 'Linear Algebra', '(value, tolerance=1e-9)', 'Approximate a decomposition with explicit tolerance controls.', 'professional_function_catalog.md'), + ('linearAlgebraApproximateLinearMap', 'Linear Algebra', '(value, tolerance=1e-9)', 'Approximate a linear map with explicit tolerance controls.', 'professional_function_catalog.md'), + ('linearAlgebraApproximateMatrix', 'Linear Algebra', '(value, tolerance=1e-9)', 'Approximate a matrix with explicit tolerance controls.', 'professional_function_catalog.md'), + ('linearAlgebraApproximateSubspace', 'Linear Algebra', '(value, tolerance=1e-9)', 'Approximate a subspace with explicit tolerance controls.', 'professional_function_catalog.md'), + ('linearAlgebraApproximateVector', 'Linear Algebra', '(value, tolerance=1e-9)', 'Approximate a vector with explicit tolerance controls.', 'professional_function_catalog.md'), + ('linearAlgebraCanonicalizeDecomposition', 'Linear Algebra', '(value)', 'Canonicalize a decomposition so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('linearAlgebraCanonicalizeLinearMap', 'Linear Algebra', '(value)', 'Canonicalize a linear map so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('linearAlgebraCanonicalizeMatrix', 'Linear Algebra', '(value)', 'Canonicalize a matrix so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('linearAlgebraCanonicalizeSubspace', 'Linear Algebra', '(value)', 'Canonicalize a subspace so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('linearAlgebraCanonicalizeVector', 'Linear Algebra', '(value)', 'Canonicalize a vector so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('linearAlgebraClassifyDecomposition', 'Linear Algebra', '(value)', 'Classify a decomposition by its standard Linear Algebra invariants.', 'professional_function_catalog.md'), + ('linearAlgebraClassifyLinearMap', 'Linear Algebra', '(value)', 'Classify a linear map by its standard Linear Algebra invariants.', 'professional_function_catalog.md'), + ('linearAlgebraClassifyMatrix', 'Linear Algebra', '(value)', 'Classify a matrix by its standard Linear Algebra invariants.', 'professional_function_catalog.md'), + ('linearAlgebraClassifySubspace', 'Linear Algebra', '(value)', 'Classify a subspace by its standard Linear Algebra invariants.', 'professional_function_catalog.md'), + ('linearAlgebraClassifyVector', 'Linear Algebra', '(value)', 'Classify a vector by its standard Linear Algebra invariants.', 'professional_function_catalog.md'), + ('linearAlgebraCombineDecomposition', 'Linear Algebra', '(left, right)', 'Combine two decomposition values with the natural operation for Linear Algebra.', 'professional_function_catalog.md'), + ('linearAlgebraCombineLinearMap', 'Linear Algebra', '(left, right)', 'Combine two linear map values with the natural operation for Linear Algebra.', 'professional_function_catalog.md'), + ('linearAlgebraCombineMatrix', 'Linear Algebra', '(left, right)', 'Combine two matrix values with the natural operation for Linear Algebra.', 'professional_function_catalog.md'), + ('linearAlgebraCombineSubspace', 'Linear Algebra', '(left, right)', 'Combine two subspace values with the natural operation for Linear Algebra.', 'professional_function_catalog.md'), + ('linearAlgebraCombineVector', 'Linear Algebra', '(left, right)', 'Combine two vector values with the natural operation for Linear Algebra.', 'professional_function_catalog.md'), + ('linearAlgebraCompareDecomposition', 'Linear Algebra', '(left, right)', 'Compare two decomposition values under the conventions of Linear Algebra.', 'professional_function_catalog.md'), + ('linearAlgebraCompareLinearMap', 'Linear Algebra', '(left, right)', 'Compare two linear map values under the conventions of Linear Algebra.', 'professional_function_catalog.md'), + ('linearAlgebraCompareMatrix', 'Linear Algebra', '(left, right)', 'Compare two matrix values under the conventions of Linear Algebra.', 'professional_function_catalog.md'), + ('linearAlgebraCompareSubspace', 'Linear Algebra', '(left, right)', 'Compare two subspace values under the conventions of Linear Algebra.', 'professional_function_catalog.md'), + ('linearAlgebraCompareVector', 'Linear Algebra', '(left, right)', 'Compare two vector values under the conventions of Linear Algebra.', 'professional_function_catalog.md'), + ('linearAlgebraComputeDecomposition', 'Linear Algebra', '(value)', 'Compute the central numerical or symbolic data of a decomposition.', 'professional_function_catalog.md'), + ('linearAlgebraComputeLinearMap', 'Linear Algebra', '(value)', 'Compute the central numerical or symbolic data of a linear map.', 'professional_function_catalog.md'), + ('linearAlgebraComputeMatrix', 'Linear Algebra', '(value)', 'Compute the central numerical or symbolic data of a matrix.', 'professional_function_catalog.md'), + ('linearAlgebraComputeSubspace', 'Linear Algebra', '(value)', 'Compute the central numerical or symbolic data of a subspace.', 'professional_function_catalog.md'), + ('linearAlgebraComputeVector', 'Linear Algebra', '(value)', 'Compute the central numerical or symbolic data of a vector.', 'professional_function_catalog.md'), + ('linearAlgebraConstructDecomposition', 'Linear Algebra', '(*args)', 'Construct a decomposition from explicit inputs for Linear Algebra.', 'professional_function_catalog.md'), + ('linearAlgebraConstructLinearMap', 'Linear Algebra', '(*args)', 'Construct a linear map from explicit inputs for Linear Algebra.', 'professional_function_catalog.md'), + ('linearAlgebraConstructMatrix', 'Linear Algebra', '(*args)', 'Construct a matrix from explicit inputs for Linear Algebra.', 'professional_function_catalog.md'), + ('linearAlgebraConstructSubspace', 'Linear Algebra', '(*args)', 'Construct a subspace from explicit inputs for Linear Algebra.', 'professional_function_catalog.md'), + ('linearAlgebraConstructVector', 'Linear Algebra', '(*args)', 'Construct a vector from explicit inputs for Linear Algebra.', 'professional_function_catalog.md'), + ('linearAlgebraDecomposeDecomposition', 'Linear Algebra', '(value)', 'Decompose a decomposition into simpler or canonical components.', 'professional_function_catalog.md'), + ('linearAlgebraDecomposeLinearMap', 'Linear Algebra', '(value)', 'Decompose a linear map into simpler or canonical components.', 'professional_function_catalog.md'), + ('linearAlgebraDecomposeMatrix', 'Linear Algebra', '(value)', 'Decompose a matrix into simpler or canonical components.', 'professional_function_catalog.md'), + ('linearAlgebraDecomposeSubspace', 'Linear Algebra', '(value)', 'Decompose a subspace into simpler or canonical components.', 'professional_function_catalog.md'), + ('linearAlgebraDecomposeVector', 'Linear Algebra', '(value)', 'Decompose a vector into simpler or canonical components.', 'professional_function_catalog.md'), + ('linearAlgebraDocumentDecomposition', 'Linear Algebra', '(value)', 'Return a structured explanation of a decomposition and related assumptions.', 'professional_function_catalog.md'), + ('linearAlgebraDocumentLinearMap', 'Linear Algebra', '(value)', 'Return a structured explanation of a linear map and related assumptions.', 'professional_function_catalog.md'), + ('linearAlgebraDocumentMatrix', 'Linear Algebra', '(value)', 'Return a structured explanation of a matrix and related assumptions.', 'professional_function_catalog.md'), + ('linearAlgebraDocumentSubspace', 'Linear Algebra', '(value)', 'Return a structured explanation of a subspace and related assumptions.', 'professional_function_catalog.md'), + ('linearAlgebraDocumentVector', 'Linear Algebra', '(value)', 'Return a structured explanation of a vector and related assumptions.', 'professional_function_catalog.md'), + ('linearAlgebraEnumerateDecomposition', 'Linear Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a decomposition.', 'professional_function_catalog.md'), + ('linearAlgebraEnumerateLinearMap', 'Linear Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a linear map.', 'professional_function_catalog.md'), + ('linearAlgebraEnumerateMatrix', 'Linear Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a matrix.', 'professional_function_catalog.md'), + ('linearAlgebraEnumerateSubspace', 'Linear Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a subspace.', 'professional_function_catalog.md'), + ('linearAlgebraEnumerateVector', 'Linear Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a vector.', 'professional_function_catalog.md'), + ('linearAlgebraEstimateDecomposition', 'Linear Algebra', '(value, samples=None)', 'Estimate a decomposition property from finite samples or approximations.', 'professional_function_catalog.md'), + ('linearAlgebraEstimateLinearMap', 'Linear Algebra', '(value, samples=None)', 'Estimate a linear map property from finite samples or approximations.', 'professional_function_catalog.md'), + ('linearAlgebraEstimateMatrix', 'Linear Algebra', '(value, samples=None)', 'Estimate a matrix property from finite samples or approximations.', 'professional_function_catalog.md'), + ('linearAlgebraEstimateSubspace', 'Linear Algebra', '(value, samples=None)', 'Estimate a subspace property from finite samples or approximations.', 'professional_function_catalog.md'), + ('linearAlgebraEstimateVector', 'Linear Algebra', '(value, samples=None)', 'Estimate a vector property from finite samples or approximations.', 'professional_function_catalog.md'), + ('linearAlgebraEvaluateDecomposition', 'Linear Algebra', '(value, point=None)', 'Evaluate a decomposition at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('linearAlgebraEvaluateLinearMap', 'Linear Algebra', '(value, point=None)', 'Evaluate a linear map at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('linearAlgebraEvaluateMatrix', 'Linear Algebra', '(value, point=None)', 'Evaluate a matrix at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('linearAlgebraEvaluateSubspace', 'Linear Algebra', '(value, point=None)', 'Evaluate a subspace at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('linearAlgebraEvaluateVector', 'Linear Algebra', '(value, point=None)', 'Evaluate a vector at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('linearAlgebraFormatDecomposition', 'Linear Algebra', '(value)', 'Format a decomposition for deterministic user-facing output.', 'professional_function_catalog.md'), + ('linearAlgebraFormatLinearMap', 'Linear Algebra', '(value)', 'Format a linear map for deterministic user-facing output.', 'professional_function_catalog.md'), + ('linearAlgebraFormatMatrix', 'Linear Algebra', '(value)', 'Format a matrix for deterministic user-facing output.', 'professional_function_catalog.md'), + ('linearAlgebraFormatSubspace', 'Linear Algebra', '(value)', 'Format a subspace for deterministic user-facing output.', 'professional_function_catalog.md'), + ('linearAlgebraFormatVector', 'Linear Algebra', '(value)', 'Format a vector for deterministic user-facing output.', 'professional_function_catalog.md'), + ('linearAlgebraGenerateExampleDecomposition', 'Linear Algebra', '(size=3)', 'Generate a small documented example of a decomposition.', 'professional_function_catalog.md'), + ('linearAlgebraGenerateExampleLinearMap', 'Linear Algebra', '(size=3)', 'Generate a small documented example of a linear map.', 'professional_function_catalog.md'), + ('linearAlgebraGenerateExampleMatrix', 'Linear Algebra', '(size=3)', 'Generate a small documented example of a matrix.', 'professional_function_catalog.md'), + ('linearAlgebraGenerateExampleSubspace', 'Linear Algebra', '(size=3)', 'Generate a small documented example of a subspace.', 'professional_function_catalog.md'), + ('linearAlgebraGenerateExampleVector', 'Linear Algebra', '(size=3)', 'Generate a small documented example of a vector.', 'professional_function_catalog.md'), + ('linearAlgebraNormalizeDecomposition', 'Linear Algebra', '(value)', 'Normalize a decomposition into the standard Linear Algebra representation.', 'professional_function_catalog.md'), + ('linearAlgebraNormalizeLinearMap', 'Linear Algebra', '(value)', 'Normalize a linear map into the standard Linear Algebra representation.', 'professional_function_catalog.md'), + ('linearAlgebraNormalizeMatrix', 'Linear Algebra', '(value)', 'Normalize a matrix into the standard Linear Algebra representation.', 'professional_function_catalog.md'), + ('linearAlgebraNormalizeSubspace', 'Linear Algebra', '(value)', 'Normalize a subspace into the standard Linear Algebra representation.', 'professional_function_catalog.md'), + ('linearAlgebraNormalizeVector', 'Linear Algebra', '(value)', 'Normalize a vector into the standard Linear Algebra representation.', 'professional_function_catalog.md'), + ('linearAlgebraParseDecomposition', 'Linear Algebra', '(text)', 'Parse a text or structured value into a decomposition.', 'professional_function_catalog.md'), + ('linearAlgebraParseLinearMap', 'Linear Algebra', '(text)', 'Parse a text or structured value into a linear map.', 'professional_function_catalog.md'), + ('linearAlgebraParseMatrix', 'Linear Algebra', '(text)', 'Parse a text or structured value into a matrix.', 'professional_function_catalog.md'), + ('linearAlgebraParseSubspace', 'Linear Algebra', '(text)', 'Parse a text or structured value into a subspace.', 'professional_function_catalog.md'), + ('linearAlgebraParseVector', 'Linear Algebra', '(text)', 'Parse a text or structured value into a vector.', 'professional_function_catalog.md'), + ('linearAlgebraSimplifyDecomposition', 'Linear Algebra', '(value)', 'Simplify a decomposition without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('linearAlgebraSimplifyLinearMap', 'Linear Algebra', '(value)', 'Simplify a linear map without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('linearAlgebraSimplifyMatrix', 'Linear Algebra', '(value)', 'Simplify a matrix without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('linearAlgebraSimplifySubspace', 'Linear Algebra', '(value)', 'Simplify a subspace without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('linearAlgebraSimplifyVector', 'Linear Algebra', '(value)', 'Simplify a vector without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('linearAlgebraTestEquivalenceDecomposition', 'Linear Algebra', '(left, right)', 'Test whether two decomposition values are equivalent in Linear Algebra.', 'professional_function_catalog.md'), + ('linearAlgebraTestEquivalenceLinearMap', 'Linear Algebra', '(left, right)', 'Test whether two linear map values are equivalent in Linear Algebra.', 'professional_function_catalog.md'), + ('linearAlgebraTestEquivalenceMatrix', 'Linear Algebra', '(left, right)', 'Test whether two matrix values are equivalent in Linear Algebra.', 'professional_function_catalog.md'), + ('linearAlgebraTestEquivalenceSubspace', 'Linear Algebra', '(left, right)', 'Test whether two subspace values are equivalent in Linear Algebra.', 'professional_function_catalog.md'), + ('linearAlgebraTestEquivalenceVector', 'Linear Algebra', '(left, right)', 'Test whether two vector values are equivalent in Linear Algebra.', 'professional_function_catalog.md'), + ('linearAlgebraTransformDecomposition', 'Linear Algebra', '(value, mapping)', 'Transform a decomposition through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('linearAlgebraTransformLinearMap', 'Linear Algebra', '(value, mapping)', 'Transform a linear map through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('linearAlgebraTransformMatrix', 'Linear Algebra', '(value, mapping)', 'Transform a matrix through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('linearAlgebraTransformSubspace', 'Linear Algebra', '(value, mapping)', 'Transform a subspace through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('linearAlgebraTransformVector', 'Linear Algebra', '(value, mapping)', 'Transform a vector through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('linearAlgebraValidateDecomposition', 'Linear Algebra', '(value)', 'Validate the decomposition representation and domain rules for Linear Algebra.', 'professional_function_catalog.md'), + ('linearAlgebraValidateLinearMap', 'Linear Algebra', '(value)', 'Validate the linear map representation and domain rules for Linear Algebra.', 'professional_function_catalog.md'), + ('linearAlgebraValidateMatrix', 'Linear Algebra', '(value)', 'Validate the matrix representation and domain rules for Linear Algebra.', 'professional_function_catalog.md'), + ('linearAlgebraValidateSubspace', 'Linear Algebra', '(value)', 'Validate the subspace representation and domain rules for Linear Algebra.', 'professional_function_catalog.md'), + ('linearAlgebraValidateVector', 'Linear Algebra', '(value)', 'Validate the vector representation and domain rules for Linear Algebra.', 'professional_function_catalog.md'), + ('matrixMinor', 'Linear Algebra', '(matrix, row, col)', 'Planned roadmap function for Linear Algebra from upcoming.md.', 'upcoming.md'), + ('rank', 'Linear Algebra', '(matrix)', 'Planned roadmap function for Linear Algebra from upcoming.md.', 'upcoming.md'), + ('reducedRowEchelon', 'Linear Algebra', '(matrix)', 'Planned roadmap function for Linear Algebra from upcoming.md.', 'upcoming.md'), + ('rowEchelon', 'Linear Algebra', '(matrix)', 'Planned roadmap function for Linear Algebra from upcoming.md.', 'upcoming.md'), + ('solveLinearSystem', 'Linear Algebra', '(A, b)', 'Planned roadmap function for Linear Algebra from upcoming.md.', 'upcoming.md'), + ('trace', 'Linear Algebra', '(matrix)', 'Planned roadmap function for Linear Algebra from upcoming.md.', 'upcoming.md'), + ('vectorNorm', 'Linear Algebra', '(v)', 'Planned roadmap function for Linear Algebra from upcoming.md.', 'upcoming.md'), + ('deMorgansLawCheck', 'Mathematical Logic', '(a, b)', 'Planned roadmap function for Mathematical Logic from upcoming.md.', 'upcoming.md'), + ('iff', 'Mathematical Logic', '(a, b)', 'Planned roadmap function for Mathematical Logic from upcoming.md.', 'upcoming.md'), + ('implies', 'Mathematical Logic', '(a, b)', 'Planned roadmap function for Mathematical Logic from upcoming.md.', 'upcoming.md'), + ('isContradiction', 'Mathematical Logic', '(expression, variables)', 'Planned roadmap function for Mathematical Logic from upcoming.md.', 'upcoming.md'), + ('isSatisfiable', 'Mathematical Logic', '(expression, variables)', 'Planned roadmap function for Mathematical Logic from upcoming.md.', 'upcoming.md'), + ('isTautology', 'Mathematical Logic', '(expression, variables)', 'Planned roadmap function for Mathematical Logic from upcoming.md.', 'upcoming.md'), + ('logicalAnd', 'Mathematical Logic', '(a, b)', 'Planned roadmap function for Mathematical Logic from upcoming.md.', 'upcoming.md'), + ('logicalNot', 'Mathematical Logic', '(a)', 'Planned roadmap function for Mathematical Logic from upcoming.md.', 'upcoming.md'), + ('logicalOr', 'Mathematical Logic', '(a, b)', 'Planned roadmap function for Mathematical Logic from upcoming.md.', 'upcoming.md'), + ('mathematicalLogicApproximateFormula', 'Mathematical Logic', '(value, tolerance=1e-9)', 'Approximate a formula with explicit tolerance controls.', 'professional_function_catalog.md'), + ('mathematicalLogicApproximateInferenceRule', 'Mathematical Logic', '(value, tolerance=1e-9)', 'Approximate a inference rule with explicit tolerance controls.', 'professional_function_catalog.md'), + ('mathematicalLogicApproximateLogicalTheory', 'Mathematical Logic', '(value, tolerance=1e-9)', 'Approximate a logical theory with explicit tolerance controls.', 'professional_function_catalog.md'), + ('mathematicalLogicApproximateProposition', 'Mathematical Logic', '(value, tolerance=1e-9)', 'Approximate a proposition with explicit tolerance controls.', 'professional_function_catalog.md'), + ('mathematicalLogicApproximateTruthAssignment', 'Mathematical Logic', '(value, tolerance=1e-9)', 'Approximate a truth assignment with explicit tolerance controls.', 'professional_function_catalog.md'), + ('mathematicalLogicCanonicalizeFormula', 'Mathematical Logic', '(value)', 'Canonicalize a formula so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('mathematicalLogicCanonicalizeInferenceRule', 'Mathematical Logic', '(value)', 'Canonicalize a inference rule so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('mathematicalLogicCanonicalizeLogicalTheory', 'Mathematical Logic', '(value)', 'Canonicalize a logical theory so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('mathematicalLogicCanonicalizeProposition', 'Mathematical Logic', '(value)', 'Canonicalize a proposition so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('mathematicalLogicCanonicalizeTruthAssignment', 'Mathematical Logic', '(value)', 'Canonicalize a truth assignment so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('mathematicalLogicClassifyFormula', 'Mathematical Logic', '(value)', 'Classify a formula by its standard Mathematical Logic invariants.', 'professional_function_catalog.md'), + ('mathematicalLogicClassifyInferenceRule', 'Mathematical Logic', '(value)', 'Classify a inference rule by its standard Mathematical Logic invariants.', 'professional_function_catalog.md'), + ('mathematicalLogicClassifyLogicalTheory', 'Mathematical Logic', '(value)', 'Classify a logical theory by its standard Mathematical Logic invariants.', 'professional_function_catalog.md'), + ('mathematicalLogicClassifyProposition', 'Mathematical Logic', '(value)', 'Classify a proposition by its standard Mathematical Logic invariants.', 'professional_function_catalog.md'), + ('mathematicalLogicClassifyTruthAssignment', 'Mathematical Logic', '(value)', 'Classify a truth assignment by its standard Mathematical Logic invariants.', 'professional_function_catalog.md'), + ('mathematicalLogicCombineFormula', 'Mathematical Logic', '(left, right)', 'Combine two formula values with the natural operation for Mathematical Logic.', 'professional_function_catalog.md'), + ('mathematicalLogicCombineInferenceRule', 'Mathematical Logic', '(left, right)', 'Combine two inference rule values with the natural operation for Mathematical Logic.', 'professional_function_catalog.md'), + ('mathematicalLogicCombineLogicalTheory', 'Mathematical Logic', '(left, right)', 'Combine two logical theory values with the natural operation for Mathematical Logic.', 'professional_function_catalog.md'), + ('mathematicalLogicCombineProposition', 'Mathematical Logic', '(left, right)', 'Combine two proposition values with the natural operation for Mathematical Logic.', 'professional_function_catalog.md'), + ('mathematicalLogicCombineTruthAssignment', 'Mathematical Logic', '(left, right)', 'Combine two truth assignment values with the natural operation for Mathematical Logic.', 'professional_function_catalog.md'), + ('mathematicalLogicCompareFormula', 'Mathematical Logic', '(left, right)', 'Compare two formula values under the conventions of Mathematical Logic.', 'professional_function_catalog.md'), + ('mathematicalLogicCompareInferenceRule', 'Mathematical Logic', '(left, right)', 'Compare two inference rule values under the conventions of Mathematical Logic.', 'professional_function_catalog.md'), + ('mathematicalLogicCompareLogicalTheory', 'Mathematical Logic', '(left, right)', 'Compare two logical theory values under the conventions of Mathematical Logic.', 'professional_function_catalog.md'), + ('mathematicalLogicCompareProposition', 'Mathematical Logic', '(left, right)', 'Compare two proposition values under the conventions of Mathematical Logic.', 'professional_function_catalog.md'), + ('mathematicalLogicCompareTruthAssignment', 'Mathematical Logic', '(left, right)', 'Compare two truth assignment values under the conventions of Mathematical Logic.', 'professional_function_catalog.md'), + ('mathematicalLogicComputeFormula', 'Mathematical Logic', '(value)', 'Compute the central numerical or symbolic data of a formula.', 'professional_function_catalog.md'), + ('mathematicalLogicComputeInferenceRule', 'Mathematical Logic', '(value)', 'Compute the central numerical or symbolic data of a inference rule.', 'professional_function_catalog.md'), + ('mathematicalLogicComputeLogicalTheory', 'Mathematical Logic', '(value)', 'Compute the central numerical or symbolic data of a logical theory.', 'professional_function_catalog.md'), + ('mathematicalLogicComputeProposition', 'Mathematical Logic', '(value)', 'Compute the central numerical or symbolic data of a proposition.', 'professional_function_catalog.md'), + ('mathematicalLogicComputeTruthAssignment', 'Mathematical Logic', '(value)', 'Compute the central numerical or symbolic data of a truth assignment.', 'professional_function_catalog.md'), + ('mathematicalLogicConstructFormula', 'Mathematical Logic', '(*args)', 'Construct a formula from explicit inputs for Mathematical Logic.', 'professional_function_catalog.md'), + ('mathematicalLogicConstructInferenceRule', 'Mathematical Logic', '(*args)', 'Construct a inference rule from explicit inputs for Mathematical Logic.', 'professional_function_catalog.md'), + ('mathematicalLogicConstructLogicalTheory', 'Mathematical Logic', '(*args)', 'Construct a logical theory from explicit inputs for Mathematical Logic.', 'professional_function_catalog.md'), + ('mathematicalLogicConstructProposition', 'Mathematical Logic', '(*args)', 'Construct a proposition from explicit inputs for Mathematical Logic.', 'professional_function_catalog.md'), + ('mathematicalLogicConstructTruthAssignment', 'Mathematical Logic', '(*args)', 'Construct a truth assignment from explicit inputs for Mathematical Logic.', 'professional_function_catalog.md'), + ('mathematicalLogicDecomposeFormula', 'Mathematical Logic', '(value)', 'Decompose a formula into simpler or canonical components.', 'professional_function_catalog.md'), + ('mathematicalLogicDecomposeInferenceRule', 'Mathematical Logic', '(value)', 'Decompose a inference rule into simpler or canonical components.', 'professional_function_catalog.md'), + ('mathematicalLogicDecomposeLogicalTheory', 'Mathematical Logic', '(value)', 'Decompose a logical theory into simpler or canonical components.', 'professional_function_catalog.md'), + ('mathematicalLogicDecomposeProposition', 'Mathematical Logic', '(value)', 'Decompose a proposition into simpler or canonical components.', 'professional_function_catalog.md'), + ('mathematicalLogicDecomposeTruthAssignment', 'Mathematical Logic', '(value)', 'Decompose a truth assignment into simpler or canonical components.', 'professional_function_catalog.md'), + ('mathematicalLogicDocumentFormula', 'Mathematical Logic', '(value)', 'Return a structured explanation of a formula and related assumptions.', 'professional_function_catalog.md'), + ('mathematicalLogicDocumentInferenceRule', 'Mathematical Logic', '(value)', 'Return a structured explanation of a inference rule and related assumptions.', 'professional_function_catalog.md'), + ('mathematicalLogicDocumentLogicalTheory', 'Mathematical Logic', '(value)', 'Return a structured explanation of a logical theory and related assumptions.', 'professional_function_catalog.md'), + ('mathematicalLogicDocumentProposition', 'Mathematical Logic', '(value)', 'Return a structured explanation of a proposition and related assumptions.', 'professional_function_catalog.md'), + ('mathematicalLogicDocumentTruthAssignment', 'Mathematical Logic', '(value)', 'Return a structured explanation of a truth assignment and related assumptions.', 'professional_function_catalog.md'), + ('mathematicalLogicEnumerateFormula', 'Mathematical Logic', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a formula.', 'professional_function_catalog.md'), + ('mathematicalLogicEnumerateInferenceRule', 'Mathematical Logic', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a inference rule.', 'professional_function_catalog.md'), + ('mathematicalLogicEnumerateLogicalTheory', 'Mathematical Logic', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a logical theory.', 'professional_function_catalog.md'), + ('mathematicalLogicEnumerateProposition', 'Mathematical Logic', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a proposition.', 'professional_function_catalog.md'), + ('mathematicalLogicEnumerateTruthAssignment', 'Mathematical Logic', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a truth assignment.', 'professional_function_catalog.md'), + ('mathematicalLogicEstimateFormula', 'Mathematical Logic', '(value, samples=None)', 'Estimate a formula property from finite samples or approximations.', 'professional_function_catalog.md'), + ('mathematicalLogicEstimateInferenceRule', 'Mathematical Logic', '(value, samples=None)', 'Estimate a inference rule property from finite samples or approximations.', 'professional_function_catalog.md'), + ('mathematicalLogicEstimateLogicalTheory', 'Mathematical Logic', '(value, samples=None)', 'Estimate a logical theory property from finite samples or approximations.', 'professional_function_catalog.md'), + ('mathematicalLogicEstimateProposition', 'Mathematical Logic', '(value, samples=None)', 'Estimate a proposition property from finite samples or approximations.', 'professional_function_catalog.md'), + ('mathematicalLogicEstimateTruthAssignment', 'Mathematical Logic', '(value, samples=None)', 'Estimate a truth assignment property from finite samples or approximations.', 'professional_function_catalog.md'), + ('mathematicalLogicEvaluateFormula', 'Mathematical Logic', '(value, point=None)', 'Evaluate a formula at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('mathematicalLogicEvaluateInferenceRule', 'Mathematical Logic', '(value, point=None)', 'Evaluate a inference rule at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('mathematicalLogicEvaluateLogicalTheory', 'Mathematical Logic', '(value, point=None)', 'Evaluate a logical theory at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('mathematicalLogicEvaluateProposition', 'Mathematical Logic', '(value, point=None)', 'Evaluate a proposition at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('mathematicalLogicEvaluateTruthAssignment', 'Mathematical Logic', '(value, point=None)', 'Evaluate a truth assignment at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('mathematicalLogicFormatFormula', 'Mathematical Logic', '(value)', 'Format a formula for deterministic user-facing output.', 'professional_function_catalog.md'), + ('mathematicalLogicFormatInferenceRule', 'Mathematical Logic', '(value)', 'Format a inference rule for deterministic user-facing output.', 'professional_function_catalog.md'), + ('mathematicalLogicFormatLogicalTheory', 'Mathematical Logic', '(value)', 'Format a logical theory for deterministic user-facing output.', 'professional_function_catalog.md'), + ('mathematicalLogicFormatProposition', 'Mathematical Logic', '(value)', 'Format a proposition for deterministic user-facing output.', 'professional_function_catalog.md'), + ('mathematicalLogicFormatTruthAssignment', 'Mathematical Logic', '(value)', 'Format a truth assignment for deterministic user-facing output.', 'professional_function_catalog.md'), + ('mathematicalLogicGenerateExampleFormula', 'Mathematical Logic', '(size=3)', 'Generate a small documented example of a formula.', 'professional_function_catalog.md'), + ('mathematicalLogicGenerateExampleInferenceRule', 'Mathematical Logic', '(size=3)', 'Generate a small documented example of a inference rule.', 'professional_function_catalog.md'), + ('mathematicalLogicGenerateExampleLogicalTheory', 'Mathematical Logic', '(size=3)', 'Generate a small documented example of a logical theory.', 'professional_function_catalog.md'), + ('mathematicalLogicGenerateExampleProposition', 'Mathematical Logic', '(size=3)', 'Generate a small documented example of a proposition.', 'professional_function_catalog.md'), + ('mathematicalLogicGenerateExampleTruthAssignment', 'Mathematical Logic', '(size=3)', 'Generate a small documented example of a truth assignment.', 'professional_function_catalog.md'), + ('mathematicalLogicNormalizeFormula', 'Mathematical Logic', '(value)', 'Normalize a formula into the standard Mathematical Logic representation.', 'professional_function_catalog.md'), + ('mathematicalLogicNormalizeInferenceRule', 'Mathematical Logic', '(value)', 'Normalize a inference rule into the standard Mathematical Logic representation.', 'professional_function_catalog.md'), + ('mathematicalLogicNormalizeLogicalTheory', 'Mathematical Logic', '(value)', 'Normalize a logical theory into the standard Mathematical Logic representation.', 'professional_function_catalog.md'), + ('mathematicalLogicNormalizeProposition', 'Mathematical Logic', '(value)', 'Normalize a proposition into the standard Mathematical Logic representation.', 'professional_function_catalog.md'), + ('mathematicalLogicNormalizeTruthAssignment', 'Mathematical Logic', '(value)', 'Normalize a truth assignment into the standard Mathematical Logic representation.', 'professional_function_catalog.md'), + ('mathematicalLogicParseFormula', 'Mathematical Logic', '(text)', 'Parse a text or structured value into a formula.', 'professional_function_catalog.md'), + ('mathematicalLogicParseInferenceRule', 'Mathematical Logic', '(text)', 'Parse a text or structured value into a inference rule.', 'professional_function_catalog.md'), + ('mathematicalLogicParseLogicalTheory', 'Mathematical Logic', '(text)', 'Parse a text or structured value into a logical theory.', 'professional_function_catalog.md'), + ('mathematicalLogicParseProposition', 'Mathematical Logic', '(text)', 'Parse a text or structured value into a proposition.', 'professional_function_catalog.md'), + ('mathematicalLogicParseTruthAssignment', 'Mathematical Logic', '(text)', 'Parse a text or structured value into a truth assignment.', 'professional_function_catalog.md'), + ('mathematicalLogicSimplifyFormula', 'Mathematical Logic', '(value)', 'Simplify a formula without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('mathematicalLogicSimplifyInferenceRule', 'Mathematical Logic', '(value)', 'Simplify a inference rule without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('mathematicalLogicSimplifyLogicalTheory', 'Mathematical Logic', '(value)', 'Simplify a logical theory without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('mathematicalLogicSimplifyProposition', 'Mathematical Logic', '(value)', 'Simplify a proposition without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('mathematicalLogicSimplifyTruthAssignment', 'Mathematical Logic', '(value)', 'Simplify a truth assignment without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('mathematicalLogicTestEquivalenceFormula', 'Mathematical Logic', '(left, right)', 'Test whether two formula values are equivalent in Mathematical Logic.', 'professional_function_catalog.md'), + ('mathematicalLogicTestEquivalenceInferenceRule', 'Mathematical Logic', '(left, right)', 'Test whether two inference rule values are equivalent in Mathematical Logic.', 'professional_function_catalog.md'), + ('mathematicalLogicTestEquivalenceLogicalTheory', 'Mathematical Logic', '(left, right)', 'Test whether two logical theory values are equivalent in Mathematical Logic.', 'professional_function_catalog.md'), + ('mathematicalLogicTestEquivalenceProposition', 'Mathematical Logic', '(left, right)', 'Test whether two proposition values are equivalent in Mathematical Logic.', 'professional_function_catalog.md'), + ('mathematicalLogicTestEquivalenceTruthAssignment', 'Mathematical Logic', '(left, right)', 'Test whether two truth assignment values are equivalent in Mathematical Logic.', 'professional_function_catalog.md'), + ('mathematicalLogicTransformFormula', 'Mathematical Logic', '(value, mapping)', 'Transform a formula through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('mathematicalLogicTransformInferenceRule', 'Mathematical Logic', '(value, mapping)', 'Transform a inference rule through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('mathematicalLogicTransformLogicalTheory', 'Mathematical Logic', '(value, mapping)', 'Transform a logical theory through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('mathematicalLogicTransformProposition', 'Mathematical Logic', '(value, mapping)', 'Transform a proposition through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('mathematicalLogicTransformTruthAssignment', 'Mathematical Logic', '(value, mapping)', 'Transform a truth assignment through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('mathematicalLogicValidateFormula', 'Mathematical Logic', '(value)', 'Validate the formula representation and domain rules for Mathematical Logic.', 'professional_function_catalog.md'), + ('mathematicalLogicValidateInferenceRule', 'Mathematical Logic', '(value)', 'Validate the inference rule representation and domain rules for Mathematical Logic.', 'professional_function_catalog.md'), + ('mathematicalLogicValidateLogicalTheory', 'Mathematical Logic', '(value)', 'Validate the logical theory representation and domain rules for Mathematical Logic.', 'professional_function_catalog.md'), + ('mathematicalLogicValidateProposition', 'Mathematical Logic', '(value)', 'Validate the proposition representation and domain rules for Mathematical Logic.', 'professional_function_catalog.md'), + ('mathematicalLogicValidateTruthAssignment', 'Mathematical Logic', '(value)', 'Validate the truth assignment representation and domain rules for Mathematical Logic.', 'professional_function_catalog.md'), + ('modusPonens', 'Mathematical Logic', '(p, impliesPQ)', 'Planned roadmap function for Mathematical Logic from upcoming.md.', 'upcoming.md'), + ('truthTable', 'Mathematical Logic', '(expression, variables)', 'Planned roadmap function for Mathematical Logic from upcoming.md.', 'upcoming.md'), + ('dualMatroidBases', 'Matroid Theory', '(groundSet, bases)', 'Planned roadmap function for Matroid Theory from upcoming.md.', 'upcoming.md'), + ('graphicMatroid', 'Matroid Theory', '(graph)', 'Planned roadmap function for Matroid Theory from upcoming.md.', 'upcoming.md'), + ('greedyMatroidOptimization', 'Matroid Theory', '(groundSet, independentSets, weights)', 'Planned roadmap function for Matroid Theory from upcoming.md.', 'upcoming.md'), + ('isIndependentMatroid', 'Matroid Theory', '(subset, independentSets)', 'Planned roadmap function for Matroid Theory from upcoming.md.', 'upcoming.md'), + ('isMatroid', 'Matroid Theory', '(groundSet, independentSets)', 'Planned roadmap function for Matroid Theory from upcoming.md.', 'upcoming.md'), + ('matroidBases', 'Matroid Theory', '(groundSet, independentSets)', 'Planned roadmap function for Matroid Theory from upcoming.md.', 'upcoming.md'), + ('matroidCircuits', 'Matroid Theory', '(groundSet, independentSets)', 'Planned roadmap function for Matroid Theory from upcoming.md.', 'upcoming.md'), + ('matroidRank', 'Matroid Theory', '(subset, independentSets)', 'Planned roadmap function for Matroid Theory from upcoming.md.', 'upcoming.md'), + ('matroidTheoryApproximateBasis', 'Matroid Theory', '(value, tolerance=1e-9)', 'Approximate a basis with explicit tolerance controls.', 'professional_function_catalog.md'), + ('matroidTheoryApproximateCircuit', 'Matroid Theory', '(value, tolerance=1e-9)', 'Approximate a circuit with explicit tolerance controls.', 'professional_function_catalog.md'), + ('matroidTheoryApproximateGroundSet', 'Matroid Theory', '(value, tolerance=1e-9)', 'Approximate a ground set with explicit tolerance controls.', 'professional_function_catalog.md'), + ('matroidTheoryApproximateIndependentSet', 'Matroid Theory', '(value, tolerance=1e-9)', 'Approximate a independent set with explicit tolerance controls.', 'professional_function_catalog.md'), + ('matroidTheoryApproximateRankFunction', 'Matroid Theory', '(value, tolerance=1e-9)', 'Approximate a rank function with explicit tolerance controls.', 'professional_function_catalog.md'), + ('matroidTheoryCanonicalizeBasis', 'Matroid Theory', '(value)', 'Canonicalize a basis so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('matroidTheoryCanonicalizeCircuit', 'Matroid Theory', '(value)', 'Canonicalize a circuit so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('matroidTheoryCanonicalizeGroundSet', 'Matroid Theory', '(value)', 'Canonicalize a ground set so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('matroidTheoryCanonicalizeIndependentSet', 'Matroid Theory', '(value)', 'Canonicalize a independent set so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('matroidTheoryCanonicalizeRankFunction', 'Matroid Theory', '(value)', 'Canonicalize a rank function so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('matroidTheoryClassifyBasis', 'Matroid Theory', '(value)', 'Classify a basis by its standard Matroid Theory invariants.', 'professional_function_catalog.md'), + ('matroidTheoryClassifyCircuit', 'Matroid Theory', '(value)', 'Classify a circuit by its standard Matroid Theory invariants.', 'professional_function_catalog.md'), + ('matroidTheoryClassifyGroundSet', 'Matroid Theory', '(value)', 'Classify a ground set by its standard Matroid Theory invariants.', 'professional_function_catalog.md'), + ('matroidTheoryClassifyIndependentSet', 'Matroid Theory', '(value)', 'Classify a independent set by its standard Matroid Theory invariants.', 'professional_function_catalog.md'), + ('matroidTheoryClassifyRankFunction', 'Matroid Theory', '(value)', 'Classify a rank function by its standard Matroid Theory invariants.', 'professional_function_catalog.md'), + ('matroidTheoryCombineBasis', 'Matroid Theory', '(left, right)', 'Combine two basis values with the natural operation for Matroid Theory.', 'professional_function_catalog.md'), + ('matroidTheoryCombineCircuit', 'Matroid Theory', '(left, right)', 'Combine two circuit values with the natural operation for Matroid Theory.', 'professional_function_catalog.md'), + ('matroidTheoryCombineGroundSet', 'Matroid Theory', '(left, right)', 'Combine two ground set values with the natural operation for Matroid Theory.', 'professional_function_catalog.md'), + ('matroidTheoryCombineIndependentSet', 'Matroid Theory', '(left, right)', 'Combine two independent set values with the natural operation for Matroid Theory.', 'professional_function_catalog.md'), + ('matroidTheoryCombineRankFunction', 'Matroid Theory', '(left, right)', 'Combine two rank function values with the natural operation for Matroid Theory.', 'professional_function_catalog.md'), + ('matroidTheoryCompareBasis', 'Matroid Theory', '(left, right)', 'Compare two basis values under the conventions of Matroid Theory.', 'professional_function_catalog.md'), + ('matroidTheoryCompareCircuit', 'Matroid Theory', '(left, right)', 'Compare two circuit values under the conventions of Matroid Theory.', 'professional_function_catalog.md'), + ('matroidTheoryCompareGroundSet', 'Matroid Theory', '(left, right)', 'Compare two ground set values under the conventions of Matroid Theory.', 'professional_function_catalog.md'), + ('matroidTheoryCompareIndependentSet', 'Matroid Theory', '(left, right)', 'Compare two independent set values under the conventions of Matroid Theory.', 'professional_function_catalog.md'), + ('matroidTheoryCompareRankFunction', 'Matroid Theory', '(left, right)', 'Compare two rank function values under the conventions of Matroid Theory.', 'professional_function_catalog.md'), + ('matroidTheoryComputeBasis', 'Matroid Theory', '(value)', 'Compute the central numerical or symbolic data of a basis.', 'professional_function_catalog.md'), + ('matroidTheoryComputeCircuit', 'Matroid Theory', '(value)', 'Compute the central numerical or symbolic data of a circuit.', 'professional_function_catalog.md'), + ('matroidTheoryComputeGroundSet', 'Matroid Theory', '(value)', 'Compute the central numerical or symbolic data of a ground set.', 'professional_function_catalog.md'), + ('matroidTheoryComputeIndependentSet', 'Matroid Theory', '(value)', 'Compute the central numerical or symbolic data of a independent set.', 'professional_function_catalog.md'), + ('matroidTheoryComputeRankFunction', 'Matroid Theory', '(value)', 'Compute the central numerical or symbolic data of a rank function.', 'professional_function_catalog.md'), + ('matroidTheoryConstructBasis', 'Matroid Theory', '(*args)', 'Construct a basis from explicit inputs for Matroid Theory.', 'professional_function_catalog.md'), + ('matroidTheoryConstructCircuit', 'Matroid Theory', '(*args)', 'Construct a circuit from explicit inputs for Matroid Theory.', 'professional_function_catalog.md'), + ('matroidTheoryConstructGroundSet', 'Matroid Theory', '(*args)', 'Construct a ground set from explicit inputs for Matroid Theory.', 'professional_function_catalog.md'), + ('matroidTheoryConstructIndependentSet', 'Matroid Theory', '(*args)', 'Construct a independent set from explicit inputs for Matroid Theory.', 'professional_function_catalog.md'), + ('matroidTheoryConstructRankFunction', 'Matroid Theory', '(*args)', 'Construct a rank function from explicit inputs for Matroid Theory.', 'professional_function_catalog.md'), + ('matroidTheoryDecomposeBasis', 'Matroid Theory', '(value)', 'Decompose a basis into simpler or canonical components.', 'professional_function_catalog.md'), + ('matroidTheoryDecomposeCircuit', 'Matroid Theory', '(value)', 'Decompose a circuit into simpler or canonical components.', 'professional_function_catalog.md'), + ('matroidTheoryDecomposeGroundSet', 'Matroid Theory', '(value)', 'Decompose a ground set into simpler or canonical components.', 'professional_function_catalog.md'), + ('matroidTheoryDecomposeIndependentSet', 'Matroid Theory', '(value)', 'Decompose a independent set into simpler or canonical components.', 'professional_function_catalog.md'), + ('matroidTheoryDecomposeRankFunction', 'Matroid Theory', '(value)', 'Decompose a rank function into simpler or canonical components.', 'professional_function_catalog.md'), + ('matroidTheoryDocumentBasis', 'Matroid Theory', '(value)', 'Return a structured explanation of a basis and related assumptions.', 'professional_function_catalog.md'), + ('matroidTheoryDocumentCircuit', 'Matroid Theory', '(value)', 'Return a structured explanation of a circuit and related assumptions.', 'professional_function_catalog.md'), + ('matroidTheoryDocumentGroundSet', 'Matroid Theory', '(value)', 'Return a structured explanation of a ground set and related assumptions.', 'professional_function_catalog.md'), + ('matroidTheoryDocumentIndependentSet', 'Matroid Theory', '(value)', 'Return a structured explanation of a independent set and related assumptions.', 'professional_function_catalog.md'), + ('matroidTheoryDocumentRankFunction', 'Matroid Theory', '(value)', 'Return a structured explanation of a rank function and related assumptions.', 'professional_function_catalog.md'), + ('matroidTheoryEnumerateBasis', 'Matroid Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a basis.', 'professional_function_catalog.md'), + ('matroidTheoryEnumerateCircuit', 'Matroid Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a circuit.', 'professional_function_catalog.md'), + ('matroidTheoryEnumerateGroundSet', 'Matroid Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a ground set.', 'professional_function_catalog.md'), + ('matroidTheoryEnumerateIndependentSet', 'Matroid Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a independent set.', 'professional_function_catalog.md'), + ('matroidTheoryEnumerateRankFunction', 'Matroid Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a rank function.', 'professional_function_catalog.md'), + ('matroidTheoryEstimateBasis', 'Matroid Theory', '(value, samples=None)', 'Estimate a basis property from finite samples or approximations.', 'professional_function_catalog.md'), + ('matroidTheoryEstimateCircuit', 'Matroid Theory', '(value, samples=None)', 'Estimate a circuit property from finite samples or approximations.', 'professional_function_catalog.md'), + ('matroidTheoryEstimateGroundSet', 'Matroid Theory', '(value, samples=None)', 'Estimate a ground set property from finite samples or approximations.', 'professional_function_catalog.md'), + ('matroidTheoryEstimateIndependentSet', 'Matroid Theory', '(value, samples=None)', 'Estimate a independent set property from finite samples or approximations.', 'professional_function_catalog.md'), + ('matroidTheoryEstimateRankFunction', 'Matroid Theory', '(value, samples=None)', 'Estimate a rank function property from finite samples or approximations.', 'professional_function_catalog.md'), + ('matroidTheoryEvaluateBasis', 'Matroid Theory', '(value, point=None)', 'Evaluate a basis at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('matroidTheoryEvaluateCircuit', 'Matroid Theory', '(value, point=None)', 'Evaluate a circuit at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('matroidTheoryEvaluateGroundSet', 'Matroid Theory', '(value, point=None)', 'Evaluate a ground set at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('matroidTheoryEvaluateIndependentSet', 'Matroid Theory', '(value, point=None)', 'Evaluate a independent set at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('matroidTheoryEvaluateRankFunction', 'Matroid Theory', '(value, point=None)', 'Evaluate a rank function at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('matroidTheoryFormatBasis', 'Matroid Theory', '(value)', 'Format a basis for deterministic user-facing output.', 'professional_function_catalog.md'), + ('matroidTheoryFormatCircuit', 'Matroid Theory', '(value)', 'Format a circuit for deterministic user-facing output.', 'professional_function_catalog.md'), + ('matroidTheoryFormatGroundSet', 'Matroid Theory', '(value)', 'Format a ground set for deterministic user-facing output.', 'professional_function_catalog.md'), + ('matroidTheoryFormatIndependentSet', 'Matroid Theory', '(value)', 'Format a independent set for deterministic user-facing output.', 'professional_function_catalog.md'), + ('matroidTheoryFormatRankFunction', 'Matroid Theory', '(value)', 'Format a rank function for deterministic user-facing output.', 'professional_function_catalog.md'), + ('matroidTheoryGenerateExampleBasis', 'Matroid Theory', '(size=3)', 'Generate a small documented example of a basis.', 'professional_function_catalog.md'), + ('matroidTheoryGenerateExampleCircuit', 'Matroid Theory', '(size=3)', 'Generate a small documented example of a circuit.', 'professional_function_catalog.md'), + ('matroidTheoryGenerateExampleGroundSet', 'Matroid Theory', '(size=3)', 'Generate a small documented example of a ground set.', 'professional_function_catalog.md'), + ('matroidTheoryGenerateExampleIndependentSet', 'Matroid Theory', '(size=3)', 'Generate a small documented example of a independent set.', 'professional_function_catalog.md'), + ('matroidTheoryGenerateExampleRankFunction', 'Matroid Theory', '(size=3)', 'Generate a small documented example of a rank function.', 'professional_function_catalog.md'), + ('matroidTheoryNormalizeBasis', 'Matroid Theory', '(value)', 'Normalize a basis into the standard Matroid Theory representation.', 'professional_function_catalog.md'), + ('matroidTheoryNormalizeCircuit', 'Matroid Theory', '(value)', 'Normalize a circuit into the standard Matroid Theory representation.', 'professional_function_catalog.md'), + ('matroidTheoryNormalizeGroundSet', 'Matroid Theory', '(value)', 'Normalize a ground set into the standard Matroid Theory representation.', 'professional_function_catalog.md'), + ('matroidTheoryNormalizeIndependentSet', 'Matroid Theory', '(value)', 'Normalize a independent set into the standard Matroid Theory representation.', 'professional_function_catalog.md'), + ('matroidTheoryNormalizeRankFunction', 'Matroid Theory', '(value)', 'Normalize a rank function into the standard Matroid Theory representation.', 'professional_function_catalog.md'), + ('matroidTheoryParseBasis', 'Matroid Theory', '(text)', 'Parse a text or structured value into a basis.', 'professional_function_catalog.md'), + ('matroidTheoryParseCircuit', 'Matroid Theory', '(text)', 'Parse a text or structured value into a circuit.', 'professional_function_catalog.md'), + ('matroidTheoryParseGroundSet', 'Matroid Theory', '(text)', 'Parse a text or structured value into a ground set.', 'professional_function_catalog.md'), + ('matroidTheoryParseIndependentSet', 'Matroid Theory', '(text)', 'Parse a text or structured value into a independent set.', 'professional_function_catalog.md'), + ('matroidTheoryParseRankFunction', 'Matroid Theory', '(text)', 'Parse a text or structured value into a rank function.', 'professional_function_catalog.md'), + ('matroidTheorySimplifyBasis', 'Matroid Theory', '(value)', 'Simplify a basis without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('matroidTheorySimplifyCircuit', 'Matroid Theory', '(value)', 'Simplify a circuit without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('matroidTheorySimplifyGroundSet', 'Matroid Theory', '(value)', 'Simplify a ground set without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('matroidTheorySimplifyIndependentSet', 'Matroid Theory', '(value)', 'Simplify a independent set without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('matroidTheorySimplifyRankFunction', 'Matroid Theory', '(value)', 'Simplify a rank function without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('matroidTheoryTestEquivalenceBasis', 'Matroid Theory', '(left, right)', 'Test whether two basis values are equivalent in Matroid Theory.', 'professional_function_catalog.md'), + ('matroidTheoryTestEquivalenceCircuit', 'Matroid Theory', '(left, right)', 'Test whether two circuit values are equivalent in Matroid Theory.', 'professional_function_catalog.md'), + ('matroidTheoryTestEquivalenceGroundSet', 'Matroid Theory', '(left, right)', 'Test whether two ground set values are equivalent in Matroid Theory.', 'professional_function_catalog.md'), + ('matroidTheoryTestEquivalenceIndependentSet', 'Matroid Theory', '(left, right)', 'Test whether two independent set values are equivalent in Matroid Theory.', 'professional_function_catalog.md'), + ('matroidTheoryTestEquivalenceRankFunction', 'Matroid Theory', '(left, right)', 'Test whether two rank function values are equivalent in Matroid Theory.', 'professional_function_catalog.md'), + ('matroidTheoryTransformBasis', 'Matroid Theory', '(value, mapping)', 'Transform a basis through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('matroidTheoryTransformCircuit', 'Matroid Theory', '(value, mapping)', 'Transform a circuit through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('matroidTheoryTransformGroundSet', 'Matroid Theory', '(value, mapping)', 'Transform a ground set through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('matroidTheoryTransformIndependentSet', 'Matroid Theory', '(value, mapping)', 'Transform a independent set through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('matroidTheoryTransformRankFunction', 'Matroid Theory', '(value, mapping)', 'Transform a rank function through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('matroidTheoryValidateBasis', 'Matroid Theory', '(value)', 'Validate the basis representation and domain rules for Matroid Theory.', 'professional_function_catalog.md'), + ('matroidTheoryValidateCircuit', 'Matroid Theory', '(value)', 'Validate the circuit representation and domain rules for Matroid Theory.', 'professional_function_catalog.md'), + ('matroidTheoryValidateGroundSet', 'Matroid Theory', '(value)', 'Validate the ground set representation and domain rules for Matroid Theory.', 'professional_function_catalog.md'), + ('matroidTheoryValidateIndependentSet', 'Matroid Theory', '(value)', 'Validate the independent set representation and domain rules for Matroid Theory.', 'professional_function_catalog.md'), + ('matroidTheoryValidateRankFunction', 'Matroid Theory', '(value)', 'Validate the rank function representation and domain rules for Matroid Theory.', 'professional_function_catalog.md'), + ('generatedSigmaAlgebra', 'Measure Theory', '(subsets, universalSet)', 'Planned roadmap function for Measure Theory from upcoming.md.', 'upcoming.md'), + ('isMeasurableFunction', 'Measure Theory', '(f, domainSigma, codomainSigma)', 'Planned roadmap function for Measure Theory from upcoming.md.', 'upcoming.md'), + ('isMeasure', 'Measure Theory', '(measure, sigmaAlgebra)', 'Planned roadmap function for Measure Theory from upcoming.md.', 'upcoming.md'), + ('isSigmaAlgebra', 'Measure Theory', '(collection, universalSet)', 'Planned roadmap function for Measure Theory from upcoming.md.', 'upcoming.md'), + ('measureOfSet', 'Measure Theory', '(measure, subset)', 'Planned roadmap function for Measure Theory from upcoming.md.', 'upcoming.md'), + ('measureTheoryApproximateMeasurableFunction', 'Measure Theory', '(value, tolerance=1e-9)', 'Approximate a measurable function with explicit tolerance controls.', 'professional_function_catalog.md'), + ('measureTheoryApproximateMeasure', 'Measure Theory', '(value, tolerance=1e-9)', 'Approximate a measure with explicit tolerance controls.', 'professional_function_catalog.md'), + ('measureTheoryApproximateNullSet', 'Measure Theory', '(value, tolerance=1e-9)', 'Approximate a null set with explicit tolerance controls.', 'professional_function_catalog.md'), + ('measureTheoryApproximateSigmaAlgebra', 'Measure Theory', '(value, tolerance=1e-9)', 'Approximate a sigma algebra with explicit tolerance controls.', 'professional_function_catalog.md'), + ('measureTheoryApproximateSimpleFunction', 'Measure Theory', '(value, tolerance=1e-9)', 'Approximate a simple function with explicit tolerance controls.', 'professional_function_catalog.md'), + ('measureTheoryCanonicalizeMeasurableFunction', 'Measure Theory', '(value)', 'Canonicalize a measurable function so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('measureTheoryCanonicalizeMeasure', 'Measure Theory', '(value)', 'Canonicalize a measure so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('measureTheoryCanonicalizeNullSet', 'Measure Theory', '(value)', 'Canonicalize a null set so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('measureTheoryCanonicalizeSigmaAlgebra', 'Measure Theory', '(value)', 'Canonicalize a sigma algebra so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('measureTheoryCanonicalizeSimpleFunction', 'Measure Theory', '(value)', 'Canonicalize a simple function so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('measureTheoryClassifyMeasurableFunction', 'Measure Theory', '(value)', 'Classify a measurable function by its standard Measure Theory invariants.', 'professional_function_catalog.md'), + ('measureTheoryClassifyMeasure', 'Measure Theory', '(value)', 'Classify a measure by its standard Measure Theory invariants.', 'professional_function_catalog.md'), + ('measureTheoryClassifyNullSet', 'Measure Theory', '(value)', 'Classify a null set by its standard Measure Theory invariants.', 'professional_function_catalog.md'), + ('measureTheoryClassifySigmaAlgebra', 'Measure Theory', '(value)', 'Classify a sigma algebra by its standard Measure Theory invariants.', 'professional_function_catalog.md'), + ('measureTheoryClassifySimpleFunction', 'Measure Theory', '(value)', 'Classify a simple function by its standard Measure Theory invariants.', 'professional_function_catalog.md'), + ('measureTheoryCombineMeasurableFunction', 'Measure Theory', '(left, right)', 'Combine two measurable function values with the natural operation for Measure Theory.', 'professional_function_catalog.md'), + ('measureTheoryCombineMeasure', 'Measure Theory', '(left, right)', 'Combine two measure values with the natural operation for Measure Theory.', 'professional_function_catalog.md'), + ('measureTheoryCombineNullSet', 'Measure Theory', '(left, right)', 'Combine two null set values with the natural operation for Measure Theory.', 'professional_function_catalog.md'), + ('measureTheoryCombineSigmaAlgebra', 'Measure Theory', '(left, right)', 'Combine two sigma algebra values with the natural operation for Measure Theory.', 'professional_function_catalog.md'), + ('measureTheoryCombineSimpleFunction', 'Measure Theory', '(left, right)', 'Combine two simple function values with the natural operation for Measure Theory.', 'professional_function_catalog.md'), + ('measureTheoryCompareMeasurableFunction', 'Measure Theory', '(left, right)', 'Compare two measurable function values under the conventions of Measure Theory.', 'professional_function_catalog.md'), + ('measureTheoryCompareMeasure', 'Measure Theory', '(left, right)', 'Compare two measure values under the conventions of Measure Theory.', 'professional_function_catalog.md'), + ('measureTheoryCompareNullSet', 'Measure Theory', '(left, right)', 'Compare two null set values under the conventions of Measure Theory.', 'professional_function_catalog.md'), + ('measureTheoryCompareSigmaAlgebra', 'Measure Theory', '(left, right)', 'Compare two sigma algebra values under the conventions of Measure Theory.', 'professional_function_catalog.md'), + ('measureTheoryCompareSimpleFunction', 'Measure Theory', '(left, right)', 'Compare two simple function values under the conventions of Measure Theory.', 'professional_function_catalog.md'), + ('measureTheoryComputeMeasurableFunction', 'Measure Theory', '(value)', 'Compute the central numerical or symbolic data of a measurable function.', 'professional_function_catalog.md'), + ('measureTheoryComputeMeasure', 'Measure Theory', '(value)', 'Compute the central numerical or symbolic data of a measure.', 'professional_function_catalog.md'), + ('measureTheoryComputeNullSet', 'Measure Theory', '(value)', 'Compute the central numerical or symbolic data of a null set.', 'professional_function_catalog.md'), + ('measureTheoryComputeSigmaAlgebra', 'Measure Theory', '(value)', 'Compute the central numerical or symbolic data of a sigma algebra.', 'professional_function_catalog.md'), + ('measureTheoryComputeSimpleFunction', 'Measure Theory', '(value)', 'Compute the central numerical or symbolic data of a simple function.', 'professional_function_catalog.md'), + ('measureTheoryConstructMeasurableFunction', 'Measure Theory', '(*args)', 'Construct a measurable function from explicit inputs for Measure Theory.', 'professional_function_catalog.md'), + ('measureTheoryConstructMeasure', 'Measure Theory', '(*args)', 'Construct a measure from explicit inputs for Measure Theory.', 'professional_function_catalog.md'), + ('measureTheoryConstructNullSet', 'Measure Theory', '(*args)', 'Construct a null set from explicit inputs for Measure Theory.', 'professional_function_catalog.md'), + ('measureTheoryConstructSigmaAlgebra', 'Measure Theory', '(*args)', 'Construct a sigma algebra from explicit inputs for Measure Theory.', 'professional_function_catalog.md'), + ('measureTheoryConstructSimpleFunction', 'Measure Theory', '(*args)', 'Construct a simple function from explicit inputs for Measure Theory.', 'professional_function_catalog.md'), + ('measureTheoryDecomposeMeasurableFunction', 'Measure Theory', '(value)', 'Decompose a measurable function into simpler or canonical components.', 'professional_function_catalog.md'), + ('measureTheoryDecomposeMeasure', 'Measure Theory', '(value)', 'Decompose a measure into simpler or canonical components.', 'professional_function_catalog.md'), + ('measureTheoryDecomposeNullSet', 'Measure Theory', '(value)', 'Decompose a null set into simpler or canonical components.', 'professional_function_catalog.md'), + ('measureTheoryDecomposeSigmaAlgebra', 'Measure Theory', '(value)', 'Decompose a sigma algebra into simpler or canonical components.', 'professional_function_catalog.md'), + ('measureTheoryDecomposeSimpleFunction', 'Measure Theory', '(value)', 'Decompose a simple function into simpler or canonical components.', 'professional_function_catalog.md'), + ('measureTheoryDocumentMeasurableFunction', 'Measure Theory', '(value)', 'Return a structured explanation of a measurable function and related assumptions.', 'professional_function_catalog.md'), + ('measureTheoryDocumentMeasure', 'Measure Theory', '(value)', 'Return a structured explanation of a measure and related assumptions.', 'professional_function_catalog.md'), + ('measureTheoryDocumentNullSet', 'Measure Theory', '(value)', 'Return a structured explanation of a null set and related assumptions.', 'professional_function_catalog.md'), + ('measureTheoryDocumentSigmaAlgebra', 'Measure Theory', '(value)', 'Return a structured explanation of a sigma algebra and related assumptions.', 'professional_function_catalog.md'), + ('measureTheoryDocumentSimpleFunction', 'Measure Theory', '(value)', 'Return a structured explanation of a simple function and related assumptions.', 'professional_function_catalog.md'), + ('measureTheoryEnumerateMeasurableFunction', 'Measure Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a measurable function.', 'professional_function_catalog.md'), + ('measureTheoryEnumerateMeasure', 'Measure Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a measure.', 'professional_function_catalog.md'), + ('measureTheoryEnumerateNullSet', 'Measure Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a null set.', 'professional_function_catalog.md'), + ('measureTheoryEnumerateSigmaAlgebra', 'Measure Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a sigma algebra.', 'professional_function_catalog.md'), + ('measureTheoryEnumerateSimpleFunction', 'Measure Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a simple function.', 'professional_function_catalog.md'), + ('measureTheoryEstimateMeasurableFunction', 'Measure Theory', '(value, samples=None)', 'Estimate a measurable function property from finite samples or approximations.', 'professional_function_catalog.md'), + ('measureTheoryEstimateMeasure', 'Measure Theory', '(value, samples=None)', 'Estimate a measure property from finite samples or approximations.', 'professional_function_catalog.md'), + ('measureTheoryEstimateNullSet', 'Measure Theory', '(value, samples=None)', 'Estimate a null set property from finite samples or approximations.', 'professional_function_catalog.md'), + ('measureTheoryEstimateSigmaAlgebra', 'Measure Theory', '(value, samples=None)', 'Estimate a sigma algebra property from finite samples or approximations.', 'professional_function_catalog.md'), + ('measureTheoryEstimateSimpleFunction', 'Measure Theory', '(value, samples=None)', 'Estimate a simple function property from finite samples or approximations.', 'professional_function_catalog.md'), + ('measureTheoryEvaluateMeasurableFunction', 'Measure Theory', '(value, point=None)', 'Evaluate a measurable function at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('measureTheoryEvaluateMeasure', 'Measure Theory', '(value, point=None)', 'Evaluate a measure at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('measureTheoryEvaluateNullSet', 'Measure Theory', '(value, point=None)', 'Evaluate a null set at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('measureTheoryEvaluateSigmaAlgebra', 'Measure Theory', '(value, point=None)', 'Evaluate a sigma algebra at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('measureTheoryEvaluateSimpleFunction', 'Measure Theory', '(value, point=None)', 'Evaluate a simple function at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('measureTheoryFormatMeasurableFunction', 'Measure Theory', '(value)', 'Format a measurable function for deterministic user-facing output.', 'professional_function_catalog.md'), + ('measureTheoryFormatMeasure', 'Measure Theory', '(value)', 'Format a measure for deterministic user-facing output.', 'professional_function_catalog.md'), + ('measureTheoryFormatNullSet', 'Measure Theory', '(value)', 'Format a null set for deterministic user-facing output.', 'professional_function_catalog.md'), + ('measureTheoryFormatSigmaAlgebra', 'Measure Theory', '(value)', 'Format a sigma algebra for deterministic user-facing output.', 'professional_function_catalog.md'), + ('measureTheoryFormatSimpleFunction', 'Measure Theory', '(value)', 'Format a simple function for deterministic user-facing output.', 'professional_function_catalog.md'), + ('measureTheoryGenerateExampleMeasurableFunction', 'Measure Theory', '(size=3)', 'Generate a small documented example of a measurable function.', 'professional_function_catalog.md'), + ('measureTheoryGenerateExampleMeasure', 'Measure Theory', '(size=3)', 'Generate a small documented example of a measure.', 'professional_function_catalog.md'), + ('measureTheoryGenerateExampleNullSet', 'Measure Theory', '(size=3)', 'Generate a small documented example of a null set.', 'professional_function_catalog.md'), + ('measureTheoryGenerateExampleSigmaAlgebra', 'Measure Theory', '(size=3)', 'Generate a small documented example of a sigma algebra.', 'professional_function_catalog.md'), + ('measureTheoryGenerateExampleSimpleFunction', 'Measure Theory', '(size=3)', 'Generate a small documented example of a simple function.', 'professional_function_catalog.md'), + ('measureTheoryNormalizeMeasurableFunction', 'Measure Theory', '(value)', 'Normalize a measurable function into the standard Measure Theory representation.', 'professional_function_catalog.md'), + ('measureTheoryNormalizeMeasure', 'Measure Theory', '(value)', 'Normalize a measure into the standard Measure Theory representation.', 'professional_function_catalog.md'), + ('measureTheoryNormalizeNullSet', 'Measure Theory', '(value)', 'Normalize a null set into the standard Measure Theory representation.', 'professional_function_catalog.md'), + ('measureTheoryNormalizeSigmaAlgebra', 'Measure Theory', '(value)', 'Normalize a sigma algebra into the standard Measure Theory representation.', 'professional_function_catalog.md'), + ('measureTheoryNormalizeSimpleFunction', 'Measure Theory', '(value)', 'Normalize a simple function into the standard Measure Theory representation.', 'professional_function_catalog.md'), + ('measureTheoryParseMeasurableFunction', 'Measure Theory', '(text)', 'Parse a text or structured value into a measurable function.', 'professional_function_catalog.md'), + ('measureTheoryParseMeasure', 'Measure Theory', '(text)', 'Parse a text or structured value into a measure.', 'professional_function_catalog.md'), + ('measureTheoryParseNullSet', 'Measure Theory', '(text)', 'Parse a text or structured value into a null set.', 'professional_function_catalog.md'), + ('measureTheoryParseSigmaAlgebra', 'Measure Theory', '(text)', 'Parse a text or structured value into a sigma algebra.', 'professional_function_catalog.md'), + ('measureTheoryParseSimpleFunction', 'Measure Theory', '(text)', 'Parse a text or structured value into a simple function.', 'professional_function_catalog.md'), + ('measureTheorySimplifyMeasurableFunction', 'Measure Theory', '(value)', 'Simplify a measurable function without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('measureTheorySimplifyMeasure', 'Measure Theory', '(value)', 'Simplify a measure without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('measureTheorySimplifyNullSet', 'Measure Theory', '(value)', 'Simplify a null set without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('measureTheorySimplifySigmaAlgebra', 'Measure Theory', '(value)', 'Simplify a sigma algebra without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('measureTheorySimplifySimpleFunction', 'Measure Theory', '(value)', 'Simplify a simple function without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('measureTheoryTestEquivalenceMeasurableFunction', 'Measure Theory', '(left, right)', 'Test whether two measurable function values are equivalent in Measure Theory.', 'professional_function_catalog.md'), + ('measureTheoryTestEquivalenceMeasure', 'Measure Theory', '(left, right)', 'Test whether two measure values are equivalent in Measure Theory.', 'professional_function_catalog.md'), + ('measureTheoryTestEquivalenceNullSet', 'Measure Theory', '(left, right)', 'Test whether two null set values are equivalent in Measure Theory.', 'professional_function_catalog.md'), + ('measureTheoryTestEquivalenceSigmaAlgebra', 'Measure Theory', '(left, right)', 'Test whether two sigma algebra values are equivalent in Measure Theory.', 'professional_function_catalog.md'), + ('measureTheoryTestEquivalenceSimpleFunction', 'Measure Theory', '(left, right)', 'Test whether two simple function values are equivalent in Measure Theory.', 'professional_function_catalog.md'), + ('measureTheoryTransformMeasurableFunction', 'Measure Theory', '(value, mapping)', 'Transform a measurable function through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('measureTheoryTransformMeasure', 'Measure Theory', '(value, mapping)', 'Transform a measure through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('measureTheoryTransformNullSet', 'Measure Theory', '(value, mapping)', 'Transform a null set through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('measureTheoryTransformSigmaAlgebra', 'Measure Theory', '(value, mapping)', 'Transform a sigma algebra through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('measureTheoryTransformSimpleFunction', 'Measure Theory', '(value, mapping)', 'Transform a simple function through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('measureTheoryValidateMeasurableFunction', 'Measure Theory', '(value)', 'Validate the measurable function representation and domain rules for Measure Theory.', 'professional_function_catalog.md'), + ('measureTheoryValidateMeasure', 'Measure Theory', '(value)', 'Validate the measure representation and domain rules for Measure Theory.', 'professional_function_catalog.md'), + ('measureTheoryValidateNullSet', 'Measure Theory', '(value)', 'Validate the null set representation and domain rules for Measure Theory.', 'professional_function_catalog.md'), + ('measureTheoryValidateSigmaAlgebra', 'Measure Theory', '(value)', 'Validate the sigma algebra representation and domain rules for Measure Theory.', 'professional_function_catalog.md'), + ('measureTheoryValidateSimpleFunction', 'Measure Theory', '(value)', 'Validate the simple function representation and domain rules for Measure Theory.', 'professional_function_catalog.md'), + ('outerMeasure', 'Measure Theory', '(set, coverings, measure)', 'Planned roadmap function for Measure Theory from upcoming.md.', 'upcoming.md'), + ('probabilitySpace', 'Measure Theory', '(universalSet, sigmaAlgebra, measure)', 'Planned roadmap function for Measure Theory from upcoming.md.', 'upcoming.md'), + ('simpleFunctionIntegral', 'Measure Theory', '(values, measures)', 'Planned roadmap function for Measure Theory from upcoming.md.', 'upcoming.md'), + ('closedBall', 'Metric Spaces', '(center, radius, points, metric="euclidean")', 'Planned roadmap function for Metric Spaces from upcoming.md.', 'upcoming.md'), + ('diameter', 'Metric Spaces', '(points, metric="euclidean")', 'Planned roadmap function for Metric Spaces from upcoming.md.', 'upcoming.md'), + ('discreteMetric', 'Metric Spaces', '(x, y)', 'Planned roadmap function for Metric Spaces from upcoming.md.', 'upcoming.md'), + ('isBounded', 'Metric Spaces', '(points, metric="euclidean")', 'Planned roadmap function for Metric Spaces from upcoming.md.', 'upcoming.md'), + ('metricSpacesApproximateBoundedSet', 'Metric Spaces', '(value, tolerance=1e-9)', 'Approximate a bounded set with explicit tolerance controls.', 'professional_function_catalog.md'), + ('metricSpacesApproximateMetric', 'Metric Spaces', '(value, tolerance=1e-9)', 'Approximate a metric with explicit tolerance controls.', 'professional_function_catalog.md'), + ('metricSpacesApproximateOpenBall', 'Metric Spaces', '(value, tolerance=1e-9)', 'Approximate a open ball with explicit tolerance controls.', 'professional_function_catalog.md'), + ('metricSpacesApproximatePointCloud', 'Metric Spaces', '(value, tolerance=1e-9)', 'Approximate a point cloud with explicit tolerance controls.', 'professional_function_catalog.md'), + ('metricSpacesApproximateSequence', 'Metric Spaces', '(value, tolerance=1e-9)', 'Approximate a sequence with explicit tolerance controls.', 'professional_function_catalog.md'), + ('metricSpacesCanonicalizeBoundedSet', 'Metric Spaces', '(value)', 'Canonicalize a bounded set so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('metricSpacesCanonicalizeMetric', 'Metric Spaces', '(value)', 'Canonicalize a metric so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('metricSpacesCanonicalizeOpenBall', 'Metric Spaces', '(value)', 'Canonicalize a open ball so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('metricSpacesCanonicalizePointCloud', 'Metric Spaces', '(value)', 'Canonicalize a point cloud so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('metricSpacesCanonicalizeSequence', 'Metric Spaces', '(value)', 'Canonicalize a sequence so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('metricSpacesClassifyBoundedSet', 'Metric Spaces', '(value)', 'Classify a bounded set by its standard Metric Spaces invariants.', 'professional_function_catalog.md'), + ('metricSpacesClassifyMetric', 'Metric Spaces', '(value)', 'Classify a metric by its standard Metric Spaces invariants.', 'professional_function_catalog.md'), + ('metricSpacesClassifyOpenBall', 'Metric Spaces', '(value)', 'Classify a open ball by its standard Metric Spaces invariants.', 'professional_function_catalog.md'), + ('metricSpacesClassifyPointCloud', 'Metric Spaces', '(value)', 'Classify a point cloud by its standard Metric Spaces invariants.', 'professional_function_catalog.md'), + ('metricSpacesClassifySequence', 'Metric Spaces', '(value)', 'Classify a sequence by its standard Metric Spaces invariants.', 'professional_function_catalog.md'), + ('metricSpacesCombineBoundedSet', 'Metric Spaces', '(left, right)', 'Combine two bounded set values with the natural operation for Metric Spaces.', 'professional_function_catalog.md'), + ('metricSpacesCombineMetric', 'Metric Spaces', '(left, right)', 'Combine two metric values with the natural operation for Metric Spaces.', 'professional_function_catalog.md'), + ('metricSpacesCombineOpenBall', 'Metric Spaces', '(left, right)', 'Combine two open ball values with the natural operation for Metric Spaces.', 'professional_function_catalog.md'), + ('metricSpacesCombinePointCloud', 'Metric Spaces', '(left, right)', 'Combine two point cloud values with the natural operation for Metric Spaces.', 'professional_function_catalog.md'), + ('metricSpacesCombineSequence', 'Metric Spaces', '(left, right)', 'Combine two sequence values with the natural operation for Metric Spaces.', 'professional_function_catalog.md'), + ('metricSpacesCompareBoundedSet', 'Metric Spaces', '(left, right)', 'Compare two bounded set values under the conventions of Metric Spaces.', 'professional_function_catalog.md'), + ('metricSpacesCompareMetric', 'Metric Spaces', '(left, right)', 'Compare two metric values under the conventions of Metric Spaces.', 'professional_function_catalog.md'), + ('metricSpacesCompareOpenBall', 'Metric Spaces', '(left, right)', 'Compare two open ball values under the conventions of Metric Spaces.', 'professional_function_catalog.md'), + ('metricSpacesComparePointCloud', 'Metric Spaces', '(left, right)', 'Compare two point cloud values under the conventions of Metric Spaces.', 'professional_function_catalog.md'), + ('metricSpacesCompareSequence', 'Metric Spaces', '(left, right)', 'Compare two sequence values under the conventions of Metric Spaces.', 'professional_function_catalog.md'), + ('metricSpacesComputeBoundedSet', 'Metric Spaces', '(value)', 'Compute the central numerical or symbolic data of a bounded set.', 'professional_function_catalog.md'), + ('metricSpacesComputeMetric', 'Metric Spaces', '(value)', 'Compute the central numerical or symbolic data of a metric.', 'professional_function_catalog.md'), + ('metricSpacesComputeOpenBall', 'Metric Spaces', '(value)', 'Compute the central numerical or symbolic data of a open ball.', 'professional_function_catalog.md'), + ('metricSpacesComputePointCloud', 'Metric Spaces', '(value)', 'Compute the central numerical or symbolic data of a point cloud.', 'professional_function_catalog.md'), + ('metricSpacesComputeSequence', 'Metric Spaces', '(value)', 'Compute the central numerical or symbolic data of a sequence.', 'professional_function_catalog.md'), + ('metricSpacesConstructBoundedSet', 'Metric Spaces', '(*args)', 'Construct a bounded set from explicit inputs for Metric Spaces.', 'professional_function_catalog.md'), + ('metricSpacesConstructMetric', 'Metric Spaces', '(*args)', 'Construct a metric from explicit inputs for Metric Spaces.', 'professional_function_catalog.md'), + ('metricSpacesConstructOpenBall', 'Metric Spaces', '(*args)', 'Construct a open ball from explicit inputs for Metric Spaces.', 'professional_function_catalog.md'), + ('metricSpacesConstructPointCloud', 'Metric Spaces', '(*args)', 'Construct a point cloud from explicit inputs for Metric Spaces.', 'professional_function_catalog.md'), + ('metricSpacesConstructSequence', 'Metric Spaces', '(*args)', 'Construct a sequence from explicit inputs for Metric Spaces.', 'professional_function_catalog.md'), + ('metricSpacesDecomposeBoundedSet', 'Metric Spaces', '(value)', 'Decompose a bounded set into simpler or canonical components.', 'professional_function_catalog.md'), + ('metricSpacesDecomposeMetric', 'Metric Spaces', '(value)', 'Decompose a metric into simpler or canonical components.', 'professional_function_catalog.md'), + ('metricSpacesDecomposeOpenBall', 'Metric Spaces', '(value)', 'Decompose a open ball into simpler or canonical components.', 'professional_function_catalog.md'), + ('metricSpacesDecomposePointCloud', 'Metric Spaces', '(value)', 'Decompose a point cloud into simpler or canonical components.', 'professional_function_catalog.md'), + ('metricSpacesDecomposeSequence', 'Metric Spaces', '(value)', 'Decompose a sequence into simpler or canonical components.', 'professional_function_catalog.md'), + ('metricSpacesDocumentBoundedSet', 'Metric Spaces', '(value)', 'Return a structured explanation of a bounded set and related assumptions.', 'professional_function_catalog.md'), + ('metricSpacesDocumentMetric', 'Metric Spaces', '(value)', 'Return a structured explanation of a metric and related assumptions.', 'professional_function_catalog.md'), + ('metricSpacesDocumentOpenBall', 'Metric Spaces', '(value)', 'Return a structured explanation of a open ball and related assumptions.', 'professional_function_catalog.md'), + ('metricSpacesDocumentPointCloud', 'Metric Spaces', '(value)', 'Return a structured explanation of a point cloud and related assumptions.', 'professional_function_catalog.md'), + ('metricSpacesDocumentSequence', 'Metric Spaces', '(value)', 'Return a structured explanation of a sequence and related assumptions.', 'professional_function_catalog.md'), + ('metricSpacesEnumerateBoundedSet', 'Metric Spaces', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a bounded set.', 'professional_function_catalog.md'), + ('metricSpacesEnumerateMetric', 'Metric Spaces', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a metric.', 'professional_function_catalog.md'), + ('metricSpacesEnumerateOpenBall', 'Metric Spaces', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a open ball.', 'professional_function_catalog.md'), + ('metricSpacesEnumeratePointCloud', 'Metric Spaces', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a point cloud.', 'professional_function_catalog.md'), + ('metricSpacesEnumerateSequence', 'Metric Spaces', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a sequence.', 'professional_function_catalog.md'), + ('metricSpacesEstimateBoundedSet', 'Metric Spaces', '(value, samples=None)', 'Estimate a bounded set property from finite samples or approximations.', 'professional_function_catalog.md'), + ('metricSpacesEstimateMetric', 'Metric Spaces', '(value, samples=None)', 'Estimate a metric property from finite samples or approximations.', 'professional_function_catalog.md'), + ('metricSpacesEstimateOpenBall', 'Metric Spaces', '(value, samples=None)', 'Estimate a open ball property from finite samples or approximations.', 'professional_function_catalog.md'), + ('metricSpacesEstimatePointCloud', 'Metric Spaces', '(value, samples=None)', 'Estimate a point cloud property from finite samples or approximations.', 'professional_function_catalog.md'), + ('metricSpacesEstimateSequence', 'Metric Spaces', '(value, samples=None)', 'Estimate a sequence property from finite samples or approximations.', 'professional_function_catalog.md'), + ('metricSpacesEvaluateBoundedSet', 'Metric Spaces', '(value, point=None)', 'Evaluate a bounded set at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('metricSpacesEvaluateMetric', 'Metric Spaces', '(value, point=None)', 'Evaluate a metric at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('metricSpacesEvaluateOpenBall', 'Metric Spaces', '(value, point=None)', 'Evaluate a open ball at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('metricSpacesEvaluatePointCloud', 'Metric Spaces', '(value, point=None)', 'Evaluate a point cloud at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('metricSpacesEvaluateSequence', 'Metric Spaces', '(value, point=None)', 'Evaluate a sequence at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('metricSpacesFormatBoundedSet', 'Metric Spaces', '(value)', 'Format a bounded set for deterministic user-facing output.', 'professional_function_catalog.md'), + ('metricSpacesFormatMetric', 'Metric Spaces', '(value)', 'Format a metric for deterministic user-facing output.', 'professional_function_catalog.md'), + ('metricSpacesFormatOpenBall', 'Metric Spaces', '(value)', 'Format a open ball for deterministic user-facing output.', 'professional_function_catalog.md'), + ('metricSpacesFormatPointCloud', 'Metric Spaces', '(value)', 'Format a point cloud for deterministic user-facing output.', 'professional_function_catalog.md'), + ('metricSpacesFormatSequence', 'Metric Spaces', '(value)', 'Format a sequence for deterministic user-facing output.', 'professional_function_catalog.md'), + ('metricSpacesGenerateExampleBoundedSet', 'Metric Spaces', '(size=3)', 'Generate a small documented example of a bounded set.', 'professional_function_catalog.md'), + ('metricSpacesGenerateExampleMetric', 'Metric Spaces', '(size=3)', 'Generate a small documented example of a metric.', 'professional_function_catalog.md'), + ('metricSpacesGenerateExampleOpenBall', 'Metric Spaces', '(size=3)', 'Generate a small documented example of a open ball.', 'professional_function_catalog.md'), + ('metricSpacesGenerateExamplePointCloud', 'Metric Spaces', '(size=3)', 'Generate a small documented example of a point cloud.', 'professional_function_catalog.md'), + ('metricSpacesGenerateExampleSequence', 'Metric Spaces', '(size=3)', 'Generate a small documented example of a sequence.', 'professional_function_catalog.md'), + ('metricSpacesNormalizeBoundedSet', 'Metric Spaces', '(value)', 'Normalize a bounded set into the standard Metric Spaces representation.', 'professional_function_catalog.md'), + ('metricSpacesNormalizeMetric', 'Metric Spaces', '(value)', 'Normalize a metric into the standard Metric Spaces representation.', 'professional_function_catalog.md'), + ('metricSpacesNormalizeOpenBall', 'Metric Spaces', '(value)', 'Normalize a open ball into the standard Metric Spaces representation.', 'professional_function_catalog.md'), + ('metricSpacesNormalizePointCloud', 'Metric Spaces', '(value)', 'Normalize a point cloud into the standard Metric Spaces representation.', 'professional_function_catalog.md'), + ('metricSpacesNormalizeSequence', 'Metric Spaces', '(value)', 'Normalize a sequence into the standard Metric Spaces representation.', 'professional_function_catalog.md'), + ('metricSpacesParseBoundedSet', 'Metric Spaces', '(text)', 'Parse a text or structured value into a bounded set.', 'professional_function_catalog.md'), + ('metricSpacesParseMetric', 'Metric Spaces', '(text)', 'Parse a text or structured value into a metric.', 'professional_function_catalog.md'), + ('metricSpacesParseOpenBall', 'Metric Spaces', '(text)', 'Parse a text or structured value into a open ball.', 'professional_function_catalog.md'), + ('metricSpacesParsePointCloud', 'Metric Spaces', '(text)', 'Parse a text or structured value into a point cloud.', 'professional_function_catalog.md'), + ('metricSpacesParseSequence', 'Metric Spaces', '(text)', 'Parse a text or structured value into a sequence.', 'professional_function_catalog.md'), + ('metricSpacesSimplifyBoundedSet', 'Metric Spaces', '(value)', 'Simplify a bounded set without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('metricSpacesSimplifyMetric', 'Metric Spaces', '(value)', 'Simplify a metric without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('metricSpacesSimplifyOpenBall', 'Metric Spaces', '(value)', 'Simplify a open ball without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('metricSpacesSimplifyPointCloud', 'Metric Spaces', '(value)', 'Simplify a point cloud without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('metricSpacesSimplifySequence', 'Metric Spaces', '(value)', 'Simplify a sequence without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('metricSpacesTestEquivalenceBoundedSet', 'Metric Spaces', '(left, right)', 'Test whether two bounded set values are equivalent in Metric Spaces.', 'professional_function_catalog.md'), + ('metricSpacesTestEquivalenceMetric', 'Metric Spaces', '(left, right)', 'Test whether two metric values are equivalent in Metric Spaces.', 'professional_function_catalog.md'), + ('metricSpacesTestEquivalenceOpenBall', 'Metric Spaces', '(left, right)', 'Test whether two open ball values are equivalent in Metric Spaces.', 'professional_function_catalog.md'), + ('metricSpacesTestEquivalencePointCloud', 'Metric Spaces', '(left, right)', 'Test whether two point cloud values are equivalent in Metric Spaces.', 'professional_function_catalog.md'), + ('metricSpacesTestEquivalenceSequence', 'Metric Spaces', '(left, right)', 'Test whether two sequence values are equivalent in Metric Spaces.', 'professional_function_catalog.md'), + ('metricSpacesTransformBoundedSet', 'Metric Spaces', '(value, mapping)', 'Transform a bounded set through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('metricSpacesTransformMetric', 'Metric Spaces', '(value, mapping)', 'Transform a metric through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('metricSpacesTransformOpenBall', 'Metric Spaces', '(value, mapping)', 'Transform a open ball through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('metricSpacesTransformPointCloud', 'Metric Spaces', '(value, mapping)', 'Transform a point cloud through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('metricSpacesTransformSequence', 'Metric Spaces', '(value, mapping)', 'Transform a sequence through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('metricSpacesValidateBoundedSet', 'Metric Spaces', '(value)', 'Validate the bounded set representation and domain rules for Metric Spaces.', 'professional_function_catalog.md'), + ('metricSpacesValidateMetric', 'Metric Spaces', '(value)', 'Validate the metric representation and domain rules for Metric Spaces.', 'professional_function_catalog.md'), + ('metricSpacesValidateOpenBall', 'Metric Spaces', '(value)', 'Validate the open ball representation and domain rules for Metric Spaces.', 'professional_function_catalog.md'), + ('metricSpacesValidatePointCloud', 'Metric Spaces', '(value)', 'Validate the point cloud representation and domain rules for Metric Spaces.', 'professional_function_catalog.md'), + ('metricSpacesValidateSequence', 'Metric Spaces', '(value)', 'Validate the sequence representation and domain rules for Metric Spaces.', 'professional_function_catalog.md'), + ('minkowskiDistance', 'Metric Spaces', '(x, y, p)', 'Planned roadmap function for Metric Spaces from upcoming.md.', 'upcoming.md'), + ('nearestNeighbor', 'Metric Spaces', '(point, points, metric="euclidean")', 'Planned roadmap function for Metric Spaces from upcoming.md.', 'upcoming.md'), + ('openBall', 'Metric Spaces', '(center, radius, points, metric="euclidean")', 'Planned roadmap function for Metric Spaces from upcoming.md.', 'upcoming.md'), + ('sequenceConverges', 'Metric Spaces', '(sequence, target, tolerance=1e-9)', 'Planned roadmap function for Metric Spaces from upcoming.md.', 'upcoming.md'), + ('automorphismsFiniteStructure', 'Model Theory', '(structure)', 'Planned roadmap function for Model Theory from upcoming.md.', 'upcoming.md'), + ('elementaryEquivalentFinite', 'Model Theory', '(structureA, structureB, formulas)', 'Planned roadmap function for Model Theory from upcoming.md.', 'upcoming.md'), + ('evaluateTerm', 'Model Theory', '(term, structure, assignment)', 'Planned roadmap function for Model Theory from upcoming.md.', 'upcoming.md'), + ('isIsomorphicStructure', 'Model Theory', '(structureA, structureB, mapping)', 'Planned roadmap function for Model Theory from upcoming.md.', 'upcoming.md'), + ('modelTheoryApproximateFormula', 'Model Theory', '(value, tolerance=1e-9)', 'Approximate a formula with explicit tolerance controls.', 'professional_function_catalog.md'), + ('modelTheoryApproximateLanguage', 'Model Theory', '(value, tolerance=1e-9)', 'Approximate a language with explicit tolerance controls.', 'professional_function_catalog.md'), + ('modelTheoryApproximateModel', 'Model Theory', '(value, tolerance=1e-9)', 'Approximate a model with explicit tolerance controls.', 'professional_function_catalog.md'), + ('modelTheoryApproximateStructure', 'Model Theory', '(value, tolerance=1e-9)', 'Approximate a structure with explicit tolerance controls.', 'professional_function_catalog.md'), + ('modelTheoryApproximateTerm', 'Model Theory', '(value, tolerance=1e-9)', 'Approximate a term with explicit tolerance controls.', 'professional_function_catalog.md'), + ('modelTheoryCanonicalizeFormula', 'Model Theory', '(value)', 'Canonicalize a formula so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('modelTheoryCanonicalizeLanguage', 'Model Theory', '(value)', 'Canonicalize a language so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('modelTheoryCanonicalizeModel', 'Model Theory', '(value)', 'Canonicalize a model so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('modelTheoryCanonicalizeStructure', 'Model Theory', '(value)', 'Canonicalize a structure so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('modelTheoryCanonicalizeTerm', 'Model Theory', '(value)', 'Canonicalize a term so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('modelTheoryClassifyFormula', 'Model Theory', '(value)', 'Classify a formula by its standard Model Theory invariants.', 'professional_function_catalog.md'), + ('modelTheoryClassifyLanguage', 'Model Theory', '(value)', 'Classify a language by its standard Model Theory invariants.', 'professional_function_catalog.md'), + ('modelTheoryClassifyModel', 'Model Theory', '(value)', 'Classify a model by its standard Model Theory invariants.', 'professional_function_catalog.md'), + ('modelTheoryClassifyStructure', 'Model Theory', '(value)', 'Classify a structure by its standard Model Theory invariants.', 'professional_function_catalog.md'), + ('modelTheoryClassifyTerm', 'Model Theory', '(value)', 'Classify a term by its standard Model Theory invariants.', 'professional_function_catalog.md'), + ('modelTheoryCombineFormula', 'Model Theory', '(left, right)', 'Combine two formula values with the natural operation for Model Theory.', 'professional_function_catalog.md'), + ('modelTheoryCombineLanguage', 'Model Theory', '(left, right)', 'Combine two language values with the natural operation for Model Theory.', 'professional_function_catalog.md'), + ('modelTheoryCombineModel', 'Model Theory', '(left, right)', 'Combine two model values with the natural operation for Model Theory.', 'professional_function_catalog.md'), + ('modelTheoryCombineStructure', 'Model Theory', '(left, right)', 'Combine two structure values with the natural operation for Model Theory.', 'professional_function_catalog.md'), + ('modelTheoryCombineTerm', 'Model Theory', '(left, right)', 'Combine two term values with the natural operation for Model Theory.', 'professional_function_catalog.md'), + ('modelTheoryCompareFormula', 'Model Theory', '(left, right)', 'Compare two formula values under the conventions of Model Theory.', 'professional_function_catalog.md'), + ('modelTheoryCompareLanguage', 'Model Theory', '(left, right)', 'Compare two language values under the conventions of Model Theory.', 'professional_function_catalog.md'), + ('modelTheoryCompareModel', 'Model Theory', '(left, right)', 'Compare two model values under the conventions of Model Theory.', 'professional_function_catalog.md'), + ('modelTheoryCompareStructure', 'Model Theory', '(left, right)', 'Compare two structure values under the conventions of Model Theory.', 'professional_function_catalog.md'), + ('modelTheoryCompareTerm', 'Model Theory', '(left, right)', 'Compare two term values under the conventions of Model Theory.', 'professional_function_catalog.md'), + ('modelTheoryComputeFormula', 'Model Theory', '(value)', 'Compute the central numerical or symbolic data of a formula.', 'professional_function_catalog.md'), + ('modelTheoryComputeLanguage', 'Model Theory', '(value)', 'Compute the central numerical or symbolic data of a language.', 'professional_function_catalog.md'), + ('modelTheoryComputeModel', 'Model Theory', '(value)', 'Compute the central numerical or symbolic data of a model.', 'professional_function_catalog.md'), + ('modelTheoryComputeStructure', 'Model Theory', '(value)', 'Compute the central numerical or symbolic data of a structure.', 'professional_function_catalog.md'), + ('modelTheoryComputeTerm', 'Model Theory', '(value)', 'Compute the central numerical or symbolic data of a term.', 'professional_function_catalog.md'), + ('modelTheoryConstructFormula', 'Model Theory', '(*args)', 'Construct a formula from explicit inputs for Model Theory.', 'professional_function_catalog.md'), + ('modelTheoryConstructLanguage', 'Model Theory', '(*args)', 'Construct a language from explicit inputs for Model Theory.', 'professional_function_catalog.md'), + ('modelTheoryConstructModel', 'Model Theory', '(*args)', 'Construct a model from explicit inputs for Model Theory.', 'professional_function_catalog.md'), + ('modelTheoryConstructStructure', 'Model Theory', '(*args)', 'Construct a structure from explicit inputs for Model Theory.', 'professional_function_catalog.md'), + ('modelTheoryConstructTerm', 'Model Theory', '(*args)', 'Construct a term from explicit inputs for Model Theory.', 'professional_function_catalog.md'), + ('modelTheoryDecomposeFormula', 'Model Theory', '(value)', 'Decompose a formula into simpler or canonical components.', 'professional_function_catalog.md'), + ('modelTheoryDecomposeLanguage', 'Model Theory', '(value)', 'Decompose a language into simpler or canonical components.', 'professional_function_catalog.md'), + ('modelTheoryDecomposeModel', 'Model Theory', '(value)', 'Decompose a model into simpler or canonical components.', 'professional_function_catalog.md'), + ('modelTheoryDecomposeStructure', 'Model Theory', '(value)', 'Decompose a structure into simpler or canonical components.', 'professional_function_catalog.md'), + ('modelTheoryDecomposeTerm', 'Model Theory', '(value)', 'Decompose a term into simpler or canonical components.', 'professional_function_catalog.md'), + ('modelTheoryDocumentFormula', 'Model Theory', '(value)', 'Return a structured explanation of a formula and related assumptions.', 'professional_function_catalog.md'), + ('modelTheoryDocumentLanguage', 'Model Theory', '(value)', 'Return a structured explanation of a language and related assumptions.', 'professional_function_catalog.md'), + ('modelTheoryDocumentModel', 'Model Theory', '(value)', 'Return a structured explanation of a model and related assumptions.', 'professional_function_catalog.md'), + ('modelTheoryDocumentStructure', 'Model Theory', '(value)', 'Return a structured explanation of a structure and related assumptions.', 'professional_function_catalog.md'), + ('modelTheoryDocumentTerm', 'Model Theory', '(value)', 'Return a structured explanation of a term and related assumptions.', 'professional_function_catalog.md'), + ('modelTheoryEnumerateFormula', 'Model Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a formula.', 'professional_function_catalog.md'), + ('modelTheoryEnumerateLanguage', 'Model Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a language.', 'professional_function_catalog.md'), + ('modelTheoryEnumerateModel', 'Model Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a model.', 'professional_function_catalog.md'), + ('modelTheoryEnumerateStructure', 'Model Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a structure.', 'professional_function_catalog.md'), + ('modelTheoryEnumerateTerm', 'Model Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a term.', 'professional_function_catalog.md'), + ('modelTheoryEstimateFormula', 'Model Theory', '(value, samples=None)', 'Estimate a formula property from finite samples or approximations.', 'professional_function_catalog.md'), + ('modelTheoryEstimateLanguage', 'Model Theory', '(value, samples=None)', 'Estimate a language property from finite samples or approximations.', 'professional_function_catalog.md'), + ('modelTheoryEstimateModel', 'Model Theory', '(value, samples=None)', 'Estimate a model property from finite samples or approximations.', 'professional_function_catalog.md'), + ('modelTheoryEstimateStructure', 'Model Theory', '(value, samples=None)', 'Estimate a structure property from finite samples or approximations.', 'professional_function_catalog.md'), + ('modelTheoryEstimateTerm', 'Model Theory', '(value, samples=None)', 'Estimate a term property from finite samples or approximations.', 'professional_function_catalog.md'), + ('modelTheoryEvaluateFormula', 'Model Theory', '(value, point=None)', 'Evaluate a formula at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('modelTheoryEvaluateLanguage', 'Model Theory', '(value, point=None)', 'Evaluate a language at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('modelTheoryEvaluateModel', 'Model Theory', '(value, point=None)', 'Evaluate a model at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('modelTheoryEvaluateStructure', 'Model Theory', '(value, point=None)', 'Evaluate a structure at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('modelTheoryEvaluateTerm', 'Model Theory', '(value, point=None)', 'Evaluate a term at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('modelTheoryFormatFormula', 'Model Theory', '(value)', 'Format a formula for deterministic user-facing output.', 'professional_function_catalog.md'), + ('modelTheoryFormatLanguage', 'Model Theory', '(value)', 'Format a language for deterministic user-facing output.', 'professional_function_catalog.md'), + ('modelTheoryFormatModel', 'Model Theory', '(value)', 'Format a model for deterministic user-facing output.', 'professional_function_catalog.md'), + ('modelTheoryFormatStructure', 'Model Theory', '(value)', 'Format a structure for deterministic user-facing output.', 'professional_function_catalog.md'), + ('modelTheoryFormatTerm', 'Model Theory', '(value)', 'Format a term for deterministic user-facing output.', 'professional_function_catalog.md'), + ('modelTheoryGenerateExampleFormula', 'Model Theory', '(size=3)', 'Generate a small documented example of a formula.', 'professional_function_catalog.md'), + ('modelTheoryGenerateExampleLanguage', 'Model Theory', '(size=3)', 'Generate a small documented example of a language.', 'professional_function_catalog.md'), + ('modelTheoryGenerateExampleModel', 'Model Theory', '(size=3)', 'Generate a small documented example of a model.', 'professional_function_catalog.md'), + ('modelTheoryGenerateExampleStructure', 'Model Theory', '(size=3)', 'Generate a small documented example of a structure.', 'professional_function_catalog.md'), + ('modelTheoryGenerateExampleTerm', 'Model Theory', '(size=3)', 'Generate a small documented example of a term.', 'professional_function_catalog.md'), + ('modelTheoryNormalizeFormula', 'Model Theory', '(value)', 'Normalize a formula into the standard Model Theory representation.', 'professional_function_catalog.md'), + ('modelTheoryNormalizeLanguage', 'Model Theory', '(value)', 'Normalize a language into the standard Model Theory representation.', 'professional_function_catalog.md'), + ('modelTheoryNormalizeModel', 'Model Theory', '(value)', 'Normalize a model into the standard Model Theory representation.', 'professional_function_catalog.md'), + ('modelTheoryNormalizeStructure', 'Model Theory', '(value)', 'Normalize a structure into the standard Model Theory representation.', 'professional_function_catalog.md'), + ('modelTheoryNormalizeTerm', 'Model Theory', '(value)', 'Normalize a term into the standard Model Theory representation.', 'professional_function_catalog.md'), + ('modelTheoryParseFormula', 'Model Theory', '(text)', 'Parse a text or structured value into a formula.', 'professional_function_catalog.md'), + ('modelTheoryParseLanguage', 'Model Theory', '(text)', 'Parse a text or structured value into a language.', 'professional_function_catalog.md'), + ('modelTheoryParseModel', 'Model Theory', '(text)', 'Parse a text or structured value into a model.', 'professional_function_catalog.md'), + ('modelTheoryParseStructure', 'Model Theory', '(text)', 'Parse a text or structured value into a structure.', 'professional_function_catalog.md'), + ('modelTheoryParseTerm', 'Model Theory', '(text)', 'Parse a text or structured value into a term.', 'professional_function_catalog.md'), + ('modelTheorySimplifyFormula', 'Model Theory', '(value)', 'Simplify a formula without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('modelTheorySimplifyLanguage', 'Model Theory', '(value)', 'Simplify a language without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('modelTheorySimplifyModel', 'Model Theory', '(value)', 'Simplify a model without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('modelTheorySimplifyStructure', 'Model Theory', '(value)', 'Simplify a structure without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('modelTheorySimplifyTerm', 'Model Theory', '(value)', 'Simplify a term without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('modelTheoryTestEquivalenceFormula', 'Model Theory', '(left, right)', 'Test whether two formula values are equivalent in Model Theory.', 'professional_function_catalog.md'), + ('modelTheoryTestEquivalenceLanguage', 'Model Theory', '(left, right)', 'Test whether two language values are equivalent in Model Theory.', 'professional_function_catalog.md'), + ('modelTheoryTestEquivalenceModel', 'Model Theory', '(left, right)', 'Test whether two model values are equivalent in Model Theory.', 'professional_function_catalog.md'), + ('modelTheoryTestEquivalenceStructure', 'Model Theory', '(left, right)', 'Test whether two structure values are equivalent in Model Theory.', 'professional_function_catalog.md'), + ('modelTheoryTestEquivalenceTerm', 'Model Theory', '(left, right)', 'Test whether two term values are equivalent in Model Theory.', 'professional_function_catalog.md'), + ('modelTheoryTransformFormula', 'Model Theory', '(value, mapping)', 'Transform a formula through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('modelTheoryTransformLanguage', 'Model Theory', '(value, mapping)', 'Transform a language through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('modelTheoryTransformModel', 'Model Theory', '(value, mapping)', 'Transform a model through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('modelTheoryTransformStructure', 'Model Theory', '(value, mapping)', 'Transform a structure through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('modelTheoryTransformTerm', 'Model Theory', '(value, mapping)', 'Transform a term through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('modelTheoryValidateFormula', 'Model Theory', '(value)', 'Validate the formula representation and domain rules for Model Theory.', 'professional_function_catalog.md'), + ('modelTheoryValidateLanguage', 'Model Theory', '(value)', 'Validate the language representation and domain rules for Model Theory.', 'professional_function_catalog.md'), + ('modelTheoryValidateModel', 'Model Theory', '(value)', 'Validate the model representation and domain rules for Model Theory.', 'professional_function_catalog.md'), + ('modelTheoryValidateStructure', 'Model Theory', '(value)', 'Validate the structure representation and domain rules for Model Theory.', 'professional_function_catalog.md'), + ('modelTheoryValidateTerm', 'Model Theory', '(value)', 'Validate the term representation and domain rules for Model Theory.', 'professional_function_catalog.md'), + ('satisfiesAtomicFormula', 'Model Theory', '(formula, structure, assignment)', 'Planned roadmap function for Model Theory from upcoming.md.', 'upcoming.md'), + ('satisfiesFormula', 'Model Theory', '(formula, structure, assignment)', 'Planned roadmap function for Model Theory from upcoming.md.', 'upcoming.md'), + ('structure', 'Model Theory', '(domain, functions, relations, constants)', 'Planned roadmap function for Model Theory from upcoming.md.', 'upcoming.md'), + ('theoryModels', 'Model Theory', '(theory, candidateStructures)', 'Planned roadmap function for Model Theory from upcoming.md.', 'upcoming.md'), + ('curl', 'Multivariable and Vector Calculus', '(vectorField, point)', 'Planned roadmap function for Multivariable and Vector Calculus from upcoming.md.', 'upcoming.md'), + ('directionalDerivative', 'Multivariable and Vector Calculus', '(f, point, direction)', 'Planned roadmap function for Multivariable and Vector Calculus from upcoming.md.', 'upcoming.md'), + ('divergence', 'Multivariable and Vector Calculus', '(vectorField, point)', 'Planned roadmap function for Multivariable and Vector Calculus from upcoming.md.', 'upcoming.md'), + ('gradient', 'Multivariable and Vector Calculus', '(f, point)', 'Planned roadmap function for Multivariable and Vector Calculus from upcoming.md.', 'upcoming.md'), + ('hessian', 'Multivariable and Vector Calculus', '(f, point)', 'Planned roadmap function for Multivariable and Vector Calculus from upcoming.md.', 'upcoming.md'), + ('jacobian', 'Multivariable and Vector Calculus', '(functions, point)', 'Planned roadmap function for Multivariable and Vector Calculus from upcoming.md.', 'upcoming.md'), + ('lineIntegral', 'Multivariable and Vector Calculus', '(vectorField, pathPoints)', 'Planned roadmap function for Multivariable and Vector Calculus from upcoming.md.', 'upcoming.md'), + ('multivariableAndVectorCalculusApproximateGradientModel', 'Multivariable and Vector Calculus', '(value, tolerance=1e-9)', 'Approximate a gradient model with explicit tolerance controls.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusApproximateJacobian', 'Multivariable and Vector Calculus', '(value, tolerance=1e-9)', 'Approximate a jacobian with explicit tolerance controls.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusApproximateMultivariableFunction', 'Multivariable and Vector Calculus', '(value, tolerance=1e-9)', 'Approximate a multivariable function with explicit tolerance controls.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusApproximateSurfaceIntegral', 'Multivariable and Vector Calculus', '(value, tolerance=1e-9)', 'Approximate a surface integral with explicit tolerance controls.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusApproximateVectorField', 'Multivariable and Vector Calculus', '(value, tolerance=1e-9)', 'Approximate a vector field with explicit tolerance controls.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusCanonicalizeGradientModel', 'Multivariable and Vector Calculus', '(value)', 'Canonicalize a gradient model so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusCanonicalizeJacobian', 'Multivariable and Vector Calculus', '(value)', 'Canonicalize a jacobian so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusCanonicalizeMultivariableFunction', 'Multivariable and Vector Calculus', '(value)', 'Canonicalize a multivariable function so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusCanonicalizeSurfaceIntegral', 'Multivariable and Vector Calculus', '(value)', 'Canonicalize a surface integral so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusCanonicalizeVectorField', 'Multivariable and Vector Calculus', '(value)', 'Canonicalize a vector field so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusClassifyGradientModel', 'Multivariable and Vector Calculus', '(value)', 'Classify a gradient model by its standard Multivariable and Vector Calculus invariants.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusClassifyJacobian', 'Multivariable and Vector Calculus', '(value)', 'Classify a jacobian by its standard Multivariable and Vector Calculus invariants.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusClassifyMultivariableFunction', 'Multivariable and Vector Calculus', '(value)', 'Classify a multivariable function by its standard Multivariable and Vector Calculus invariants.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusClassifySurfaceIntegral', 'Multivariable and Vector Calculus', '(value)', 'Classify a surface integral by its standard Multivariable and Vector Calculus invariants.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusClassifyVectorField', 'Multivariable and Vector Calculus', '(value)', 'Classify a vector field by its standard Multivariable and Vector Calculus invariants.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusCombineGradientModel', 'Multivariable and Vector Calculus', '(left, right)', 'Combine two gradient model values with the natural operation for Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusCombineJacobian', 'Multivariable and Vector Calculus', '(left, right)', 'Combine two jacobian values with the natural operation for Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusCombineMultivariableFunction', 'Multivariable and Vector Calculus', '(left, right)', 'Combine two multivariable function values with the natural operation for Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusCombineSurfaceIntegral', 'Multivariable and Vector Calculus', '(left, right)', 'Combine two surface integral values with the natural operation for Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusCombineVectorField', 'Multivariable and Vector Calculus', '(left, right)', 'Combine two vector field values with the natural operation for Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusCompareGradientModel', 'Multivariable and Vector Calculus', '(left, right)', 'Compare two gradient model values under the conventions of Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusCompareJacobian', 'Multivariable and Vector Calculus', '(left, right)', 'Compare two jacobian values under the conventions of Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusCompareMultivariableFunction', 'Multivariable and Vector Calculus', '(left, right)', 'Compare two multivariable function values under the conventions of Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusCompareSurfaceIntegral', 'Multivariable and Vector Calculus', '(left, right)', 'Compare two surface integral values under the conventions of Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusCompareVectorField', 'Multivariable and Vector Calculus', '(left, right)', 'Compare two vector field values under the conventions of Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusComputeGradientModel', 'Multivariable and Vector Calculus', '(value)', 'Compute the central numerical or symbolic data of a gradient model.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusComputeJacobian', 'Multivariable and Vector Calculus', '(value)', 'Compute the central numerical or symbolic data of a jacobian.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusComputeMultivariableFunction', 'Multivariable and Vector Calculus', '(value)', 'Compute the central numerical or symbolic data of a multivariable function.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusComputeSurfaceIntegral', 'Multivariable and Vector Calculus', '(value)', 'Compute the central numerical or symbolic data of a surface integral.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusComputeVectorField', 'Multivariable and Vector Calculus', '(value)', 'Compute the central numerical or symbolic data of a vector field.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusConstructGradientModel', 'Multivariable and Vector Calculus', '(*args)', 'Construct a gradient model from explicit inputs for Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusConstructJacobian', 'Multivariable and Vector Calculus', '(*args)', 'Construct a jacobian from explicit inputs for Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusConstructMultivariableFunction', 'Multivariable and Vector Calculus', '(*args)', 'Construct a multivariable function from explicit inputs for Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusConstructSurfaceIntegral', 'Multivariable and Vector Calculus', '(*args)', 'Construct a surface integral from explicit inputs for Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusConstructVectorField', 'Multivariable and Vector Calculus', '(*args)', 'Construct a vector field from explicit inputs for Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusDecomposeGradientModel', 'Multivariable and Vector Calculus', '(value)', 'Decompose a gradient model into simpler or canonical components.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusDecomposeJacobian', 'Multivariable and Vector Calculus', '(value)', 'Decompose a jacobian into simpler or canonical components.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusDecomposeMultivariableFunction', 'Multivariable and Vector Calculus', '(value)', 'Decompose a multivariable function into simpler or canonical components.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusDecomposeSurfaceIntegral', 'Multivariable and Vector Calculus', '(value)', 'Decompose a surface integral into simpler or canonical components.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusDecomposeVectorField', 'Multivariable and Vector Calculus', '(value)', 'Decompose a vector field into simpler or canonical components.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusDocumentGradientModel', 'Multivariable and Vector Calculus', '(value)', 'Return a structured explanation of a gradient model and related assumptions.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusDocumentJacobian', 'Multivariable and Vector Calculus', '(value)', 'Return a structured explanation of a jacobian and related assumptions.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusDocumentMultivariableFunction', 'Multivariable and Vector Calculus', '(value)', 'Return a structured explanation of a multivariable function and related assumptions.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusDocumentSurfaceIntegral', 'Multivariable and Vector Calculus', '(value)', 'Return a structured explanation of a surface integral and related assumptions.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusDocumentVectorField', 'Multivariable and Vector Calculus', '(value)', 'Return a structured explanation of a vector field and related assumptions.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusEnumerateGradientModel', 'Multivariable and Vector Calculus', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a gradient model.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusEnumerateJacobian', 'Multivariable and Vector Calculus', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a jacobian.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusEnumerateMultivariableFunction', 'Multivariable and Vector Calculus', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a multivariable function.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusEnumerateSurfaceIntegral', 'Multivariable and Vector Calculus', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a surface integral.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusEnumerateVectorField', 'Multivariable and Vector Calculus', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a vector field.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusEstimateGradientModel', 'Multivariable and Vector Calculus', '(value, samples=None)', 'Estimate a gradient model property from finite samples or approximations.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusEstimateJacobian', 'Multivariable and Vector Calculus', '(value, samples=None)', 'Estimate a jacobian property from finite samples or approximations.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusEstimateMultivariableFunction', 'Multivariable and Vector Calculus', '(value, samples=None)', 'Estimate a multivariable function property from finite samples or approximations.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusEstimateSurfaceIntegral', 'Multivariable and Vector Calculus', '(value, samples=None)', 'Estimate a surface integral property from finite samples or approximations.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusEstimateVectorField', 'Multivariable and Vector Calculus', '(value, samples=None)', 'Estimate a vector field property from finite samples or approximations.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusEvaluateGradientModel', 'Multivariable and Vector Calculus', '(value, point=None)', 'Evaluate a gradient model at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusEvaluateJacobian', 'Multivariable and Vector Calculus', '(value, point=None)', 'Evaluate a jacobian at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusEvaluateMultivariableFunction', 'Multivariable and Vector Calculus', '(value, point=None)', 'Evaluate a multivariable function at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusEvaluateSurfaceIntegral', 'Multivariable and Vector Calculus', '(value, point=None)', 'Evaluate a surface integral at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusEvaluateVectorField', 'Multivariable and Vector Calculus', '(value, point=None)', 'Evaluate a vector field at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusFormatGradientModel', 'Multivariable and Vector Calculus', '(value)', 'Format a gradient model for deterministic user-facing output.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusFormatJacobian', 'Multivariable and Vector Calculus', '(value)', 'Format a jacobian for deterministic user-facing output.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusFormatMultivariableFunction', 'Multivariable and Vector Calculus', '(value)', 'Format a multivariable function for deterministic user-facing output.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusFormatSurfaceIntegral', 'Multivariable and Vector Calculus', '(value)', 'Format a surface integral for deterministic user-facing output.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusFormatVectorField', 'Multivariable and Vector Calculus', '(value)', 'Format a vector field for deterministic user-facing output.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusGenerateExampleGradientModel', 'Multivariable and Vector Calculus', '(size=3)', 'Generate a small documented example of a gradient model.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusGenerateExampleJacobian', 'Multivariable and Vector Calculus', '(size=3)', 'Generate a small documented example of a jacobian.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusGenerateExampleMultivariableFunction', 'Multivariable and Vector Calculus', '(size=3)', 'Generate a small documented example of a multivariable function.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusGenerateExampleSurfaceIntegral', 'Multivariable and Vector Calculus', '(size=3)', 'Generate a small documented example of a surface integral.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusGenerateExampleVectorField', 'Multivariable and Vector Calculus', '(size=3)', 'Generate a small documented example of a vector field.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusNormalizeGradientModel', 'Multivariable and Vector Calculus', '(value)', 'Normalize a gradient model into the standard Multivariable and Vector Calculus representation.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusNormalizeJacobian', 'Multivariable and Vector Calculus', '(value)', 'Normalize a jacobian into the standard Multivariable and Vector Calculus representation.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusNormalizeMultivariableFunction', 'Multivariable and Vector Calculus', '(value)', 'Normalize a multivariable function into the standard Multivariable and Vector Calculus representation.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusNormalizeSurfaceIntegral', 'Multivariable and Vector Calculus', '(value)', 'Normalize a surface integral into the standard Multivariable and Vector Calculus representation.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusNormalizeVectorField', 'Multivariable and Vector Calculus', '(value)', 'Normalize a vector field into the standard Multivariable and Vector Calculus representation.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusParseGradientModel', 'Multivariable and Vector Calculus', '(text)', 'Parse a text or structured value into a gradient model.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusParseJacobian', 'Multivariable and Vector Calculus', '(text)', 'Parse a text or structured value into a jacobian.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusParseMultivariableFunction', 'Multivariable and Vector Calculus', '(text)', 'Parse a text or structured value into a multivariable function.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusParseSurfaceIntegral', 'Multivariable and Vector Calculus', '(text)', 'Parse a text or structured value into a surface integral.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusParseVectorField', 'Multivariable and Vector Calculus', '(text)', 'Parse a text or structured value into a vector field.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusSimplifyGradientModel', 'Multivariable and Vector Calculus', '(value)', 'Simplify a gradient model without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusSimplifyJacobian', 'Multivariable and Vector Calculus', '(value)', 'Simplify a jacobian without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusSimplifyMultivariableFunction', 'Multivariable and Vector Calculus', '(value)', 'Simplify a multivariable function without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusSimplifySurfaceIntegral', 'Multivariable and Vector Calculus', '(value)', 'Simplify a surface integral without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusSimplifyVectorField', 'Multivariable and Vector Calculus', '(value)', 'Simplify a vector field without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusTestEquivalenceGradientModel', 'Multivariable and Vector Calculus', '(left, right)', 'Test whether two gradient model values are equivalent in Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusTestEquivalenceJacobian', 'Multivariable and Vector Calculus', '(left, right)', 'Test whether two jacobian values are equivalent in Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusTestEquivalenceMultivariableFunction', 'Multivariable and Vector Calculus', '(left, right)', 'Test whether two multivariable function values are equivalent in Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusTestEquivalenceSurfaceIntegral', 'Multivariable and Vector Calculus', '(left, right)', 'Test whether two surface integral values are equivalent in Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusTestEquivalenceVectorField', 'Multivariable and Vector Calculus', '(left, right)', 'Test whether two vector field values are equivalent in Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusTransformGradientModel', 'Multivariable and Vector Calculus', '(value, mapping)', 'Transform a gradient model through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusTransformJacobian', 'Multivariable and Vector Calculus', '(value, mapping)', 'Transform a jacobian through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusTransformMultivariableFunction', 'Multivariable and Vector Calculus', '(value, mapping)', 'Transform a multivariable function through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusTransformSurfaceIntegral', 'Multivariable and Vector Calculus', '(value, mapping)', 'Transform a surface integral through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusTransformVectorField', 'Multivariable and Vector Calculus', '(value, mapping)', 'Transform a vector field through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusValidateGradientModel', 'Multivariable and Vector Calculus', '(value)', 'Validate the gradient model representation and domain rules for Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusValidateJacobian', 'Multivariable and Vector Calculus', '(value)', 'Validate the jacobian representation and domain rules for Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusValidateMultivariableFunction', 'Multivariable and Vector Calculus', '(value)', 'Validate the multivariable function representation and domain rules for Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusValidateSurfaceIntegral', 'Multivariable and Vector Calculus', '(value)', 'Validate the surface integral representation and domain rules for Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('multivariableAndVectorCalculusValidateVectorField', 'Multivariable and Vector Calculus', '(value)', 'Validate the vector field representation and domain rules for Multivariable and Vector Calculus.', 'professional_function_catalog.md'), + ('partialDerivative', 'Multivariable and Vector Calculus', '(f, point, variableIndex)', 'Planned roadmap function for Multivariable and Vector Calculus from upcoming.md.', 'upcoming.md'), + ('cartesianPower', 'Naive Set Theory', '(set, n)', 'Planned roadmap function for Naive Set Theory from upcoming.md.', 'upcoming.md'), + ('isBijective', 'Naive Set Theory', '(mapping, codomain)', 'Planned roadmap function for Naive Set Theory from upcoming.md.', 'upcoming.md'), + ('isEquivalenceRelation', 'Naive Set Theory', '(relation, set)', 'Planned roadmap function for Naive Set Theory from upcoming.md.', 'upcoming.md'), + ('isFunctionRelation', 'Naive Set Theory', '(relation, domain, codomain)', 'Planned roadmap function for Naive Set Theory from upcoming.md.', 'upcoming.md'), + ('isInjective', 'Naive Set Theory', '(mapping)', 'Planned roadmap function for Naive Set Theory from upcoming.md.', 'upcoming.md'), + ('isRelation', 'Naive Set Theory', '(relation, set1, set2)', 'Planned roadmap function for Naive Set Theory from upcoming.md.', 'upcoming.md'), + ('isSurjective', 'Naive Set Theory', '(mapping, codomain)', 'Planned roadmap function for Naive Set Theory from upcoming.md.', 'upcoming.md'), + ('naiveSetTheoryApproximateFiniteSet', 'Naive Set Theory', '(value, tolerance=1e-9)', 'Approximate a finite set with explicit tolerance controls.', 'professional_function_catalog.md'), + ('naiveSetTheoryApproximateMapping', 'Naive Set Theory', '(value, tolerance=1e-9)', 'Approximate a mapping with explicit tolerance controls.', 'professional_function_catalog.md'), + ('naiveSetTheoryApproximatePartition', 'Naive Set Theory', '(value, tolerance=1e-9)', 'Approximate a partition with explicit tolerance controls.', 'professional_function_catalog.md'), + ('naiveSetTheoryApproximateRelation', 'Naive Set Theory', '(value, tolerance=1e-9)', 'Approximate a relation with explicit tolerance controls.', 'professional_function_catalog.md'), + ('naiveSetTheoryApproximateSetOperation', 'Naive Set Theory', '(value, tolerance=1e-9)', 'Approximate a set operation with explicit tolerance controls.', 'professional_function_catalog.md'), + ('naiveSetTheoryCanonicalizeFiniteSet', 'Naive Set Theory', '(value)', 'Canonicalize a finite set so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('naiveSetTheoryCanonicalizeMapping', 'Naive Set Theory', '(value)', 'Canonicalize a mapping so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('naiveSetTheoryCanonicalizePartition', 'Naive Set Theory', '(value)', 'Canonicalize a partition so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('naiveSetTheoryCanonicalizeRelation', 'Naive Set Theory', '(value)', 'Canonicalize a relation so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('naiveSetTheoryCanonicalizeSetOperation', 'Naive Set Theory', '(value)', 'Canonicalize a set operation so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('naiveSetTheoryClassifyFiniteSet', 'Naive Set Theory', '(value)', 'Classify a finite set by its standard Naive Set Theory invariants.', 'professional_function_catalog.md'), + ('naiveSetTheoryClassifyMapping', 'Naive Set Theory', '(value)', 'Classify a mapping by its standard Naive Set Theory invariants.', 'professional_function_catalog.md'), + ('naiveSetTheoryClassifyPartition', 'Naive Set Theory', '(value)', 'Classify a partition by its standard Naive Set Theory invariants.', 'professional_function_catalog.md'), + ('naiveSetTheoryClassifyRelation', 'Naive Set Theory', '(value)', 'Classify a relation by its standard Naive Set Theory invariants.', 'professional_function_catalog.md'), + ('naiveSetTheoryClassifySetOperation', 'Naive Set Theory', '(value)', 'Classify a set operation by its standard Naive Set Theory invariants.', 'professional_function_catalog.md'), + ('naiveSetTheoryCombineFiniteSet', 'Naive Set Theory', '(left, right)', 'Combine two finite set values with the natural operation for Naive Set Theory.', 'professional_function_catalog.md'), + ('naiveSetTheoryCombineMapping', 'Naive Set Theory', '(left, right)', 'Combine two mapping values with the natural operation for Naive Set Theory.', 'professional_function_catalog.md'), + ('naiveSetTheoryCombinePartition', 'Naive Set Theory', '(left, right)', 'Combine two partition values with the natural operation for Naive Set Theory.', 'professional_function_catalog.md'), + ('naiveSetTheoryCombineRelation', 'Naive Set Theory', '(left, right)', 'Combine two relation values with the natural operation for Naive Set Theory.', 'professional_function_catalog.md'), + ('naiveSetTheoryCombineSetOperation', 'Naive Set Theory', '(left, right)', 'Combine two set operation values with the natural operation for Naive Set Theory.', 'professional_function_catalog.md'), + ('naiveSetTheoryCompareFiniteSet', 'Naive Set Theory', '(left, right)', 'Compare two finite set values under the conventions of Naive Set Theory.', 'professional_function_catalog.md'), + ('naiveSetTheoryCompareMapping', 'Naive Set Theory', '(left, right)', 'Compare two mapping values under the conventions of Naive Set Theory.', 'professional_function_catalog.md'), + ('naiveSetTheoryComparePartition', 'Naive Set Theory', '(left, right)', 'Compare two partition values under the conventions of Naive Set Theory.', 'professional_function_catalog.md'), + ('naiveSetTheoryCompareRelation', 'Naive Set Theory', '(left, right)', 'Compare two relation values under the conventions of Naive Set Theory.', 'professional_function_catalog.md'), + ('naiveSetTheoryCompareSetOperation', 'Naive Set Theory', '(left, right)', 'Compare two set operation values under the conventions of Naive Set Theory.', 'professional_function_catalog.md'), + ('naiveSetTheoryComputeFiniteSet', 'Naive Set Theory', '(value)', 'Compute the central numerical or symbolic data of a finite set.', 'professional_function_catalog.md'), + ('naiveSetTheoryComputeMapping', 'Naive Set Theory', '(value)', 'Compute the central numerical or symbolic data of a mapping.', 'professional_function_catalog.md'), + ('naiveSetTheoryComputePartition', 'Naive Set Theory', '(value)', 'Compute the central numerical or symbolic data of a partition.', 'professional_function_catalog.md'), + ('naiveSetTheoryComputeRelation', 'Naive Set Theory', '(value)', 'Compute the central numerical or symbolic data of a relation.', 'professional_function_catalog.md'), + ('naiveSetTheoryComputeSetOperation', 'Naive Set Theory', '(value)', 'Compute the central numerical or symbolic data of a set operation.', 'professional_function_catalog.md'), + ('naiveSetTheoryConstructFiniteSet', 'Naive Set Theory', '(*args)', 'Construct a finite set from explicit inputs for Naive Set Theory.', 'professional_function_catalog.md'), + ('naiveSetTheoryConstructMapping', 'Naive Set Theory', '(*args)', 'Construct a mapping from explicit inputs for Naive Set Theory.', 'professional_function_catalog.md'), + ('naiveSetTheoryConstructPartition', 'Naive Set Theory', '(*args)', 'Construct a partition from explicit inputs for Naive Set Theory.', 'professional_function_catalog.md'), + ('naiveSetTheoryConstructRelation', 'Naive Set Theory', '(*args)', 'Construct a relation from explicit inputs for Naive Set Theory.', 'professional_function_catalog.md'), + ('naiveSetTheoryConstructSetOperation', 'Naive Set Theory', '(*args)', 'Construct a set operation from explicit inputs for Naive Set Theory.', 'professional_function_catalog.md'), + ('naiveSetTheoryDecomposeFiniteSet', 'Naive Set Theory', '(value)', 'Decompose a finite set into simpler or canonical components.', 'professional_function_catalog.md'), + ('naiveSetTheoryDecomposeMapping', 'Naive Set Theory', '(value)', 'Decompose a mapping into simpler or canonical components.', 'professional_function_catalog.md'), + ('naiveSetTheoryDecomposePartition', 'Naive Set Theory', '(value)', 'Decompose a partition into simpler or canonical components.', 'professional_function_catalog.md'), + ('naiveSetTheoryDecomposeRelation', 'Naive Set Theory', '(value)', 'Decompose a relation into simpler or canonical components.', 'professional_function_catalog.md'), + ('naiveSetTheoryDecomposeSetOperation', 'Naive Set Theory', '(value)', 'Decompose a set operation into simpler or canonical components.', 'professional_function_catalog.md'), + ('naiveSetTheoryDocumentFiniteSet', 'Naive Set Theory', '(value)', 'Return a structured explanation of a finite set and related assumptions.', 'professional_function_catalog.md'), + ('naiveSetTheoryDocumentMapping', 'Naive Set Theory', '(value)', 'Return a structured explanation of a mapping and related assumptions.', 'professional_function_catalog.md'), + ('naiveSetTheoryDocumentPartition', 'Naive Set Theory', '(value)', 'Return a structured explanation of a partition and related assumptions.', 'professional_function_catalog.md'), + ('naiveSetTheoryDocumentRelation', 'Naive Set Theory', '(value)', 'Return a structured explanation of a relation and related assumptions.', 'professional_function_catalog.md'), + ('naiveSetTheoryDocumentSetOperation', 'Naive Set Theory', '(value)', 'Return a structured explanation of a set operation and related assumptions.', 'professional_function_catalog.md'), + ('naiveSetTheoryEnumerateFiniteSet', 'Naive Set Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a finite set.', 'professional_function_catalog.md'), + ('naiveSetTheoryEnumerateMapping', 'Naive Set Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a mapping.', 'professional_function_catalog.md'), + ('naiveSetTheoryEnumeratePartition', 'Naive Set Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a partition.', 'professional_function_catalog.md'), + ('naiveSetTheoryEnumerateRelation', 'Naive Set Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a relation.', 'professional_function_catalog.md'), + ('naiveSetTheoryEnumerateSetOperation', 'Naive Set Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a set operation.', 'professional_function_catalog.md'), + ('naiveSetTheoryEstimateFiniteSet', 'Naive Set Theory', '(value, samples=None)', 'Estimate a finite set property from finite samples or approximations.', 'professional_function_catalog.md'), + ('naiveSetTheoryEstimateMapping', 'Naive Set Theory', '(value, samples=None)', 'Estimate a mapping property from finite samples or approximations.', 'professional_function_catalog.md'), + ('naiveSetTheoryEstimatePartition', 'Naive Set Theory', '(value, samples=None)', 'Estimate a partition property from finite samples or approximations.', 'professional_function_catalog.md'), + ('naiveSetTheoryEstimateRelation', 'Naive Set Theory', '(value, samples=None)', 'Estimate a relation property from finite samples or approximations.', 'professional_function_catalog.md'), + ('naiveSetTheoryEstimateSetOperation', 'Naive Set Theory', '(value, samples=None)', 'Estimate a set operation property from finite samples or approximations.', 'professional_function_catalog.md'), + ('naiveSetTheoryEvaluateFiniteSet', 'Naive Set Theory', '(value, point=None)', 'Evaluate a finite set at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('naiveSetTheoryEvaluateMapping', 'Naive Set Theory', '(value, point=None)', 'Evaluate a mapping at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('naiveSetTheoryEvaluatePartition', 'Naive Set Theory', '(value, point=None)', 'Evaluate a partition at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('naiveSetTheoryEvaluateRelation', 'Naive Set Theory', '(value, point=None)', 'Evaluate a relation at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('naiveSetTheoryEvaluateSetOperation', 'Naive Set Theory', '(value, point=None)', 'Evaluate a set operation at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('naiveSetTheoryFormatFiniteSet', 'Naive Set Theory', '(value)', 'Format a finite set for deterministic user-facing output.', 'professional_function_catalog.md'), + ('naiveSetTheoryFormatMapping', 'Naive Set Theory', '(value)', 'Format a mapping for deterministic user-facing output.', 'professional_function_catalog.md'), + ('naiveSetTheoryFormatPartition', 'Naive Set Theory', '(value)', 'Format a partition for deterministic user-facing output.', 'professional_function_catalog.md'), + ('naiveSetTheoryFormatRelation', 'Naive Set Theory', '(value)', 'Format a relation for deterministic user-facing output.', 'professional_function_catalog.md'), + ('naiveSetTheoryFormatSetOperation', 'Naive Set Theory', '(value)', 'Format a set operation for deterministic user-facing output.', 'professional_function_catalog.md'), + ('naiveSetTheoryGenerateExampleFiniteSet', 'Naive Set Theory', '(size=3)', 'Generate a small documented example of a finite set.', 'professional_function_catalog.md'), + ('naiveSetTheoryGenerateExampleMapping', 'Naive Set Theory', '(size=3)', 'Generate a small documented example of a mapping.', 'professional_function_catalog.md'), + ('naiveSetTheoryGenerateExamplePartition', 'Naive Set Theory', '(size=3)', 'Generate a small documented example of a partition.', 'professional_function_catalog.md'), + ('naiveSetTheoryGenerateExampleRelation', 'Naive Set Theory', '(size=3)', 'Generate a small documented example of a relation.', 'professional_function_catalog.md'), + ('naiveSetTheoryGenerateExampleSetOperation', 'Naive Set Theory', '(size=3)', 'Generate a small documented example of a set operation.', 'professional_function_catalog.md'), + ('naiveSetTheoryNormalizeFiniteSet', 'Naive Set Theory', '(value)', 'Normalize a finite set into the standard Naive Set Theory representation.', 'professional_function_catalog.md'), + ('naiveSetTheoryNormalizeMapping', 'Naive Set Theory', '(value)', 'Normalize a mapping into the standard Naive Set Theory representation.', 'professional_function_catalog.md'), + ('naiveSetTheoryNormalizePartition', 'Naive Set Theory', '(value)', 'Normalize a partition into the standard Naive Set Theory representation.', 'professional_function_catalog.md'), + ('naiveSetTheoryNormalizeRelation', 'Naive Set Theory', '(value)', 'Normalize a relation into the standard Naive Set Theory representation.', 'professional_function_catalog.md'), + ('naiveSetTheoryNormalizeSetOperation', 'Naive Set Theory', '(value)', 'Normalize a set operation into the standard Naive Set Theory representation.', 'professional_function_catalog.md'), + ('naiveSetTheoryParseFiniteSet', 'Naive Set Theory', '(text)', 'Parse a text or structured value into a finite set.', 'professional_function_catalog.md'), + ('naiveSetTheoryParseMapping', 'Naive Set Theory', '(text)', 'Parse a text or structured value into a mapping.', 'professional_function_catalog.md'), + ('naiveSetTheoryParsePartition', 'Naive Set Theory', '(text)', 'Parse a text or structured value into a partition.', 'professional_function_catalog.md'), + ('naiveSetTheoryParseRelation', 'Naive Set Theory', '(text)', 'Parse a text or structured value into a relation.', 'professional_function_catalog.md'), + ('naiveSetTheoryParseSetOperation', 'Naive Set Theory', '(text)', 'Parse a text or structured value into a set operation.', 'professional_function_catalog.md'), + ('naiveSetTheorySimplifyFiniteSet', 'Naive Set Theory', '(value)', 'Simplify a finite set without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('naiveSetTheorySimplifyMapping', 'Naive Set Theory', '(value)', 'Simplify a mapping without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('naiveSetTheorySimplifyPartition', 'Naive Set Theory', '(value)', 'Simplify a partition without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('naiveSetTheorySimplifyRelation', 'Naive Set Theory', '(value)', 'Simplify a relation without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('naiveSetTheorySimplifySetOperation', 'Naive Set Theory', '(value)', 'Simplify a set operation without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('naiveSetTheoryTestEquivalenceFiniteSet', 'Naive Set Theory', '(left, right)', 'Test whether two finite set values are equivalent in Naive Set Theory.', 'professional_function_catalog.md'), + ('naiveSetTheoryTestEquivalenceMapping', 'Naive Set Theory', '(left, right)', 'Test whether two mapping values are equivalent in Naive Set Theory.', 'professional_function_catalog.md'), + ('naiveSetTheoryTestEquivalencePartition', 'Naive Set Theory', '(left, right)', 'Test whether two partition values are equivalent in Naive Set Theory.', 'professional_function_catalog.md'), + ('naiveSetTheoryTestEquivalenceRelation', 'Naive Set Theory', '(left, right)', 'Test whether two relation values are equivalent in Naive Set Theory.', 'professional_function_catalog.md'), + ('naiveSetTheoryTestEquivalenceSetOperation', 'Naive Set Theory', '(left, right)', 'Test whether two set operation values are equivalent in Naive Set Theory.', 'professional_function_catalog.md'), + ('naiveSetTheoryTransformFiniteSet', 'Naive Set Theory', '(value, mapping)', 'Transform a finite set through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('naiveSetTheoryTransformMapping', 'Naive Set Theory', '(value, mapping)', 'Transform a mapping through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('naiveSetTheoryTransformPartition', 'Naive Set Theory', '(value, mapping)', 'Transform a partition through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('naiveSetTheoryTransformRelation', 'Naive Set Theory', '(value, mapping)', 'Transform a relation through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('naiveSetTheoryTransformSetOperation', 'Naive Set Theory', '(value, mapping)', 'Transform a set operation through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('naiveSetTheoryValidateFiniteSet', 'Naive Set Theory', '(value)', 'Validate the finite set representation and domain rules for Naive Set Theory.', 'professional_function_catalog.md'), + ('naiveSetTheoryValidateMapping', 'Naive Set Theory', '(value)', 'Validate the mapping representation and domain rules for Naive Set Theory.', 'professional_function_catalog.md'), + ('naiveSetTheoryValidatePartition', 'Naive Set Theory', '(value)', 'Validate the partition representation and domain rules for Naive Set Theory.', 'professional_function_catalog.md'), + ('naiveSetTheoryValidateRelation', 'Naive Set Theory', '(value)', 'Validate the relation representation and domain rules for Naive Set Theory.', 'professional_function_catalog.md'), + ('naiveSetTheoryValidateSetOperation', 'Naive Set Theory', '(value)', 'Validate the set operation representation and domain rules for Naive Set Theory.', 'professional_function_catalog.md'), + ('partition', 'Naive Set Theory', '(set, blocks)', 'Planned roadmap function for Naive Set Theory from upcoming.md.', 'upcoming.md'), + ('relationDomain', 'Naive Set Theory', '(relation)', 'Planned roadmap function for Naive Set Theory from upcoming.md.', 'upcoming.md'), + ('relationRange', 'Naive Set Theory', '(relation)', 'Planned roadmap function for Naive Set Theory from upcoming.md.', 'upcoming.md'), + ('setDifference', 'Naive Set Theory', '(set1, set2)', 'Planned roadmap function for Naive Set Theory from upcoming.md.', 'upcoming.md'), + ('centerOfAlgebra', 'Noncommutative Algebra', '(elements, multiply)', 'Planned roadmap function for Noncommutative Algebra from upcoming.md.', 'upcoming.md'), + ('commutatorElement', 'Noncommutative Algebra', '(a, b, multiply, subtract)', 'Planned roadmap function for Noncommutative Algebra from upcoming.md.', 'upcoming.md'), + ('isAssociativeOperation', 'Noncommutative Algebra', '(elements, operation)', 'Planned roadmap function for Noncommutative Algebra from upcoming.md.', 'upcoming.md'), + ('isCommutativeOperation', 'Noncommutative Algebra', '(elements, operation)', 'Planned roadmap function for Noncommutative Algebra from upcoming.md.', 'upcoming.md'), + ('leftIdealGeneratedBy', 'Noncommutative Algebra', '(generators, elements, add, multiply)', 'Planned roadmap function for Noncommutative Algebra from upcoming.md.', 'upcoming.md'), + ('matrixAlgebraBasis', 'Noncommutative Algebra', '(n)', 'Planned roadmap function for Noncommutative Algebra from upcoming.md.', 'upcoming.md'), + ('noncommutativeAlgebraApproximateAlgebraElement', 'Noncommutative Algebra', '(value, tolerance=1e-9)', 'Approximate a algebra element with explicit tolerance controls.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraApproximateCommutator', 'Noncommutative Algebra', '(value, tolerance=1e-9)', 'Approximate a commutator with explicit tolerance controls.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraApproximateLeftIdeal', 'Noncommutative Algebra', '(value, tolerance=1e-9)', 'Approximate a left ideal with explicit tolerance controls.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraApproximateNoncommutativeRing', 'Noncommutative Algebra', '(value, tolerance=1e-9)', 'Approximate a noncommutative ring with explicit tolerance controls.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraApproximateRightIdeal', 'Noncommutative Algebra', '(value, tolerance=1e-9)', 'Approximate a right ideal with explicit tolerance controls.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraCanonicalizeAlgebraElement', 'Noncommutative Algebra', '(value)', 'Canonicalize a algebra element so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraCanonicalizeCommutator', 'Noncommutative Algebra', '(value)', 'Canonicalize a commutator so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraCanonicalizeLeftIdeal', 'Noncommutative Algebra', '(value)', 'Canonicalize a left ideal so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraCanonicalizeNoncommutativeRing', 'Noncommutative Algebra', '(value)', 'Canonicalize a noncommutative ring so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraCanonicalizeRightIdeal', 'Noncommutative Algebra', '(value)', 'Canonicalize a right ideal so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraClassifyAlgebraElement', 'Noncommutative Algebra', '(value)', 'Classify a algebra element by its standard Noncommutative Algebra invariants.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraClassifyCommutator', 'Noncommutative Algebra', '(value)', 'Classify a commutator by its standard Noncommutative Algebra invariants.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraClassifyLeftIdeal', 'Noncommutative Algebra', '(value)', 'Classify a left ideal by its standard Noncommutative Algebra invariants.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraClassifyNoncommutativeRing', 'Noncommutative Algebra', '(value)', 'Classify a noncommutative ring by its standard Noncommutative Algebra invariants.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraClassifyRightIdeal', 'Noncommutative Algebra', '(value)', 'Classify a right ideal by its standard Noncommutative Algebra invariants.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraCombineAlgebraElement', 'Noncommutative Algebra', '(left, right)', 'Combine two algebra element values with the natural operation for Noncommutative Algebra.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraCombineCommutator', 'Noncommutative Algebra', '(left, right)', 'Combine two commutator values with the natural operation for Noncommutative Algebra.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraCombineLeftIdeal', 'Noncommutative Algebra', '(left, right)', 'Combine two left ideal values with the natural operation for Noncommutative Algebra.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraCombineNoncommutativeRing', 'Noncommutative Algebra', '(left, right)', 'Combine two noncommutative ring values with the natural operation for Noncommutative Algebra.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraCombineRightIdeal', 'Noncommutative Algebra', '(left, right)', 'Combine two right ideal values with the natural operation for Noncommutative Algebra.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraCompareAlgebraElement', 'Noncommutative Algebra', '(left, right)', 'Compare two algebra element values under the conventions of Noncommutative Algebra.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraCompareCommutator', 'Noncommutative Algebra', '(left, right)', 'Compare two commutator values under the conventions of Noncommutative Algebra.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraCompareLeftIdeal', 'Noncommutative Algebra', '(left, right)', 'Compare two left ideal values under the conventions of Noncommutative Algebra.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraCompareNoncommutativeRing', 'Noncommutative Algebra', '(left, right)', 'Compare two noncommutative ring values under the conventions of Noncommutative Algebra.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraCompareRightIdeal', 'Noncommutative Algebra', '(left, right)', 'Compare two right ideal values under the conventions of Noncommutative Algebra.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraComputeAlgebraElement', 'Noncommutative Algebra', '(value)', 'Compute the central numerical or symbolic data of a algebra element.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraComputeCommutator', 'Noncommutative Algebra', '(value)', 'Compute the central numerical or symbolic data of a commutator.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraComputeLeftIdeal', 'Noncommutative Algebra', '(value)', 'Compute the central numerical or symbolic data of a left ideal.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraComputeNoncommutativeRing', 'Noncommutative Algebra', '(value)', 'Compute the central numerical or symbolic data of a noncommutative ring.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraComputeRightIdeal', 'Noncommutative Algebra', '(value)', 'Compute the central numerical or symbolic data of a right ideal.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraConstructAlgebraElement', 'Noncommutative Algebra', '(*args)', 'Construct a algebra element from explicit inputs for Noncommutative Algebra.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraConstructCommutator', 'Noncommutative Algebra', '(*args)', 'Construct a commutator from explicit inputs for Noncommutative Algebra.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraConstructLeftIdeal', 'Noncommutative Algebra', '(*args)', 'Construct a left ideal from explicit inputs for Noncommutative Algebra.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraConstructNoncommutativeRing', 'Noncommutative Algebra', '(*args)', 'Construct a noncommutative ring from explicit inputs for Noncommutative Algebra.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraConstructRightIdeal', 'Noncommutative Algebra', '(*args)', 'Construct a right ideal from explicit inputs for Noncommutative Algebra.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraDecomposeAlgebraElement', 'Noncommutative Algebra', '(value)', 'Decompose a algebra element into simpler or canonical components.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraDecomposeCommutator', 'Noncommutative Algebra', '(value)', 'Decompose a commutator into simpler or canonical components.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraDecomposeLeftIdeal', 'Noncommutative Algebra', '(value)', 'Decompose a left ideal into simpler or canonical components.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraDecomposeNoncommutativeRing', 'Noncommutative Algebra', '(value)', 'Decompose a noncommutative ring into simpler or canonical components.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraDecomposeRightIdeal', 'Noncommutative Algebra', '(value)', 'Decompose a right ideal into simpler or canonical components.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraDocumentAlgebraElement', 'Noncommutative Algebra', '(value)', 'Return a structured explanation of a algebra element and related assumptions.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraDocumentCommutator', 'Noncommutative Algebra', '(value)', 'Return a structured explanation of a commutator and related assumptions.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraDocumentLeftIdeal', 'Noncommutative Algebra', '(value)', 'Return a structured explanation of a left ideal and related assumptions.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraDocumentNoncommutativeRing', 'Noncommutative Algebra', '(value)', 'Return a structured explanation of a noncommutative ring and related assumptions.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraDocumentRightIdeal', 'Noncommutative Algebra', '(value)', 'Return a structured explanation of a right ideal and related assumptions.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraEnumerateAlgebraElement', 'Noncommutative Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a algebra element.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraEnumerateCommutator', 'Noncommutative Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a commutator.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraEnumerateLeftIdeal', 'Noncommutative Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a left ideal.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraEnumerateNoncommutativeRing', 'Noncommutative Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a noncommutative ring.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraEnumerateRightIdeal', 'Noncommutative Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a right ideal.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraEstimateAlgebraElement', 'Noncommutative Algebra', '(value, samples=None)', 'Estimate a algebra element property from finite samples or approximations.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraEstimateCommutator', 'Noncommutative Algebra', '(value, samples=None)', 'Estimate a commutator property from finite samples or approximations.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraEstimateLeftIdeal', 'Noncommutative Algebra', '(value, samples=None)', 'Estimate a left ideal property from finite samples or approximations.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraEstimateNoncommutativeRing', 'Noncommutative Algebra', '(value, samples=None)', 'Estimate a noncommutative ring property from finite samples or approximations.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraEstimateRightIdeal', 'Noncommutative Algebra', '(value, samples=None)', 'Estimate a right ideal property from finite samples or approximations.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraEvaluateAlgebraElement', 'Noncommutative Algebra', '(value, point=None)', 'Evaluate a algebra element at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraEvaluateCommutator', 'Noncommutative Algebra', '(value, point=None)', 'Evaluate a commutator at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraEvaluateLeftIdeal', 'Noncommutative Algebra', '(value, point=None)', 'Evaluate a left ideal at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraEvaluateNoncommutativeRing', 'Noncommutative Algebra', '(value, point=None)', 'Evaluate a noncommutative ring at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraEvaluateRightIdeal', 'Noncommutative Algebra', '(value, point=None)', 'Evaluate a right ideal at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraFormatAlgebraElement', 'Noncommutative Algebra', '(value)', 'Format a algebra element for deterministic user-facing output.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraFormatCommutator', 'Noncommutative Algebra', '(value)', 'Format a commutator for deterministic user-facing output.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraFormatLeftIdeal', 'Noncommutative Algebra', '(value)', 'Format a left ideal for deterministic user-facing output.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraFormatNoncommutativeRing', 'Noncommutative Algebra', '(value)', 'Format a noncommutative ring for deterministic user-facing output.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraFormatRightIdeal', 'Noncommutative Algebra', '(value)', 'Format a right ideal for deterministic user-facing output.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraGenerateExampleAlgebraElement', 'Noncommutative Algebra', '(size=3)', 'Generate a small documented example of a algebra element.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraGenerateExampleCommutator', 'Noncommutative Algebra', '(size=3)', 'Generate a small documented example of a commutator.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraGenerateExampleLeftIdeal', 'Noncommutative Algebra', '(size=3)', 'Generate a small documented example of a left ideal.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraGenerateExampleNoncommutativeRing', 'Noncommutative Algebra', '(size=3)', 'Generate a small documented example of a noncommutative ring.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraGenerateExampleRightIdeal', 'Noncommutative Algebra', '(size=3)', 'Generate a small documented example of a right ideal.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraNormalizeAlgebraElement', 'Noncommutative Algebra', '(value)', 'Normalize a algebra element into the standard Noncommutative Algebra representation.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraNormalizeCommutator', 'Noncommutative Algebra', '(value)', 'Normalize a commutator into the standard Noncommutative Algebra representation.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraNormalizeLeftIdeal', 'Noncommutative Algebra', '(value)', 'Normalize a left ideal into the standard Noncommutative Algebra representation.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraNormalizeNoncommutativeRing', 'Noncommutative Algebra', '(value)', 'Normalize a noncommutative ring into the standard Noncommutative Algebra representation.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraNormalizeRightIdeal', 'Noncommutative Algebra', '(value)', 'Normalize a right ideal into the standard Noncommutative Algebra representation.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraParseAlgebraElement', 'Noncommutative Algebra', '(text)', 'Parse a text or structured value into a algebra element.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraParseCommutator', 'Noncommutative Algebra', '(text)', 'Parse a text or structured value into a commutator.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraParseLeftIdeal', 'Noncommutative Algebra', '(text)', 'Parse a text or structured value into a left ideal.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraParseNoncommutativeRing', 'Noncommutative Algebra', '(text)', 'Parse a text or structured value into a noncommutative ring.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraParseRightIdeal', 'Noncommutative Algebra', '(text)', 'Parse a text or structured value into a right ideal.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraSimplifyAlgebraElement', 'Noncommutative Algebra', '(value)', 'Simplify a algebra element without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraSimplifyCommutator', 'Noncommutative Algebra', '(value)', 'Simplify a commutator without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraSimplifyLeftIdeal', 'Noncommutative Algebra', '(value)', 'Simplify a left ideal without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraSimplifyNoncommutativeRing', 'Noncommutative Algebra', '(value)', 'Simplify a noncommutative ring without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraSimplifyRightIdeal', 'Noncommutative Algebra', '(value)', 'Simplify a right ideal without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraTestEquivalenceAlgebraElement', 'Noncommutative Algebra', '(left, right)', 'Test whether two algebra element values are equivalent in Noncommutative Algebra.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraTestEquivalenceCommutator', 'Noncommutative Algebra', '(left, right)', 'Test whether two commutator values are equivalent in Noncommutative Algebra.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraTestEquivalenceLeftIdeal', 'Noncommutative Algebra', '(left, right)', 'Test whether two left ideal values are equivalent in Noncommutative Algebra.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraTestEquivalenceNoncommutativeRing', 'Noncommutative Algebra', '(left, right)', 'Test whether two noncommutative ring values are equivalent in Noncommutative Algebra.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraTestEquivalenceRightIdeal', 'Noncommutative Algebra', '(left, right)', 'Test whether two right ideal values are equivalent in Noncommutative Algebra.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraTransformAlgebraElement', 'Noncommutative Algebra', '(value, mapping)', 'Transform a algebra element through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraTransformCommutator', 'Noncommutative Algebra', '(value, mapping)', 'Transform a commutator through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraTransformLeftIdeal', 'Noncommutative Algebra', '(value, mapping)', 'Transform a left ideal through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraTransformNoncommutativeRing', 'Noncommutative Algebra', '(value, mapping)', 'Transform a noncommutative ring through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraTransformRightIdeal', 'Noncommutative Algebra', '(value, mapping)', 'Transform a right ideal through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraValidateAlgebraElement', 'Noncommutative Algebra', '(value)', 'Validate the algebra element representation and domain rules for Noncommutative Algebra.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraValidateCommutator', 'Noncommutative Algebra', '(value)', 'Validate the commutator representation and domain rules for Noncommutative Algebra.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraValidateLeftIdeal', 'Noncommutative Algebra', '(value)', 'Validate the left ideal representation and domain rules for Noncommutative Algebra.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraValidateNoncommutativeRing', 'Noncommutative Algebra', '(value)', 'Validate the noncommutative ring representation and domain rules for Noncommutative Algebra.', 'professional_function_catalog.md'), + ('noncommutativeAlgebraValidateRightIdeal', 'Noncommutative Algebra', '(value)', 'Validate the right ideal representation and domain rules for Noncommutative Algebra.', 'professional_function_catalog.md'), + ('quaternionMultiply', 'Noncommutative Algebra', '(q1, q2)', 'Planned roadmap function for Noncommutative Algebra from upcoming.md.', 'upcoming.md'), + ('rightIdealGeneratedBy', 'Noncommutative Algebra', '(generators, elements, add, multiply)', 'Planned roadmap function for Noncommutative Algebra from upcoming.md.', 'upcoming.md'), + ('chineseRemainder', 'Number Theory', '(remainders, moduli)', 'Planned roadmap function for Number Theory from upcoming.md.', 'upcoming.md'), + ('divisors', 'Number Theory', '(n)', 'Planned roadmap function for Number Theory from upcoming.md.', 'upcoming.md'), + ('eulerTotient', 'Number Theory', '(n)', 'Planned roadmap function for Number Theory from upcoming.md.', 'upcoming.md'), + ('extendedGcd', 'Number Theory', '(a, b)', 'Planned roadmap function for Number Theory from upcoming.md.', 'upcoming.md'), + ('gcd', 'Number Theory', '(a, b)', 'Planned roadmap function for Number Theory from upcoming.md.', 'upcoming.md'), + ('isCoprime', 'Number Theory', '(a, b)', 'Planned roadmap function for Number Theory from upcoming.md.', 'upcoming.md'), + ('isPerfectNumber', 'Number Theory', '(n)', 'Planned roadmap function for Number Theory from upcoming.md.', 'upcoming.md'), + ('lcm', 'Number Theory', '(a, b)', 'Planned roadmap function for Number Theory from upcoming.md.', 'upcoming.md'), + ('mobiusFunction', 'Number Theory', '(n)', 'Planned roadmap function for Number Theory from upcoming.md.', 'upcoming.md'), + ('modInverse', 'Number Theory', '(a, modulus)', 'Planned roadmap function for Number Theory from upcoming.md.', 'upcoming.md'), + ('modularExponent', 'Number Theory', '(base, exponent, modulus)', 'Planned roadmap function for Number Theory from upcoming.md.', 'upcoming.md'), + ('numberTheoryApproximateArithmeticFunction', 'Number Theory', '(value, tolerance=1e-9)', 'Approximate a arithmetic function with explicit tolerance controls.', 'professional_function_catalog.md'), + ('numberTheoryApproximateDivisorSet', 'Number Theory', '(value, tolerance=1e-9)', 'Approximate a divisor set with explicit tolerance controls.', 'professional_function_catalog.md'), + ('numberTheoryApproximateInteger', 'Number Theory', '(value, tolerance=1e-9)', 'Approximate a integer with explicit tolerance controls.', 'professional_function_catalog.md'), + ('numberTheoryApproximateModularSystem', 'Number Theory', '(value, tolerance=1e-9)', 'Approximate a modular system with explicit tolerance controls.', 'professional_function_catalog.md'), + ('numberTheoryApproximatePrimeStructure', 'Number Theory', '(value, tolerance=1e-9)', 'Approximate a prime structure with explicit tolerance controls.', 'professional_function_catalog.md'), + ('numberTheoryCanonicalizeArithmeticFunction', 'Number Theory', '(value)', 'Canonicalize a arithmetic function so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('numberTheoryCanonicalizeDivisorSet', 'Number Theory', '(value)', 'Canonicalize a divisor set so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('numberTheoryCanonicalizeInteger', 'Number Theory', '(value)', 'Canonicalize a integer so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('numberTheoryCanonicalizeModularSystem', 'Number Theory', '(value)', 'Canonicalize a modular system so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('numberTheoryCanonicalizePrimeStructure', 'Number Theory', '(value)', 'Canonicalize a prime structure so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('numberTheoryClassifyArithmeticFunction', 'Number Theory', '(value)', 'Classify a arithmetic function by its standard Number Theory invariants.', 'professional_function_catalog.md'), + ('numberTheoryClassifyDivisorSet', 'Number Theory', '(value)', 'Classify a divisor set by its standard Number Theory invariants.', 'professional_function_catalog.md'), + ('numberTheoryClassifyInteger', 'Number Theory', '(value)', 'Classify a integer by its standard Number Theory invariants.', 'professional_function_catalog.md'), + ('numberTheoryClassifyModularSystem', 'Number Theory', '(value)', 'Classify a modular system by its standard Number Theory invariants.', 'professional_function_catalog.md'), + ('numberTheoryClassifyPrimeStructure', 'Number Theory', '(value)', 'Classify a prime structure by its standard Number Theory invariants.', 'professional_function_catalog.md'), + ('numberTheoryCombineArithmeticFunction', 'Number Theory', '(left, right)', 'Combine two arithmetic function values with the natural operation for Number Theory.', 'professional_function_catalog.md'), + ('numberTheoryCombineDivisorSet', 'Number Theory', '(left, right)', 'Combine two divisor set values with the natural operation for Number Theory.', 'professional_function_catalog.md'), + ('numberTheoryCombineInteger', 'Number Theory', '(left, right)', 'Combine two integer values with the natural operation for Number Theory.', 'professional_function_catalog.md'), + ('numberTheoryCombineModularSystem', 'Number Theory', '(left, right)', 'Combine two modular system values with the natural operation for Number Theory.', 'professional_function_catalog.md'), + ('numberTheoryCombinePrimeStructure', 'Number Theory', '(left, right)', 'Combine two prime structure values with the natural operation for Number Theory.', 'professional_function_catalog.md'), + ('numberTheoryCompareArithmeticFunction', 'Number Theory', '(left, right)', 'Compare two arithmetic function values under the conventions of Number Theory.', 'professional_function_catalog.md'), + ('numberTheoryCompareDivisorSet', 'Number Theory', '(left, right)', 'Compare two divisor set values under the conventions of Number Theory.', 'professional_function_catalog.md'), + ('numberTheoryCompareInteger', 'Number Theory', '(left, right)', 'Compare two integer values under the conventions of Number Theory.', 'professional_function_catalog.md'), + ('numberTheoryCompareModularSystem', 'Number Theory', '(left, right)', 'Compare two modular system values under the conventions of Number Theory.', 'professional_function_catalog.md'), + ('numberTheoryComparePrimeStructure', 'Number Theory', '(left, right)', 'Compare two prime structure values under the conventions of Number Theory.', 'professional_function_catalog.md'), + ('numberTheoryComputeArithmeticFunction', 'Number Theory', '(value)', 'Compute the central numerical or symbolic data of a arithmetic function.', 'professional_function_catalog.md'), + ('numberTheoryComputeDivisorSet', 'Number Theory', '(value)', 'Compute the central numerical or symbolic data of a divisor set.', 'professional_function_catalog.md'), + ('numberTheoryComputeInteger', 'Number Theory', '(value)', 'Compute the central numerical or symbolic data of a integer.', 'professional_function_catalog.md'), + ('numberTheoryComputeModularSystem', 'Number Theory', '(value)', 'Compute the central numerical or symbolic data of a modular system.', 'professional_function_catalog.md'), + ('numberTheoryComputePrimeStructure', 'Number Theory', '(value)', 'Compute the central numerical or symbolic data of a prime structure.', 'professional_function_catalog.md'), + ('numberTheoryConstructArithmeticFunction', 'Number Theory', '(*args)', 'Construct a arithmetic function from explicit inputs for Number Theory.', 'professional_function_catalog.md'), + ('numberTheoryConstructDivisorSet', 'Number Theory', '(*args)', 'Construct a divisor set from explicit inputs for Number Theory.', 'professional_function_catalog.md'), + ('numberTheoryConstructInteger', 'Number Theory', '(*args)', 'Construct a integer from explicit inputs for Number Theory.', 'professional_function_catalog.md'), + ('numberTheoryConstructModularSystem', 'Number Theory', '(*args)', 'Construct a modular system from explicit inputs for Number Theory.', 'professional_function_catalog.md'), + ('numberTheoryConstructPrimeStructure', 'Number Theory', '(*args)', 'Construct a prime structure from explicit inputs for Number Theory.', 'professional_function_catalog.md'), + ('numberTheoryDecomposeArithmeticFunction', 'Number Theory', '(value)', 'Decompose a arithmetic function into simpler or canonical components.', 'professional_function_catalog.md'), + ('numberTheoryDecomposeDivisorSet', 'Number Theory', '(value)', 'Decompose a divisor set into simpler or canonical components.', 'professional_function_catalog.md'), + ('numberTheoryDecomposeInteger', 'Number Theory', '(value)', 'Decompose a integer into simpler or canonical components.', 'professional_function_catalog.md'), + ('numberTheoryDecomposeModularSystem', 'Number Theory', '(value)', 'Decompose a modular system into simpler or canonical components.', 'professional_function_catalog.md'), + ('numberTheoryDecomposePrimeStructure', 'Number Theory', '(value)', 'Decompose a prime structure into simpler or canonical components.', 'professional_function_catalog.md'), + ('numberTheoryDocumentArithmeticFunction', 'Number Theory', '(value)', 'Return a structured explanation of a arithmetic function and related assumptions.', 'professional_function_catalog.md'), + ('numberTheoryDocumentDivisorSet', 'Number Theory', '(value)', 'Return a structured explanation of a divisor set and related assumptions.', 'professional_function_catalog.md'), + ('numberTheoryDocumentInteger', 'Number Theory', '(value)', 'Return a structured explanation of a integer and related assumptions.', 'professional_function_catalog.md'), + ('numberTheoryDocumentModularSystem', 'Number Theory', '(value)', 'Return a structured explanation of a modular system and related assumptions.', 'professional_function_catalog.md'), + ('numberTheoryDocumentPrimeStructure', 'Number Theory', '(value)', 'Return a structured explanation of a prime structure and related assumptions.', 'professional_function_catalog.md'), + ('numberTheoryEnumerateArithmeticFunction', 'Number Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a arithmetic function.', 'professional_function_catalog.md'), + ('numberTheoryEnumerateDivisorSet', 'Number Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a divisor set.', 'professional_function_catalog.md'), + ('numberTheoryEnumerateInteger', 'Number Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a integer.', 'professional_function_catalog.md'), + ('numberTheoryEnumerateModularSystem', 'Number Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a modular system.', 'professional_function_catalog.md'), + ('numberTheoryEnumeratePrimeStructure', 'Number Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a prime structure.', 'professional_function_catalog.md'), + ('numberTheoryEstimateArithmeticFunction', 'Number Theory', '(value, samples=None)', 'Estimate a arithmetic function property from finite samples or approximations.', 'professional_function_catalog.md'), + ('numberTheoryEstimateDivisorSet', 'Number Theory', '(value, samples=None)', 'Estimate a divisor set property from finite samples or approximations.', 'professional_function_catalog.md'), + ('numberTheoryEstimateInteger', 'Number Theory', '(value, samples=None)', 'Estimate a integer property from finite samples or approximations.', 'professional_function_catalog.md'), + ('numberTheoryEstimateModularSystem', 'Number Theory', '(value, samples=None)', 'Estimate a modular system property from finite samples or approximations.', 'professional_function_catalog.md'), + ('numberTheoryEstimatePrimeStructure', 'Number Theory', '(value, samples=None)', 'Estimate a prime structure property from finite samples or approximations.', 'professional_function_catalog.md'), + ('numberTheoryEvaluateArithmeticFunction', 'Number Theory', '(value, point=None)', 'Evaluate a arithmetic function at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('numberTheoryEvaluateDivisorSet', 'Number Theory', '(value, point=None)', 'Evaluate a divisor set at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('numberTheoryEvaluateInteger', 'Number Theory', '(value, point=None)', 'Evaluate a integer at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('numberTheoryEvaluateModularSystem', 'Number Theory', '(value, point=None)', 'Evaluate a modular system at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('numberTheoryEvaluatePrimeStructure', 'Number Theory', '(value, point=None)', 'Evaluate a prime structure at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('numberTheoryFormatArithmeticFunction', 'Number Theory', '(value)', 'Format a arithmetic function for deterministic user-facing output.', 'professional_function_catalog.md'), + ('numberTheoryFormatDivisorSet', 'Number Theory', '(value)', 'Format a divisor set for deterministic user-facing output.', 'professional_function_catalog.md'), + ('numberTheoryFormatInteger', 'Number Theory', '(value)', 'Format a integer for deterministic user-facing output.', 'professional_function_catalog.md'), + ('numberTheoryFormatModularSystem', 'Number Theory', '(value)', 'Format a modular system for deterministic user-facing output.', 'professional_function_catalog.md'), + ('numberTheoryFormatPrimeStructure', 'Number Theory', '(value)', 'Format a prime structure for deterministic user-facing output.', 'professional_function_catalog.md'), + ('numberTheoryGenerateExampleArithmeticFunction', 'Number Theory', '(size=3)', 'Generate a small documented example of a arithmetic function.', 'professional_function_catalog.md'), + ('numberTheoryGenerateExampleDivisorSet', 'Number Theory', '(size=3)', 'Generate a small documented example of a divisor set.', 'professional_function_catalog.md'), + ('numberTheoryGenerateExampleInteger', 'Number Theory', '(size=3)', 'Generate a small documented example of a integer.', 'professional_function_catalog.md'), + ('numberTheoryGenerateExampleModularSystem', 'Number Theory', '(size=3)', 'Generate a small documented example of a modular system.', 'professional_function_catalog.md'), + ('numberTheoryGenerateExamplePrimeStructure', 'Number Theory', '(size=3)', 'Generate a small documented example of a prime structure.', 'professional_function_catalog.md'), + ('numberTheoryNormalizeArithmeticFunction', 'Number Theory', '(value)', 'Normalize a arithmetic function into the standard Number Theory representation.', 'professional_function_catalog.md'), + ('numberTheoryNormalizeDivisorSet', 'Number Theory', '(value)', 'Normalize a divisor set into the standard Number Theory representation.', 'professional_function_catalog.md'), + ('numberTheoryNormalizeInteger', 'Number Theory', '(value)', 'Normalize a integer into the standard Number Theory representation.', 'professional_function_catalog.md'), + ('numberTheoryNormalizeModularSystem', 'Number Theory', '(value)', 'Normalize a modular system into the standard Number Theory representation.', 'professional_function_catalog.md'), + ('numberTheoryNormalizePrimeStructure', 'Number Theory', '(value)', 'Normalize a prime structure into the standard Number Theory representation.', 'professional_function_catalog.md'), + ('numberTheoryParseArithmeticFunction', 'Number Theory', '(text)', 'Parse a text or structured value into a arithmetic function.', 'professional_function_catalog.md'), + ('numberTheoryParseDivisorSet', 'Number Theory', '(text)', 'Parse a text or structured value into a divisor set.', 'professional_function_catalog.md'), + ('numberTheoryParseInteger', 'Number Theory', '(text)', 'Parse a text or structured value into a integer.', 'professional_function_catalog.md'), + ('numberTheoryParseModularSystem', 'Number Theory', '(text)', 'Parse a text or structured value into a modular system.', 'professional_function_catalog.md'), + ('numberTheoryParsePrimeStructure', 'Number Theory', '(text)', 'Parse a text or structured value into a prime structure.', 'professional_function_catalog.md'), + ('numberTheorySimplifyArithmeticFunction', 'Number Theory', '(value)', 'Simplify a arithmetic function without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('numberTheorySimplifyDivisorSet', 'Number Theory', '(value)', 'Simplify a divisor set without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('numberTheorySimplifyInteger', 'Number Theory', '(value)', 'Simplify a integer without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('numberTheorySimplifyModularSystem', 'Number Theory', '(value)', 'Simplify a modular system without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('numberTheorySimplifyPrimeStructure', 'Number Theory', '(value)', 'Simplify a prime structure without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('numberTheoryTestEquivalenceArithmeticFunction', 'Number Theory', '(left, right)', 'Test whether two arithmetic function values are equivalent in Number Theory.', 'professional_function_catalog.md'), + ('numberTheoryTestEquivalenceDivisorSet', 'Number Theory', '(left, right)', 'Test whether two divisor set values are equivalent in Number Theory.', 'professional_function_catalog.md'), + ('numberTheoryTestEquivalenceInteger', 'Number Theory', '(left, right)', 'Test whether two integer values are equivalent in Number Theory.', 'professional_function_catalog.md'), + ('numberTheoryTestEquivalenceModularSystem', 'Number Theory', '(left, right)', 'Test whether two modular system values are equivalent in Number Theory.', 'professional_function_catalog.md'), + ('numberTheoryTestEquivalencePrimeStructure', 'Number Theory', '(left, right)', 'Test whether two prime structure values are equivalent in Number Theory.', 'professional_function_catalog.md'), + ('numberTheoryTransformArithmeticFunction', 'Number Theory', '(value, mapping)', 'Transform a arithmetic function through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('numberTheoryTransformDivisorSet', 'Number Theory', '(value, mapping)', 'Transform a divisor set through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('numberTheoryTransformInteger', 'Number Theory', '(value, mapping)', 'Transform a integer through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('numberTheoryTransformModularSystem', 'Number Theory', '(value, mapping)', 'Transform a modular system through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('numberTheoryTransformPrimeStructure', 'Number Theory', '(value, mapping)', 'Transform a prime structure through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('numberTheoryValidateArithmeticFunction', 'Number Theory', '(value)', 'Validate the arithmetic function representation and domain rules for Number Theory.', 'professional_function_catalog.md'), + ('numberTheoryValidateDivisorSet', 'Number Theory', '(value)', 'Validate the divisor set representation and domain rules for Number Theory.', 'professional_function_catalog.md'), + ('numberTheoryValidateInteger', 'Number Theory', '(value)', 'Validate the integer representation and domain rules for Number Theory.', 'professional_function_catalog.md'), + ('numberTheoryValidateModularSystem', 'Number Theory', '(value)', 'Validate the modular system representation and domain rules for Number Theory.', 'professional_function_catalog.md'), + ('numberTheoryValidatePrimeStructure', 'Number Theory', '(value)', 'Validate the prime structure representation and domain rules for Number Theory.', 'professional_function_catalog.md'), + ('primeFactors', 'Number Theory', '(n)', 'Planned roadmap function for Number Theory from upcoming.md.', 'upcoming.md'), + ('sieve', 'Number Theory', '(limit)', 'Planned roadmap function for Number Theory from upcoming.md.', 'upcoming.md'), + ('bisectionMethod', 'Numerical Analysis', '(f, a, b, tolerance=1e-9)', 'Planned roadmap function for Numerical Analysis from upcoming.md.', 'upcoming.md'), + ('eulerMethod', 'Numerical Analysis', '(f, x0, y0, h, steps)', 'Planned roadmap function for Numerical Analysis from upcoming.md.', 'upcoming.md'), + ('fixedPointIteration', 'Numerical Analysis', '(g, x0, tolerance=1e-9)', 'Planned roadmap function for Numerical Analysis from upcoming.md.', 'upcoming.md'), + ('lagrangeInterpolation', 'Numerical Analysis', '(points, x)', 'Planned roadmap function for Numerical Analysis from upcoming.md.', 'upcoming.md'), + ('linearInterpolation', 'Numerical Analysis', '(points, x)', 'Planned roadmap function for Numerical Analysis from upcoming.md.', 'upcoming.md'), + ('newtonRaphson', 'Numerical Analysis', '(f, df, x0, tolerance=1e-9)', 'Planned roadmap function for Numerical Analysis from upcoming.md.', 'upcoming.md'), + ('numericalAnalysisApproximateErrorEstimate', 'Numerical Analysis', '(value, tolerance=1e-9)', 'Approximate a error estimate with explicit tolerance controls.', 'professional_function_catalog.md'), + ('numericalAnalysisApproximateInterpolationModel', 'Numerical Analysis', '(value, tolerance=1e-9)', 'Approximate a interpolation model with explicit tolerance controls.', 'professional_function_catalog.md'), + ('numericalAnalysisApproximateIterativeMethod', 'Numerical Analysis', '(value, tolerance=1e-9)', 'Approximate a iterative method with explicit tolerance controls.', 'professional_function_catalog.md'), + ('numericalAnalysisApproximateQuadratureRule', 'Numerical Analysis', '(value, tolerance=1e-9)', 'Approximate a quadrature rule with explicit tolerance controls.', 'professional_function_catalog.md'), + ('numericalAnalysisApproximateRootFinder', 'Numerical Analysis', '(value, tolerance=1e-9)', 'Approximate a root finder with explicit tolerance controls.', 'professional_function_catalog.md'), + ('numericalAnalysisCanonicalizeErrorEstimate', 'Numerical Analysis', '(value)', 'Canonicalize a error estimate so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('numericalAnalysisCanonicalizeInterpolationModel', 'Numerical Analysis', '(value)', 'Canonicalize a interpolation model so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('numericalAnalysisCanonicalizeIterativeMethod', 'Numerical Analysis', '(value)', 'Canonicalize a iterative method so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('numericalAnalysisCanonicalizeQuadratureRule', 'Numerical Analysis', '(value)', 'Canonicalize a quadrature rule so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('numericalAnalysisCanonicalizeRootFinder', 'Numerical Analysis', '(value)', 'Canonicalize a root finder so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('numericalAnalysisClassifyErrorEstimate', 'Numerical Analysis', '(value)', 'Classify a error estimate by its standard Numerical Analysis invariants.', 'professional_function_catalog.md'), + ('numericalAnalysisClassifyInterpolationModel', 'Numerical Analysis', '(value)', 'Classify a interpolation model by its standard Numerical Analysis invariants.', 'professional_function_catalog.md'), + ('numericalAnalysisClassifyIterativeMethod', 'Numerical Analysis', '(value)', 'Classify a iterative method by its standard Numerical Analysis invariants.', 'professional_function_catalog.md'), + ('numericalAnalysisClassifyQuadratureRule', 'Numerical Analysis', '(value)', 'Classify a quadrature rule by its standard Numerical Analysis invariants.', 'professional_function_catalog.md'), + ('numericalAnalysisClassifyRootFinder', 'Numerical Analysis', '(value)', 'Classify a root finder by its standard Numerical Analysis invariants.', 'professional_function_catalog.md'), + ('numericalAnalysisCombineErrorEstimate', 'Numerical Analysis', '(left, right)', 'Combine two error estimate values with the natural operation for Numerical Analysis.', 'professional_function_catalog.md'), + ('numericalAnalysisCombineInterpolationModel', 'Numerical Analysis', '(left, right)', 'Combine two interpolation model values with the natural operation for Numerical Analysis.', 'professional_function_catalog.md'), + ('numericalAnalysisCombineIterativeMethod', 'Numerical Analysis', '(left, right)', 'Combine two iterative method values with the natural operation for Numerical Analysis.', 'professional_function_catalog.md'), + ('numericalAnalysisCombineQuadratureRule', 'Numerical Analysis', '(left, right)', 'Combine two quadrature rule values with the natural operation for Numerical Analysis.', 'professional_function_catalog.md'), + ('numericalAnalysisCombineRootFinder', 'Numerical Analysis', '(left, right)', 'Combine two root finder values with the natural operation for Numerical Analysis.', 'professional_function_catalog.md'), + ('numericalAnalysisCompareErrorEstimate', 'Numerical Analysis', '(left, right)', 'Compare two error estimate values under the conventions of Numerical Analysis.', 'professional_function_catalog.md'), + ('numericalAnalysisCompareInterpolationModel', 'Numerical Analysis', '(left, right)', 'Compare two interpolation model values under the conventions of Numerical Analysis.', 'professional_function_catalog.md'), + ('numericalAnalysisCompareIterativeMethod', 'Numerical Analysis', '(left, right)', 'Compare two iterative method values under the conventions of Numerical Analysis.', 'professional_function_catalog.md'), + ('numericalAnalysisCompareQuadratureRule', 'Numerical Analysis', '(left, right)', 'Compare two quadrature rule values under the conventions of Numerical Analysis.', 'professional_function_catalog.md'), + ('numericalAnalysisCompareRootFinder', 'Numerical Analysis', '(left, right)', 'Compare two root finder values under the conventions of Numerical Analysis.', 'professional_function_catalog.md'), + ('numericalAnalysisComputeErrorEstimate', 'Numerical Analysis', '(value)', 'Compute the central numerical or symbolic data of a error estimate.', 'professional_function_catalog.md'), + ('numericalAnalysisComputeInterpolationModel', 'Numerical Analysis', '(value)', 'Compute the central numerical or symbolic data of a interpolation model.', 'professional_function_catalog.md'), + ('numericalAnalysisComputeIterativeMethod', 'Numerical Analysis', '(value)', 'Compute the central numerical or symbolic data of a iterative method.', 'professional_function_catalog.md'), + ('numericalAnalysisComputeQuadratureRule', 'Numerical Analysis', '(value)', 'Compute the central numerical or symbolic data of a quadrature rule.', 'professional_function_catalog.md'), + ('numericalAnalysisComputeRootFinder', 'Numerical Analysis', '(value)', 'Compute the central numerical or symbolic data of a root finder.', 'professional_function_catalog.md'), + ('numericalAnalysisConstructErrorEstimate', 'Numerical Analysis', '(*args)', 'Construct a error estimate from explicit inputs for Numerical Analysis.', 'professional_function_catalog.md'), + ('numericalAnalysisConstructInterpolationModel', 'Numerical Analysis', '(*args)', 'Construct a interpolation model from explicit inputs for Numerical Analysis.', 'professional_function_catalog.md'), + ('numericalAnalysisConstructIterativeMethod', 'Numerical Analysis', '(*args)', 'Construct a iterative method from explicit inputs for Numerical Analysis.', 'professional_function_catalog.md'), + ('numericalAnalysisConstructQuadratureRule', 'Numerical Analysis', '(*args)', 'Construct a quadrature rule from explicit inputs for Numerical Analysis.', 'professional_function_catalog.md'), + ('numericalAnalysisConstructRootFinder', 'Numerical Analysis', '(*args)', 'Construct a root finder from explicit inputs for Numerical Analysis.', 'professional_function_catalog.md'), + ('numericalAnalysisDecomposeErrorEstimate', 'Numerical Analysis', '(value)', 'Decompose a error estimate into simpler or canonical components.', 'professional_function_catalog.md'), + ('numericalAnalysisDecomposeInterpolationModel', 'Numerical Analysis', '(value)', 'Decompose a interpolation model into simpler or canonical components.', 'professional_function_catalog.md'), + ('numericalAnalysisDecomposeIterativeMethod', 'Numerical Analysis', '(value)', 'Decompose a iterative method into simpler or canonical components.', 'professional_function_catalog.md'), + ('numericalAnalysisDecomposeQuadratureRule', 'Numerical Analysis', '(value)', 'Decompose a quadrature rule into simpler or canonical components.', 'professional_function_catalog.md'), + ('numericalAnalysisDecomposeRootFinder', 'Numerical Analysis', '(value)', 'Decompose a root finder into simpler or canonical components.', 'professional_function_catalog.md'), + ('numericalAnalysisDocumentErrorEstimate', 'Numerical Analysis', '(value)', 'Return a structured explanation of a error estimate and related assumptions.', 'professional_function_catalog.md'), + ('numericalAnalysisDocumentInterpolationModel', 'Numerical Analysis', '(value)', 'Return a structured explanation of a interpolation model and related assumptions.', 'professional_function_catalog.md'), + ('numericalAnalysisDocumentIterativeMethod', 'Numerical Analysis', '(value)', 'Return a structured explanation of a iterative method and related assumptions.', 'professional_function_catalog.md'), + ('numericalAnalysisDocumentQuadratureRule', 'Numerical Analysis', '(value)', 'Return a structured explanation of a quadrature rule and related assumptions.', 'professional_function_catalog.md'), + ('numericalAnalysisDocumentRootFinder', 'Numerical Analysis', '(value)', 'Return a structured explanation of a root finder and related assumptions.', 'professional_function_catalog.md'), + ('numericalAnalysisEnumerateErrorEstimate', 'Numerical Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a error estimate.', 'professional_function_catalog.md'), + ('numericalAnalysisEnumerateInterpolationModel', 'Numerical Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a interpolation model.', 'professional_function_catalog.md'), + ('numericalAnalysisEnumerateIterativeMethod', 'Numerical Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a iterative method.', 'professional_function_catalog.md'), + ('numericalAnalysisEnumerateQuadratureRule', 'Numerical Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a quadrature rule.', 'professional_function_catalog.md'), + ('numericalAnalysisEnumerateRootFinder', 'Numerical Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a root finder.', 'professional_function_catalog.md'), + ('numericalAnalysisEstimateErrorEstimate', 'Numerical Analysis', '(value, samples=None)', 'Estimate a error estimate property from finite samples or approximations.', 'professional_function_catalog.md'), + ('numericalAnalysisEstimateInterpolationModel', 'Numerical Analysis', '(value, samples=None)', 'Estimate a interpolation model property from finite samples or approximations.', 'professional_function_catalog.md'), + ('numericalAnalysisEstimateIterativeMethod', 'Numerical Analysis', '(value, samples=None)', 'Estimate a iterative method property from finite samples or approximations.', 'professional_function_catalog.md'), + ('numericalAnalysisEstimateQuadratureRule', 'Numerical Analysis', '(value, samples=None)', 'Estimate a quadrature rule property from finite samples or approximations.', 'professional_function_catalog.md'), + ('numericalAnalysisEstimateRootFinder', 'Numerical Analysis', '(value, samples=None)', 'Estimate a root finder property from finite samples or approximations.', 'professional_function_catalog.md'), + ('numericalAnalysisEvaluateErrorEstimate', 'Numerical Analysis', '(value, point=None)', 'Evaluate a error estimate at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('numericalAnalysisEvaluateInterpolationModel', 'Numerical Analysis', '(value, point=None)', 'Evaluate a interpolation model at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('numericalAnalysisEvaluateIterativeMethod', 'Numerical Analysis', '(value, point=None)', 'Evaluate a iterative method at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('numericalAnalysisEvaluateQuadratureRule', 'Numerical Analysis', '(value, point=None)', 'Evaluate a quadrature rule at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('numericalAnalysisEvaluateRootFinder', 'Numerical Analysis', '(value, point=None)', 'Evaluate a root finder at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('numericalAnalysisFormatErrorEstimate', 'Numerical Analysis', '(value)', 'Format a error estimate for deterministic user-facing output.', 'professional_function_catalog.md'), + ('numericalAnalysisFormatInterpolationModel', 'Numerical Analysis', '(value)', 'Format a interpolation model for deterministic user-facing output.', 'professional_function_catalog.md'), + ('numericalAnalysisFormatIterativeMethod', 'Numerical Analysis', '(value)', 'Format a iterative method for deterministic user-facing output.', 'professional_function_catalog.md'), + ('numericalAnalysisFormatQuadratureRule', 'Numerical Analysis', '(value)', 'Format a quadrature rule for deterministic user-facing output.', 'professional_function_catalog.md'), + ('numericalAnalysisFormatRootFinder', 'Numerical Analysis', '(value)', 'Format a root finder for deterministic user-facing output.', 'professional_function_catalog.md'), + ('numericalAnalysisGenerateExampleErrorEstimate', 'Numerical Analysis', '(size=3)', 'Generate a small documented example of a error estimate.', 'professional_function_catalog.md'), + ('numericalAnalysisGenerateExampleInterpolationModel', 'Numerical Analysis', '(size=3)', 'Generate a small documented example of a interpolation model.', 'professional_function_catalog.md'), + ('numericalAnalysisGenerateExampleIterativeMethod', 'Numerical Analysis', '(size=3)', 'Generate a small documented example of a iterative method.', 'professional_function_catalog.md'), + ('numericalAnalysisGenerateExampleQuadratureRule', 'Numerical Analysis', '(size=3)', 'Generate a small documented example of a quadrature rule.', 'professional_function_catalog.md'), + ('numericalAnalysisGenerateExampleRootFinder', 'Numerical Analysis', '(size=3)', 'Generate a small documented example of a root finder.', 'professional_function_catalog.md'), + ('numericalAnalysisNormalizeErrorEstimate', 'Numerical Analysis', '(value)', 'Normalize a error estimate into the standard Numerical Analysis representation.', 'professional_function_catalog.md'), + ('numericalAnalysisNormalizeInterpolationModel', 'Numerical Analysis', '(value)', 'Normalize a interpolation model into the standard Numerical Analysis representation.', 'professional_function_catalog.md'), + ('numericalAnalysisNormalizeIterativeMethod', 'Numerical Analysis', '(value)', 'Normalize a iterative method into the standard Numerical Analysis representation.', 'professional_function_catalog.md'), + ('numericalAnalysisNormalizeQuadratureRule', 'Numerical Analysis', '(value)', 'Normalize a quadrature rule into the standard Numerical Analysis representation.', 'professional_function_catalog.md'), + ('numericalAnalysisNormalizeRootFinder', 'Numerical Analysis', '(value)', 'Normalize a root finder into the standard Numerical Analysis representation.', 'professional_function_catalog.md'), + ('numericalAnalysisParseErrorEstimate', 'Numerical Analysis', '(text)', 'Parse a text or structured value into a error estimate.', 'professional_function_catalog.md'), + ('numericalAnalysisParseInterpolationModel', 'Numerical Analysis', '(text)', 'Parse a text or structured value into a interpolation model.', 'professional_function_catalog.md'), + ('numericalAnalysisParseIterativeMethod', 'Numerical Analysis', '(text)', 'Parse a text or structured value into a iterative method.', 'professional_function_catalog.md'), + ('numericalAnalysisParseQuadratureRule', 'Numerical Analysis', '(text)', 'Parse a text or structured value into a quadrature rule.', 'professional_function_catalog.md'), + ('numericalAnalysisParseRootFinder', 'Numerical Analysis', '(text)', 'Parse a text or structured value into a root finder.', 'professional_function_catalog.md'), + ('numericalAnalysisSimplifyErrorEstimate', 'Numerical Analysis', '(value)', 'Simplify a error estimate without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('numericalAnalysisSimplifyInterpolationModel', 'Numerical Analysis', '(value)', 'Simplify a interpolation model without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('numericalAnalysisSimplifyIterativeMethod', 'Numerical Analysis', '(value)', 'Simplify a iterative method without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('numericalAnalysisSimplifyQuadratureRule', 'Numerical Analysis', '(value)', 'Simplify a quadrature rule without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('numericalAnalysisSimplifyRootFinder', 'Numerical Analysis', '(value)', 'Simplify a root finder without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('numericalAnalysisTestEquivalenceErrorEstimate', 'Numerical Analysis', '(left, right)', 'Test whether two error estimate values are equivalent in Numerical Analysis.', 'professional_function_catalog.md'), + ('numericalAnalysisTestEquivalenceInterpolationModel', 'Numerical Analysis', '(left, right)', 'Test whether two interpolation model values are equivalent in Numerical Analysis.', 'professional_function_catalog.md'), + ('numericalAnalysisTestEquivalenceIterativeMethod', 'Numerical Analysis', '(left, right)', 'Test whether two iterative method values are equivalent in Numerical Analysis.', 'professional_function_catalog.md'), + ('numericalAnalysisTestEquivalenceQuadratureRule', 'Numerical Analysis', '(left, right)', 'Test whether two quadrature rule values are equivalent in Numerical Analysis.', 'professional_function_catalog.md'), + ('numericalAnalysisTestEquivalenceRootFinder', 'Numerical Analysis', '(left, right)', 'Test whether two root finder values are equivalent in Numerical Analysis.', 'professional_function_catalog.md'), + ('numericalAnalysisTransformErrorEstimate', 'Numerical Analysis', '(value, mapping)', 'Transform a error estimate through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('numericalAnalysisTransformInterpolationModel', 'Numerical Analysis', '(value, mapping)', 'Transform a interpolation model through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('numericalAnalysisTransformIterativeMethod', 'Numerical Analysis', '(value, mapping)', 'Transform a iterative method through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('numericalAnalysisTransformQuadratureRule', 'Numerical Analysis', '(value, mapping)', 'Transform a quadrature rule through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('numericalAnalysisTransformRootFinder', 'Numerical Analysis', '(value, mapping)', 'Transform a root finder through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('numericalAnalysisValidateErrorEstimate', 'Numerical Analysis', '(value)', 'Validate the error estimate representation and domain rules for Numerical Analysis.', 'professional_function_catalog.md'), + ('numericalAnalysisValidateInterpolationModel', 'Numerical Analysis', '(value)', 'Validate the interpolation model representation and domain rules for Numerical Analysis.', 'professional_function_catalog.md'), + ('numericalAnalysisValidateIterativeMethod', 'Numerical Analysis', '(value)', 'Validate the iterative method representation and domain rules for Numerical Analysis.', 'professional_function_catalog.md'), + ('numericalAnalysisValidateQuadratureRule', 'Numerical Analysis', '(value)', 'Validate the quadrature rule representation and domain rules for Numerical Analysis.', 'professional_function_catalog.md'), + ('numericalAnalysisValidateRootFinder', 'Numerical Analysis', '(value)', 'Validate the root finder representation and domain rules for Numerical Analysis.', 'professional_function_catalog.md'), + ('rungeKutta4', 'Numerical Analysis', '(f, x0, y0, h, steps)', 'Planned roadmap function for Numerical Analysis from upcoming.md.', 'upcoming.md'), + ('secantMethod', 'Numerical Analysis', '(f, x0, x1, tolerance=1e-9)', 'Planned roadmap function for Numerical Analysis from upcoming.md.', 'upcoming.md'), + ('simpsonRule', 'Numerical Analysis', '(f, a, b, n)', 'Planned roadmap function for Numerical Analysis from upcoming.md.', 'upcoming.md'), + ('trapezoidalRule', 'Numerical Analysis', '(f, a, b, n)', 'Planned roadmap function for Numerical Analysis from upcoming.md.', 'upcoming.md'), + ('absoluteError', 'Numerical foundations', '(actual, expected)', 'Planned roadmap function for Numerical foundations from upcoming.md.', 'upcoming.md'), + ('approximatelyEqual', 'Numerical foundations', '(a, b, absTol=1e-9, relTol=1e-9)', 'Planned roadmap function for Numerical foundations from upcoming.md.', 'upcoming.md'), + ('isFiniteNumber', 'Numerical foundations', '(x)', 'Planned roadmap function for Numerical foundations from upcoming.md.', 'upcoming.md'), + ('relativeError', 'Numerical foundations', '(actual, expected)', 'Planned roadmap function for Numerical foundations from upcoming.md.', 'upcoming.md'), + ('validateTolerance', 'Numerical foundations', '(tolerance)', 'Planned roadmap function for Numerical foundations from upcoming.md.', 'upcoming.md'), + ('choleskyDecomposition', 'Numerical Linear Algebra', '(matrix)', 'Planned roadmap function for Numerical Linear Algebra from upcoming.md.', 'upcoming.md'), + ('conditionNumber', 'Numerical Linear Algebra', '(matrix)', 'Planned roadmap function for Numerical Linear Algebra from upcoming.md.', 'upcoming.md'), + ('gaussSeidelSolve', 'Numerical Linear Algebra', '(A, b, iterations)', 'Planned roadmap function for Numerical Linear Algebra from upcoming.md.', 'upcoming.md'), + ('gramSchmidt', 'Numerical Linear Algebra', '(vectors)', 'Planned roadmap function for Numerical Linear Algebra from upcoming.md.', 'upcoming.md'), + ('jacobiSolve', 'Numerical Linear Algebra', '(A, b, iterations)', 'Planned roadmap function for Numerical Linear Algebra from upcoming.md.', 'upcoming.md'), + ('luDecomposition', 'Numerical Linear Algebra', '(matrix)', 'Planned roadmap function for Numerical Linear Algebra from upcoming.md.', 'upcoming.md'), + ('numericalLinearAlgebraApproximateConditionEstimate', 'Numerical Linear Algebra', '(value, tolerance=1e-9)', 'Approximate a condition estimate with explicit tolerance controls.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraApproximateEigenIteration', 'Numerical Linear Algebra', '(value, tolerance=1e-9)', 'Approximate a eigen iteration with explicit tolerance controls.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraApproximateIterativeSolver', 'Numerical Linear Algebra', '(value, tolerance=1e-9)', 'Approximate a iterative solver with explicit tolerance controls.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraApproximateMatrixFactorization', 'Numerical Linear Algebra', '(value, tolerance=1e-9)', 'Approximate a matrix factorization with explicit tolerance controls.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraApproximateOrthogonalBasis', 'Numerical Linear Algebra', '(value, tolerance=1e-9)', 'Approximate a orthogonal basis with explicit tolerance controls.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraCanonicalizeConditionEstimate', 'Numerical Linear Algebra', '(value)', 'Canonicalize a condition estimate so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraCanonicalizeEigenIteration', 'Numerical Linear Algebra', '(value)', 'Canonicalize a eigen iteration so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraCanonicalizeIterativeSolver', 'Numerical Linear Algebra', '(value)', 'Canonicalize a iterative solver so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraCanonicalizeMatrixFactorization', 'Numerical Linear Algebra', '(value)', 'Canonicalize a matrix factorization so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraCanonicalizeOrthogonalBasis', 'Numerical Linear Algebra', '(value)', 'Canonicalize a orthogonal basis so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraClassifyConditionEstimate', 'Numerical Linear Algebra', '(value)', 'Classify a condition estimate by its standard Numerical Linear Algebra invariants.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraClassifyEigenIteration', 'Numerical Linear Algebra', '(value)', 'Classify a eigen iteration by its standard Numerical Linear Algebra invariants.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraClassifyIterativeSolver', 'Numerical Linear Algebra', '(value)', 'Classify a iterative solver by its standard Numerical Linear Algebra invariants.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraClassifyMatrixFactorization', 'Numerical Linear Algebra', '(value)', 'Classify a matrix factorization by its standard Numerical Linear Algebra invariants.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraClassifyOrthogonalBasis', 'Numerical Linear Algebra', '(value)', 'Classify a orthogonal basis by its standard Numerical Linear Algebra invariants.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraCombineConditionEstimate', 'Numerical Linear Algebra', '(left, right)', 'Combine two condition estimate values with the natural operation for Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraCombineEigenIteration', 'Numerical Linear Algebra', '(left, right)', 'Combine two eigen iteration values with the natural operation for Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraCombineIterativeSolver', 'Numerical Linear Algebra', '(left, right)', 'Combine two iterative solver values with the natural operation for Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraCombineMatrixFactorization', 'Numerical Linear Algebra', '(left, right)', 'Combine two matrix factorization values with the natural operation for Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraCombineOrthogonalBasis', 'Numerical Linear Algebra', '(left, right)', 'Combine two orthogonal basis values with the natural operation for Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraCompareConditionEstimate', 'Numerical Linear Algebra', '(left, right)', 'Compare two condition estimate values under the conventions of Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraCompareEigenIteration', 'Numerical Linear Algebra', '(left, right)', 'Compare two eigen iteration values under the conventions of Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraCompareIterativeSolver', 'Numerical Linear Algebra', '(left, right)', 'Compare two iterative solver values under the conventions of Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraCompareMatrixFactorization', 'Numerical Linear Algebra', '(left, right)', 'Compare two matrix factorization values under the conventions of Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraCompareOrthogonalBasis', 'Numerical Linear Algebra', '(left, right)', 'Compare two orthogonal basis values under the conventions of Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraComputeConditionEstimate', 'Numerical Linear Algebra', '(value)', 'Compute the central numerical or symbolic data of a condition estimate.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraComputeEigenIteration', 'Numerical Linear Algebra', '(value)', 'Compute the central numerical or symbolic data of a eigen iteration.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraComputeIterativeSolver', 'Numerical Linear Algebra', '(value)', 'Compute the central numerical or symbolic data of a iterative solver.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraComputeMatrixFactorization', 'Numerical Linear Algebra', '(value)', 'Compute the central numerical or symbolic data of a matrix factorization.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraComputeOrthogonalBasis', 'Numerical Linear Algebra', '(value)', 'Compute the central numerical or symbolic data of a orthogonal basis.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraConstructConditionEstimate', 'Numerical Linear Algebra', '(*args)', 'Construct a condition estimate from explicit inputs for Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraConstructEigenIteration', 'Numerical Linear Algebra', '(*args)', 'Construct a eigen iteration from explicit inputs for Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraConstructIterativeSolver', 'Numerical Linear Algebra', '(*args)', 'Construct a iterative solver from explicit inputs for Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraConstructMatrixFactorization', 'Numerical Linear Algebra', '(*args)', 'Construct a matrix factorization from explicit inputs for Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraConstructOrthogonalBasis', 'Numerical Linear Algebra', '(*args)', 'Construct a orthogonal basis from explicit inputs for Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraDecomposeConditionEstimate', 'Numerical Linear Algebra', '(value)', 'Decompose a condition estimate into simpler or canonical components.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraDecomposeEigenIteration', 'Numerical Linear Algebra', '(value)', 'Decompose a eigen iteration into simpler or canonical components.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraDecomposeIterativeSolver', 'Numerical Linear Algebra', '(value)', 'Decompose a iterative solver into simpler or canonical components.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraDecomposeMatrixFactorization', 'Numerical Linear Algebra', '(value)', 'Decompose a matrix factorization into simpler or canonical components.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraDecomposeOrthogonalBasis', 'Numerical Linear Algebra', '(value)', 'Decompose a orthogonal basis into simpler or canonical components.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraDocumentConditionEstimate', 'Numerical Linear Algebra', '(value)', 'Return a structured explanation of a condition estimate and related assumptions.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraDocumentEigenIteration', 'Numerical Linear Algebra', '(value)', 'Return a structured explanation of a eigen iteration and related assumptions.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraDocumentIterativeSolver', 'Numerical Linear Algebra', '(value)', 'Return a structured explanation of a iterative solver and related assumptions.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraDocumentMatrixFactorization', 'Numerical Linear Algebra', '(value)', 'Return a structured explanation of a matrix factorization and related assumptions.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraDocumentOrthogonalBasis', 'Numerical Linear Algebra', '(value)', 'Return a structured explanation of a orthogonal basis and related assumptions.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraEnumerateConditionEstimate', 'Numerical Linear Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a condition estimate.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraEnumerateEigenIteration', 'Numerical Linear Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a eigen iteration.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraEnumerateIterativeSolver', 'Numerical Linear Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a iterative solver.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraEnumerateMatrixFactorization', 'Numerical Linear Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a matrix factorization.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraEnumerateOrthogonalBasis', 'Numerical Linear Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a orthogonal basis.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraEstimateConditionEstimate', 'Numerical Linear Algebra', '(value, samples=None)', 'Estimate a condition estimate property from finite samples or approximations.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraEstimateEigenIteration', 'Numerical Linear Algebra', '(value, samples=None)', 'Estimate a eigen iteration property from finite samples or approximations.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraEstimateIterativeSolver', 'Numerical Linear Algebra', '(value, samples=None)', 'Estimate a iterative solver property from finite samples or approximations.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraEstimateMatrixFactorization', 'Numerical Linear Algebra', '(value, samples=None)', 'Estimate a matrix factorization property from finite samples or approximations.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraEstimateOrthogonalBasis', 'Numerical Linear Algebra', '(value, samples=None)', 'Estimate a orthogonal basis property from finite samples or approximations.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraEvaluateConditionEstimate', 'Numerical Linear Algebra', '(value, point=None)', 'Evaluate a condition estimate at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraEvaluateEigenIteration', 'Numerical Linear Algebra', '(value, point=None)', 'Evaluate a eigen iteration at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraEvaluateIterativeSolver', 'Numerical Linear Algebra', '(value, point=None)', 'Evaluate a iterative solver at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraEvaluateMatrixFactorization', 'Numerical Linear Algebra', '(value, point=None)', 'Evaluate a matrix factorization at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraEvaluateOrthogonalBasis', 'Numerical Linear Algebra', '(value, point=None)', 'Evaluate a orthogonal basis at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraFormatConditionEstimate', 'Numerical Linear Algebra', '(value)', 'Format a condition estimate for deterministic user-facing output.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraFormatEigenIteration', 'Numerical Linear Algebra', '(value)', 'Format a eigen iteration for deterministic user-facing output.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraFormatIterativeSolver', 'Numerical Linear Algebra', '(value)', 'Format a iterative solver for deterministic user-facing output.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraFormatMatrixFactorization', 'Numerical Linear Algebra', '(value)', 'Format a matrix factorization for deterministic user-facing output.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraFormatOrthogonalBasis', 'Numerical Linear Algebra', '(value)', 'Format a orthogonal basis for deterministic user-facing output.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraGenerateExampleConditionEstimate', 'Numerical Linear Algebra', '(size=3)', 'Generate a small documented example of a condition estimate.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraGenerateExampleEigenIteration', 'Numerical Linear Algebra', '(size=3)', 'Generate a small documented example of a eigen iteration.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraGenerateExampleIterativeSolver', 'Numerical Linear Algebra', '(size=3)', 'Generate a small documented example of a iterative solver.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraGenerateExampleMatrixFactorization', 'Numerical Linear Algebra', '(size=3)', 'Generate a small documented example of a matrix factorization.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraGenerateExampleOrthogonalBasis', 'Numerical Linear Algebra', '(size=3)', 'Generate a small documented example of a orthogonal basis.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraNormalizeConditionEstimate', 'Numerical Linear Algebra', '(value)', 'Normalize a condition estimate into the standard Numerical Linear Algebra representation.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraNormalizeEigenIteration', 'Numerical Linear Algebra', '(value)', 'Normalize a eigen iteration into the standard Numerical Linear Algebra representation.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraNormalizeIterativeSolver', 'Numerical Linear Algebra', '(value)', 'Normalize a iterative solver into the standard Numerical Linear Algebra representation.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraNormalizeMatrixFactorization', 'Numerical Linear Algebra', '(value)', 'Normalize a matrix factorization into the standard Numerical Linear Algebra representation.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraNormalizeOrthogonalBasis', 'Numerical Linear Algebra', '(value)', 'Normalize a orthogonal basis into the standard Numerical Linear Algebra representation.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraParseConditionEstimate', 'Numerical Linear Algebra', '(text)', 'Parse a text or structured value into a condition estimate.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraParseEigenIteration', 'Numerical Linear Algebra', '(text)', 'Parse a text or structured value into a eigen iteration.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraParseIterativeSolver', 'Numerical Linear Algebra', '(text)', 'Parse a text or structured value into a iterative solver.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraParseMatrixFactorization', 'Numerical Linear Algebra', '(text)', 'Parse a text or structured value into a matrix factorization.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraParseOrthogonalBasis', 'Numerical Linear Algebra', '(text)', 'Parse a text or structured value into a orthogonal basis.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraSimplifyConditionEstimate', 'Numerical Linear Algebra', '(value)', 'Simplify a condition estimate without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraSimplifyEigenIteration', 'Numerical Linear Algebra', '(value)', 'Simplify a eigen iteration without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraSimplifyIterativeSolver', 'Numerical Linear Algebra', '(value)', 'Simplify a iterative solver without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraSimplifyMatrixFactorization', 'Numerical Linear Algebra', '(value)', 'Simplify a matrix factorization without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraSimplifyOrthogonalBasis', 'Numerical Linear Algebra', '(value)', 'Simplify a orthogonal basis without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraTestEquivalenceConditionEstimate', 'Numerical Linear Algebra', '(left, right)', 'Test whether two condition estimate values are equivalent in Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraTestEquivalenceEigenIteration', 'Numerical Linear Algebra', '(left, right)', 'Test whether two eigen iteration values are equivalent in Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraTestEquivalenceIterativeSolver', 'Numerical Linear Algebra', '(left, right)', 'Test whether two iterative solver values are equivalent in Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraTestEquivalenceMatrixFactorization', 'Numerical Linear Algebra', '(left, right)', 'Test whether two matrix factorization values are equivalent in Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraTestEquivalenceOrthogonalBasis', 'Numerical Linear Algebra', '(left, right)', 'Test whether two orthogonal basis values are equivalent in Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraTransformConditionEstimate', 'Numerical Linear Algebra', '(value, mapping)', 'Transform a condition estimate through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraTransformEigenIteration', 'Numerical Linear Algebra', '(value, mapping)', 'Transform a eigen iteration through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraTransformIterativeSolver', 'Numerical Linear Algebra', '(value, mapping)', 'Transform a iterative solver through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraTransformMatrixFactorization', 'Numerical Linear Algebra', '(value, mapping)', 'Transform a matrix factorization through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraTransformOrthogonalBasis', 'Numerical Linear Algebra', '(value, mapping)', 'Transform a orthogonal basis through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraValidateConditionEstimate', 'Numerical Linear Algebra', '(value)', 'Validate the condition estimate representation and domain rules for Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraValidateEigenIteration', 'Numerical Linear Algebra', '(value)', 'Validate the eigen iteration representation and domain rules for Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraValidateIterativeSolver', 'Numerical Linear Algebra', '(value)', 'Validate the iterative solver representation and domain rules for Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraValidateMatrixFactorization', 'Numerical Linear Algebra', '(value)', 'Validate the matrix factorization representation and domain rules for Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('numericalLinearAlgebraValidateOrthogonalBasis', 'Numerical Linear Algebra', '(value)', 'Validate the orthogonal basis representation and domain rules for Numerical Linear Algebra.', 'professional_function_catalog.md'), + ('powerIteration', 'Numerical Linear Algebra', '(matrix, iterations)', 'Planned roadmap function for Numerical Linear Algebra from upcoming.md.', 'upcoming.md'), + ('qrDecomposition', 'Numerical Linear Algebra', '(matrix)', 'Planned roadmap function for Numerical Linear Algebra from upcoming.md.', 'upcoming.md'), + ('adjointOperator', 'Operator Theory', '(matrix)', 'Planned roadmap function for Operator Theory from upcoming.md.', 'upcoming.md'), + ('applyOperator', 'Operator Theory', '(matrix, vector)', 'Planned roadmap function for Operator Theory from upcoming.md.', 'upcoming.md'), + ('commutator', 'Operator Theory', '(A, B)', 'Planned roadmap function for Operator Theory from upcoming.md.', 'upcoming.md'), + ('isNormalOperator', 'Operator Theory', '(matrix)', 'Planned roadmap function for Operator Theory from upcoming.md.', 'upcoming.md'), + ('isProjection', 'Operator Theory', '(matrix)', 'Planned roadmap function for Operator Theory from upcoming.md.', 'upcoming.md'), + ('isSelfAdjoint', 'Operator Theory', '(matrix)', 'Planned roadmap function for Operator Theory from upcoming.md.', 'upcoming.md'), + ('operatorCompose', 'Operator Theory', '(A, B)', 'Planned roadmap function for Operator Theory from upcoming.md.', 'upcoming.md'), + ('operatorTheoryApproximateAdjoint', 'Operator Theory', '(value, tolerance=1e-9)', 'Approximate a adjoint with explicit tolerance controls.', 'professional_function_catalog.md'), + ('operatorTheoryApproximateOperator', 'Operator Theory', '(value, tolerance=1e-9)', 'Approximate a operator with explicit tolerance controls.', 'professional_function_catalog.md'), + ('operatorTheoryApproximateOperatorAlgebra', 'Operator Theory', '(value, tolerance=1e-9)', 'Approximate a operator algebra with explicit tolerance controls.', 'professional_function_catalog.md'), + ('operatorTheoryApproximateProjection', 'Operator Theory', '(value, tolerance=1e-9)', 'Approximate a projection with explicit tolerance controls.', 'professional_function_catalog.md'), + ('operatorTheoryApproximateSpectrum', 'Operator Theory', '(value, tolerance=1e-9)', 'Approximate a spectrum with explicit tolerance controls.', 'professional_function_catalog.md'), + ('operatorTheoryCanonicalizeAdjoint', 'Operator Theory', '(value)', 'Canonicalize a adjoint so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('operatorTheoryCanonicalizeOperator', 'Operator Theory', '(value)', 'Canonicalize a operator so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('operatorTheoryCanonicalizeOperatorAlgebra', 'Operator Theory', '(value)', 'Canonicalize a operator algebra so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('operatorTheoryCanonicalizeProjection', 'Operator Theory', '(value)', 'Canonicalize a projection so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('operatorTheoryCanonicalizeSpectrum', 'Operator Theory', '(value)', 'Canonicalize a spectrum so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('operatorTheoryClassifyAdjoint', 'Operator Theory', '(value)', 'Classify a adjoint by its standard Operator Theory invariants.', 'professional_function_catalog.md'), + ('operatorTheoryClassifyOperator', 'Operator Theory', '(value)', 'Classify a operator by its standard Operator Theory invariants.', 'professional_function_catalog.md'), + ('operatorTheoryClassifyOperatorAlgebra', 'Operator Theory', '(value)', 'Classify a operator algebra by its standard Operator Theory invariants.', 'professional_function_catalog.md'), + ('operatorTheoryClassifyProjection', 'Operator Theory', '(value)', 'Classify a projection by its standard Operator Theory invariants.', 'professional_function_catalog.md'), + ('operatorTheoryClassifySpectrum', 'Operator Theory', '(value)', 'Classify a spectrum by its standard Operator Theory invariants.', 'professional_function_catalog.md'), + ('operatorTheoryCombineAdjoint', 'Operator Theory', '(left, right)', 'Combine two adjoint values with the natural operation for Operator Theory.', 'professional_function_catalog.md'), + ('operatorTheoryCombineOperator', 'Operator Theory', '(left, right)', 'Combine two operator values with the natural operation for Operator Theory.', 'professional_function_catalog.md'), + ('operatorTheoryCombineOperatorAlgebra', 'Operator Theory', '(left, right)', 'Combine two operator algebra values with the natural operation for Operator Theory.', 'professional_function_catalog.md'), + ('operatorTheoryCombineProjection', 'Operator Theory', '(left, right)', 'Combine two projection values with the natural operation for Operator Theory.', 'professional_function_catalog.md'), + ('operatorTheoryCombineSpectrum', 'Operator Theory', '(left, right)', 'Combine two spectrum values with the natural operation for Operator Theory.', 'professional_function_catalog.md'), + ('operatorTheoryCompareAdjoint', 'Operator Theory', '(left, right)', 'Compare two adjoint values under the conventions of Operator Theory.', 'professional_function_catalog.md'), + ('operatorTheoryCompareOperator', 'Operator Theory', '(left, right)', 'Compare two operator values under the conventions of Operator Theory.', 'professional_function_catalog.md'), + ('operatorTheoryCompareOperatorAlgebra', 'Operator Theory', '(left, right)', 'Compare two operator algebra values under the conventions of Operator Theory.', 'professional_function_catalog.md'), + ('operatorTheoryCompareProjection', 'Operator Theory', '(left, right)', 'Compare two projection values under the conventions of Operator Theory.', 'professional_function_catalog.md'), + ('operatorTheoryCompareSpectrum', 'Operator Theory', '(left, right)', 'Compare two spectrum values under the conventions of Operator Theory.', 'professional_function_catalog.md'), + ('operatorTheoryComputeAdjoint', 'Operator Theory', '(value)', 'Compute the central numerical or symbolic data of a adjoint.', 'professional_function_catalog.md'), + ('operatorTheoryComputeOperator', 'Operator Theory', '(value)', 'Compute the central numerical or symbolic data of a operator.', 'professional_function_catalog.md'), + ('operatorTheoryComputeOperatorAlgebra', 'Operator Theory', '(value)', 'Compute the central numerical or symbolic data of a operator algebra.', 'professional_function_catalog.md'), + ('operatorTheoryComputeProjection', 'Operator Theory', '(value)', 'Compute the central numerical or symbolic data of a projection.', 'professional_function_catalog.md'), + ('operatorTheoryComputeSpectrum', 'Operator Theory', '(value)', 'Compute the central numerical or symbolic data of a spectrum.', 'professional_function_catalog.md'), + ('operatorTheoryConstructAdjoint', 'Operator Theory', '(*args)', 'Construct a adjoint from explicit inputs for Operator Theory.', 'professional_function_catalog.md'), + ('operatorTheoryConstructOperator', 'Operator Theory', '(*args)', 'Construct a operator from explicit inputs for Operator Theory.', 'professional_function_catalog.md'), + ('operatorTheoryConstructOperatorAlgebra', 'Operator Theory', '(*args)', 'Construct a operator algebra from explicit inputs for Operator Theory.', 'professional_function_catalog.md'), + ('operatorTheoryConstructProjection', 'Operator Theory', '(*args)', 'Construct a projection from explicit inputs for Operator Theory.', 'professional_function_catalog.md'), + ('operatorTheoryConstructSpectrum', 'Operator Theory', '(*args)', 'Construct a spectrum from explicit inputs for Operator Theory.', 'professional_function_catalog.md'), + ('operatorTheoryDecomposeAdjoint', 'Operator Theory', '(value)', 'Decompose a adjoint into simpler or canonical components.', 'professional_function_catalog.md'), + ('operatorTheoryDecomposeOperator', 'Operator Theory', '(value)', 'Decompose a operator into simpler or canonical components.', 'professional_function_catalog.md'), + ('operatorTheoryDecomposeOperatorAlgebra', 'Operator Theory', '(value)', 'Decompose a operator algebra into simpler or canonical components.', 'professional_function_catalog.md'), + ('operatorTheoryDecomposeProjection', 'Operator Theory', '(value)', 'Decompose a projection into simpler or canonical components.', 'professional_function_catalog.md'), + ('operatorTheoryDecomposeSpectrum', 'Operator Theory', '(value)', 'Decompose a spectrum into simpler or canonical components.', 'professional_function_catalog.md'), + ('operatorTheoryDocumentAdjoint', 'Operator Theory', '(value)', 'Return a structured explanation of a adjoint and related assumptions.', 'professional_function_catalog.md'), + ('operatorTheoryDocumentOperator', 'Operator Theory', '(value)', 'Return a structured explanation of a operator and related assumptions.', 'professional_function_catalog.md'), + ('operatorTheoryDocumentOperatorAlgebra', 'Operator Theory', '(value)', 'Return a structured explanation of a operator algebra and related assumptions.', 'professional_function_catalog.md'), + ('operatorTheoryDocumentProjection', 'Operator Theory', '(value)', 'Return a structured explanation of a projection and related assumptions.', 'professional_function_catalog.md'), + ('operatorTheoryDocumentSpectrum', 'Operator Theory', '(value)', 'Return a structured explanation of a spectrum and related assumptions.', 'professional_function_catalog.md'), + ('operatorTheoryEnumerateAdjoint', 'Operator Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a adjoint.', 'professional_function_catalog.md'), + ('operatorTheoryEnumerateOperator', 'Operator Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a operator.', 'professional_function_catalog.md'), + ('operatorTheoryEnumerateOperatorAlgebra', 'Operator Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a operator algebra.', 'professional_function_catalog.md'), + ('operatorTheoryEnumerateProjection', 'Operator Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a projection.', 'professional_function_catalog.md'), + ('operatorTheoryEnumerateSpectrum', 'Operator Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a spectrum.', 'professional_function_catalog.md'), + ('operatorTheoryEstimateAdjoint', 'Operator Theory', '(value, samples=None)', 'Estimate a adjoint property from finite samples or approximations.', 'professional_function_catalog.md'), + ('operatorTheoryEstimateOperator', 'Operator Theory', '(value, samples=None)', 'Estimate a operator property from finite samples or approximations.', 'professional_function_catalog.md'), + ('operatorTheoryEstimateOperatorAlgebra', 'Operator Theory', '(value, samples=None)', 'Estimate a operator algebra property from finite samples or approximations.', 'professional_function_catalog.md'), + ('operatorTheoryEstimateProjection', 'Operator Theory', '(value, samples=None)', 'Estimate a projection property from finite samples or approximations.', 'professional_function_catalog.md'), + ('operatorTheoryEstimateSpectrum', 'Operator Theory', '(value, samples=None)', 'Estimate a spectrum property from finite samples or approximations.', 'professional_function_catalog.md'), + ('operatorTheoryEvaluateAdjoint', 'Operator Theory', '(value, point=None)', 'Evaluate a adjoint at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('operatorTheoryEvaluateOperator', 'Operator Theory', '(value, point=None)', 'Evaluate a operator at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('operatorTheoryEvaluateOperatorAlgebra', 'Operator Theory', '(value, point=None)', 'Evaluate a operator algebra at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('operatorTheoryEvaluateProjection', 'Operator Theory', '(value, point=None)', 'Evaluate a projection at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('operatorTheoryEvaluateSpectrum', 'Operator Theory', '(value, point=None)', 'Evaluate a spectrum at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('operatorTheoryFormatAdjoint', 'Operator Theory', '(value)', 'Format a adjoint for deterministic user-facing output.', 'professional_function_catalog.md'), + ('operatorTheoryFormatOperator', 'Operator Theory', '(value)', 'Format a operator for deterministic user-facing output.', 'professional_function_catalog.md'), + ('operatorTheoryFormatOperatorAlgebra', 'Operator Theory', '(value)', 'Format a operator algebra for deterministic user-facing output.', 'professional_function_catalog.md'), + ('operatorTheoryFormatProjection', 'Operator Theory', '(value)', 'Format a projection for deterministic user-facing output.', 'professional_function_catalog.md'), + ('operatorTheoryFormatSpectrum', 'Operator Theory', '(value)', 'Format a spectrum for deterministic user-facing output.', 'professional_function_catalog.md'), + ('operatorTheoryGenerateExampleAdjoint', 'Operator Theory', '(size=3)', 'Generate a small documented example of a adjoint.', 'professional_function_catalog.md'), + ('operatorTheoryGenerateExampleOperator', 'Operator Theory', '(size=3)', 'Generate a small documented example of a operator.', 'professional_function_catalog.md'), + ('operatorTheoryGenerateExampleOperatorAlgebra', 'Operator Theory', '(size=3)', 'Generate a small documented example of a operator algebra.', 'professional_function_catalog.md'), + ('operatorTheoryGenerateExampleProjection', 'Operator Theory', '(size=3)', 'Generate a small documented example of a projection.', 'professional_function_catalog.md'), + ('operatorTheoryGenerateExampleSpectrum', 'Operator Theory', '(size=3)', 'Generate a small documented example of a spectrum.', 'professional_function_catalog.md'), + ('operatorTheoryNormalizeAdjoint', 'Operator Theory', '(value)', 'Normalize a adjoint into the standard Operator Theory representation.', 'professional_function_catalog.md'), + ('operatorTheoryNormalizeOperator', 'Operator Theory', '(value)', 'Normalize a operator into the standard Operator Theory representation.', 'professional_function_catalog.md'), + ('operatorTheoryNormalizeOperatorAlgebra', 'Operator Theory', '(value)', 'Normalize a operator algebra into the standard Operator Theory representation.', 'professional_function_catalog.md'), + ('operatorTheoryNormalizeProjection', 'Operator Theory', '(value)', 'Normalize a projection into the standard Operator Theory representation.', 'professional_function_catalog.md'), + ('operatorTheoryNormalizeSpectrum', 'Operator Theory', '(value)', 'Normalize a spectrum into the standard Operator Theory representation.', 'professional_function_catalog.md'), + ('operatorTheoryParseAdjoint', 'Operator Theory', '(text)', 'Parse a text or structured value into a adjoint.', 'professional_function_catalog.md'), + ('operatorTheoryParseOperator', 'Operator Theory', '(text)', 'Parse a text or structured value into a operator.', 'professional_function_catalog.md'), + ('operatorTheoryParseOperatorAlgebra', 'Operator Theory', '(text)', 'Parse a text or structured value into a operator algebra.', 'professional_function_catalog.md'), + ('operatorTheoryParseProjection', 'Operator Theory', '(text)', 'Parse a text or structured value into a projection.', 'professional_function_catalog.md'), + ('operatorTheoryParseSpectrum', 'Operator Theory', '(text)', 'Parse a text or structured value into a spectrum.', 'professional_function_catalog.md'), + ('operatorTheorySimplifyAdjoint', 'Operator Theory', '(value)', 'Simplify a adjoint without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('operatorTheorySimplifyOperator', 'Operator Theory', '(value)', 'Simplify a operator without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('operatorTheorySimplifyOperatorAlgebra', 'Operator Theory', '(value)', 'Simplify a operator algebra without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('operatorTheorySimplifyProjection', 'Operator Theory', '(value)', 'Simplify a projection without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('operatorTheorySimplifySpectrum', 'Operator Theory', '(value)', 'Simplify a spectrum without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('operatorTheoryTestEquivalenceAdjoint', 'Operator Theory', '(left, right)', 'Test whether two adjoint values are equivalent in Operator Theory.', 'professional_function_catalog.md'), + ('operatorTheoryTestEquivalenceOperator', 'Operator Theory', '(left, right)', 'Test whether two operator values are equivalent in Operator Theory.', 'professional_function_catalog.md'), + ('operatorTheoryTestEquivalenceOperatorAlgebra', 'Operator Theory', '(left, right)', 'Test whether two operator algebra values are equivalent in Operator Theory.', 'professional_function_catalog.md'), + ('operatorTheoryTestEquivalenceProjection', 'Operator Theory', '(left, right)', 'Test whether two projection values are equivalent in Operator Theory.', 'professional_function_catalog.md'), + ('operatorTheoryTestEquivalenceSpectrum', 'Operator Theory', '(left, right)', 'Test whether two spectrum values are equivalent in Operator Theory.', 'professional_function_catalog.md'), + ('operatorTheoryTransformAdjoint', 'Operator Theory', '(value, mapping)', 'Transform a adjoint through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('operatorTheoryTransformOperator', 'Operator Theory', '(value, mapping)', 'Transform a operator through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('operatorTheoryTransformOperatorAlgebra', 'Operator Theory', '(value, mapping)', 'Transform a operator algebra through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('operatorTheoryTransformProjection', 'Operator Theory', '(value, mapping)', 'Transform a projection through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('operatorTheoryTransformSpectrum', 'Operator Theory', '(value, mapping)', 'Transform a spectrum through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('operatorTheoryValidateAdjoint', 'Operator Theory', '(value)', 'Validate the adjoint representation and domain rules for Operator Theory.', 'professional_function_catalog.md'), + ('operatorTheoryValidateOperator', 'Operator Theory', '(value)', 'Validate the operator representation and domain rules for Operator Theory.', 'professional_function_catalog.md'), + ('operatorTheoryValidateOperatorAlgebra', 'Operator Theory', '(value)', 'Validate the operator algebra representation and domain rules for Operator Theory.', 'professional_function_catalog.md'), + ('operatorTheoryValidateProjection', 'Operator Theory', '(value)', 'Validate the projection representation and domain rules for Operator Theory.', 'professional_function_catalog.md'), + ('operatorTheoryValidateSpectrum', 'Operator Theory', '(value)', 'Validate the spectrum representation and domain rules for Operator Theory.', 'professional_function_catalog.md'), + ('spectralRadius', 'Operator Theory', '(matrix)', 'Planned roadmap function for Operator Theory from upcoming.md.', 'upcoming.md'), + ('barycenterDiscrete', 'Optimal Transport', '(distributions, weights)', 'Planned roadmap function for Optimal Transport from upcoming.md.', 'upcoming.md'), + ('costMatrix', 'Optimal Transport', '(pointsA, pointsB, metric="euclidean")', 'Planned roadmap function for Optimal Transport from upcoming.md.', 'upcoming.md'), + ('earthMoversDistance1D', 'Optimal Transport', '(source, target)', 'Planned roadmap function for Optimal Transport from upcoming.md.', 'upcoming.md'), + ('greedyTransport', 'Optimal Transport', '(source, target, costMatrix)', 'Planned roadmap function for Optimal Transport from upcoming.md.', 'upcoming.md'), + ('isCoupling', 'Optimal Transport', '(coupling, source, target)', 'Planned roadmap function for Optimal Transport from upcoming.md.', 'upcoming.md'), + ('normalizeMeasure', 'Optimal Transport', '(weights)', 'Planned roadmap function for Optimal Transport from upcoming.md.', 'upcoming.md'), + ('optimalTransportApproximateCostMatrix', 'Optimal Transport', '(value, tolerance=1e-9)', 'Approximate a cost matrix with explicit tolerance controls.', 'professional_function_catalog.md'), + ('optimalTransportApproximateCoupling', 'Optimal Transport', '(value, tolerance=1e-9)', 'Approximate a coupling with explicit tolerance controls.', 'professional_function_catalog.md'), + ('optimalTransportApproximateDiscreteMeasure', 'Optimal Transport', '(value, tolerance=1e-9)', 'Approximate a discrete measure with explicit tolerance controls.', 'professional_function_catalog.md'), + ('optimalTransportApproximateTransportPlan', 'Optimal Transport', '(value, tolerance=1e-9)', 'Approximate a transport plan with explicit tolerance controls.', 'professional_function_catalog.md'), + ('optimalTransportApproximateWassersteinEstimate', 'Optimal Transport', '(value, tolerance=1e-9)', 'Approximate a Wasserstein estimate with explicit tolerance controls.', 'professional_function_catalog.md'), + ('optimalTransportCanonicalizeCostMatrix', 'Optimal Transport', '(value)', 'Canonicalize a cost matrix so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('optimalTransportCanonicalizeCoupling', 'Optimal Transport', '(value)', 'Canonicalize a coupling so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('optimalTransportCanonicalizeDiscreteMeasure', 'Optimal Transport', '(value)', 'Canonicalize a discrete measure so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('optimalTransportCanonicalizeTransportPlan', 'Optimal Transport', '(value)', 'Canonicalize a transport plan so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('optimalTransportCanonicalizeWassersteinEstimate', 'Optimal Transport', '(value)', 'Canonicalize a Wasserstein estimate so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('optimalTransportClassifyCostMatrix', 'Optimal Transport', '(value)', 'Classify a cost matrix by its standard Optimal Transport invariants.', 'professional_function_catalog.md'), + ('optimalTransportClassifyCoupling', 'Optimal Transport', '(value)', 'Classify a coupling by its standard Optimal Transport invariants.', 'professional_function_catalog.md'), + ('optimalTransportClassifyDiscreteMeasure', 'Optimal Transport', '(value)', 'Classify a discrete measure by its standard Optimal Transport invariants.', 'professional_function_catalog.md'), + ('optimalTransportClassifyTransportPlan', 'Optimal Transport', '(value)', 'Classify a transport plan by its standard Optimal Transport invariants.', 'professional_function_catalog.md'), + ('optimalTransportClassifyWassersteinEstimate', 'Optimal Transport', '(value)', 'Classify a Wasserstein estimate by its standard Optimal Transport invariants.', 'professional_function_catalog.md'), + ('optimalTransportCombineCostMatrix', 'Optimal Transport', '(left, right)', 'Combine two cost matrix values with the natural operation for Optimal Transport.', 'professional_function_catalog.md'), + ('optimalTransportCombineCoupling', 'Optimal Transport', '(left, right)', 'Combine two coupling values with the natural operation for Optimal Transport.', 'professional_function_catalog.md'), + ('optimalTransportCombineDiscreteMeasure', 'Optimal Transport', '(left, right)', 'Combine two discrete measure values with the natural operation for Optimal Transport.', 'professional_function_catalog.md'), + ('optimalTransportCombineTransportPlan', 'Optimal Transport', '(left, right)', 'Combine two transport plan values with the natural operation for Optimal Transport.', 'professional_function_catalog.md'), + ('optimalTransportCombineWassersteinEstimate', 'Optimal Transport', '(left, right)', 'Combine two Wasserstein estimate values with the natural operation for Optimal Transport.', 'professional_function_catalog.md'), + ('optimalTransportCompareCostMatrix', 'Optimal Transport', '(left, right)', 'Compare two cost matrix values under the conventions of Optimal Transport.', 'professional_function_catalog.md'), + ('optimalTransportCompareCoupling', 'Optimal Transport', '(left, right)', 'Compare two coupling values under the conventions of Optimal Transport.', 'professional_function_catalog.md'), + ('optimalTransportCompareDiscreteMeasure', 'Optimal Transport', '(left, right)', 'Compare two discrete measure values under the conventions of Optimal Transport.', 'professional_function_catalog.md'), + ('optimalTransportCompareTransportPlan', 'Optimal Transport', '(left, right)', 'Compare two transport plan values under the conventions of Optimal Transport.', 'professional_function_catalog.md'), + ('optimalTransportCompareWassersteinEstimate', 'Optimal Transport', '(left, right)', 'Compare two Wasserstein estimate values under the conventions of Optimal Transport.', 'professional_function_catalog.md'), + ('optimalTransportComputeCostMatrix', 'Optimal Transport', '(value)', 'Compute the central numerical or symbolic data of a cost matrix.', 'professional_function_catalog.md'), + ('optimalTransportComputeCoupling', 'Optimal Transport', '(value)', 'Compute the central numerical or symbolic data of a coupling.', 'professional_function_catalog.md'), + ('optimalTransportComputeDiscreteMeasure', 'Optimal Transport', '(value)', 'Compute the central numerical or symbolic data of a discrete measure.', 'professional_function_catalog.md'), + ('optimalTransportComputeTransportPlan', 'Optimal Transport', '(value)', 'Compute the central numerical or symbolic data of a transport plan.', 'professional_function_catalog.md'), + ('optimalTransportComputeWassersteinEstimate', 'Optimal Transport', '(value)', 'Compute the central numerical or symbolic data of a Wasserstein estimate.', 'professional_function_catalog.md'), + ('optimalTransportConstructCostMatrix', 'Optimal Transport', '(*args)', 'Construct a cost matrix from explicit inputs for Optimal Transport.', 'professional_function_catalog.md'), + ('optimalTransportConstructCoupling', 'Optimal Transport', '(*args)', 'Construct a coupling from explicit inputs for Optimal Transport.', 'professional_function_catalog.md'), + ('optimalTransportConstructDiscreteMeasure', 'Optimal Transport', '(*args)', 'Construct a discrete measure from explicit inputs for Optimal Transport.', 'professional_function_catalog.md'), + ('optimalTransportConstructTransportPlan', 'Optimal Transport', '(*args)', 'Construct a transport plan from explicit inputs for Optimal Transport.', 'professional_function_catalog.md'), + ('optimalTransportConstructWassersteinEstimate', 'Optimal Transport', '(*args)', 'Construct a Wasserstein estimate from explicit inputs for Optimal Transport.', 'professional_function_catalog.md'), + ('optimalTransportDecomposeCostMatrix', 'Optimal Transport', '(value)', 'Decompose a cost matrix into simpler or canonical components.', 'professional_function_catalog.md'), + ('optimalTransportDecomposeCoupling', 'Optimal Transport', '(value)', 'Decompose a coupling into simpler or canonical components.', 'professional_function_catalog.md'), + ('optimalTransportDecomposeDiscreteMeasure', 'Optimal Transport', '(value)', 'Decompose a discrete measure into simpler or canonical components.', 'professional_function_catalog.md'), + ('optimalTransportDecomposeTransportPlan', 'Optimal Transport', '(value)', 'Decompose a transport plan into simpler or canonical components.', 'professional_function_catalog.md'), + ('optimalTransportDecomposeWassersteinEstimate', 'Optimal Transport', '(value)', 'Decompose a Wasserstein estimate into simpler or canonical components.', 'professional_function_catalog.md'), + ('optimalTransportDocumentCostMatrix', 'Optimal Transport', '(value)', 'Return a structured explanation of a cost matrix and related assumptions.', 'professional_function_catalog.md'), + ('optimalTransportDocumentCoupling', 'Optimal Transport', '(value)', 'Return a structured explanation of a coupling and related assumptions.', 'professional_function_catalog.md'), + ('optimalTransportDocumentDiscreteMeasure', 'Optimal Transport', '(value)', 'Return a structured explanation of a discrete measure and related assumptions.', 'professional_function_catalog.md'), + ('optimalTransportDocumentTransportPlan', 'Optimal Transport', '(value)', 'Return a structured explanation of a transport plan and related assumptions.', 'professional_function_catalog.md'), + ('optimalTransportDocumentWassersteinEstimate', 'Optimal Transport', '(value)', 'Return a structured explanation of a Wasserstein estimate and related assumptions.', 'professional_function_catalog.md'), + ('optimalTransportEnumerateCostMatrix', 'Optimal Transport', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a cost matrix.', 'professional_function_catalog.md'), + ('optimalTransportEnumerateCoupling', 'Optimal Transport', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a coupling.', 'professional_function_catalog.md'), + ('optimalTransportEnumerateDiscreteMeasure', 'Optimal Transport', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a discrete measure.', 'professional_function_catalog.md'), + ('optimalTransportEnumerateTransportPlan', 'Optimal Transport', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a transport plan.', 'professional_function_catalog.md'), + ('optimalTransportEnumerateWassersteinEstimate', 'Optimal Transport', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a Wasserstein estimate.', 'professional_function_catalog.md'), + ('optimalTransportEstimateCostMatrix', 'Optimal Transport', '(value, samples=None)', 'Estimate a cost matrix property from finite samples or approximations.', 'professional_function_catalog.md'), + ('optimalTransportEstimateCoupling', 'Optimal Transport', '(value, samples=None)', 'Estimate a coupling property from finite samples or approximations.', 'professional_function_catalog.md'), + ('optimalTransportEstimateDiscreteMeasure', 'Optimal Transport', '(value, samples=None)', 'Estimate a discrete measure property from finite samples or approximations.', 'professional_function_catalog.md'), + ('optimalTransportEstimateTransportPlan', 'Optimal Transport', '(value, samples=None)', 'Estimate a transport plan property from finite samples or approximations.', 'professional_function_catalog.md'), + ('optimalTransportEstimateWassersteinEstimate', 'Optimal Transport', '(value, samples=None)', 'Estimate a Wasserstein estimate property from finite samples or approximations.', 'professional_function_catalog.md'), + ('optimalTransportEvaluateCostMatrix', 'Optimal Transport', '(value, point=None)', 'Evaluate a cost matrix at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('optimalTransportEvaluateCoupling', 'Optimal Transport', '(value, point=None)', 'Evaluate a coupling at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('optimalTransportEvaluateDiscreteMeasure', 'Optimal Transport', '(value, point=None)', 'Evaluate a discrete measure at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('optimalTransportEvaluateTransportPlan', 'Optimal Transport', '(value, point=None)', 'Evaluate a transport plan at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('optimalTransportEvaluateWassersteinEstimate', 'Optimal Transport', '(value, point=None)', 'Evaluate a Wasserstein estimate at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('optimalTransportFormatCostMatrix', 'Optimal Transport', '(value)', 'Format a cost matrix for deterministic user-facing output.', 'professional_function_catalog.md'), + ('optimalTransportFormatCoupling', 'Optimal Transport', '(value)', 'Format a coupling for deterministic user-facing output.', 'professional_function_catalog.md'), + ('optimalTransportFormatDiscreteMeasure', 'Optimal Transport', '(value)', 'Format a discrete measure for deterministic user-facing output.', 'professional_function_catalog.md'), + ('optimalTransportFormatTransportPlan', 'Optimal Transport', '(value)', 'Format a transport plan for deterministic user-facing output.', 'professional_function_catalog.md'), + ('optimalTransportFormatWassersteinEstimate', 'Optimal Transport', '(value)', 'Format a Wasserstein estimate for deterministic user-facing output.', 'professional_function_catalog.md'), + ('optimalTransportGenerateExampleCostMatrix', 'Optimal Transport', '(size=3)', 'Generate a small documented example of a cost matrix.', 'professional_function_catalog.md'), + ('optimalTransportGenerateExampleCoupling', 'Optimal Transport', '(size=3)', 'Generate a small documented example of a coupling.', 'professional_function_catalog.md'), + ('optimalTransportGenerateExampleDiscreteMeasure', 'Optimal Transport', '(size=3)', 'Generate a small documented example of a discrete measure.', 'professional_function_catalog.md'), + ('optimalTransportGenerateExampleTransportPlan', 'Optimal Transport', '(size=3)', 'Generate a small documented example of a transport plan.', 'professional_function_catalog.md'), + ('optimalTransportGenerateExampleWassersteinEstimate', 'Optimal Transport', '(size=3)', 'Generate a small documented example of a Wasserstein estimate.', 'professional_function_catalog.md'), + ('optimalTransportNormalizeCostMatrix', 'Optimal Transport', '(value)', 'Normalize a cost matrix into the standard Optimal Transport representation.', 'professional_function_catalog.md'), + ('optimalTransportNormalizeCoupling', 'Optimal Transport', '(value)', 'Normalize a coupling into the standard Optimal Transport representation.', 'professional_function_catalog.md'), + ('optimalTransportNormalizeDiscreteMeasure', 'Optimal Transport', '(value)', 'Normalize a discrete measure into the standard Optimal Transport representation.', 'professional_function_catalog.md'), + ('optimalTransportNormalizeTransportPlan', 'Optimal Transport', '(value)', 'Normalize a transport plan into the standard Optimal Transport representation.', 'professional_function_catalog.md'), + ('optimalTransportNormalizeWassersteinEstimate', 'Optimal Transport', '(value)', 'Normalize a Wasserstein estimate into the standard Optimal Transport representation.', 'professional_function_catalog.md'), + ('optimalTransportParseCostMatrix', 'Optimal Transport', '(text)', 'Parse a text or structured value into a cost matrix.', 'professional_function_catalog.md'), + ('optimalTransportParseCoupling', 'Optimal Transport', '(text)', 'Parse a text or structured value into a coupling.', 'professional_function_catalog.md'), + ('optimalTransportParseDiscreteMeasure', 'Optimal Transport', '(text)', 'Parse a text or structured value into a discrete measure.', 'professional_function_catalog.md'), + ('optimalTransportParseTransportPlan', 'Optimal Transport', '(text)', 'Parse a text or structured value into a transport plan.', 'professional_function_catalog.md'), + ('optimalTransportParseWassersteinEstimate', 'Optimal Transport', '(text)', 'Parse a text or structured value into a Wasserstein estimate.', 'professional_function_catalog.md'), + ('optimalTransportSimplifyCostMatrix', 'Optimal Transport', '(value)', 'Simplify a cost matrix without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('optimalTransportSimplifyCoupling', 'Optimal Transport', '(value)', 'Simplify a coupling without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('optimalTransportSimplifyDiscreteMeasure', 'Optimal Transport', '(value)', 'Simplify a discrete measure without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('optimalTransportSimplifyTransportPlan', 'Optimal Transport', '(value)', 'Simplify a transport plan without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('optimalTransportSimplifyWassersteinEstimate', 'Optimal Transport', '(value)', 'Simplify a Wasserstein estimate without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('optimalTransportTestEquivalenceCostMatrix', 'Optimal Transport', '(left, right)', 'Test whether two cost matrix values are equivalent in Optimal Transport.', 'professional_function_catalog.md'), + ('optimalTransportTestEquivalenceCoupling', 'Optimal Transport', '(left, right)', 'Test whether two coupling values are equivalent in Optimal Transport.', 'professional_function_catalog.md'), + ('optimalTransportTestEquivalenceDiscreteMeasure', 'Optimal Transport', '(left, right)', 'Test whether two discrete measure values are equivalent in Optimal Transport.', 'professional_function_catalog.md'), + ('optimalTransportTestEquivalenceTransportPlan', 'Optimal Transport', '(left, right)', 'Test whether two transport plan values are equivalent in Optimal Transport.', 'professional_function_catalog.md'), + ('optimalTransportTestEquivalenceWassersteinEstimate', 'Optimal Transport', '(left, right)', 'Test whether two Wasserstein estimate values are equivalent in Optimal Transport.', 'professional_function_catalog.md'), + ('optimalTransportTransformCostMatrix', 'Optimal Transport', '(value, mapping)', 'Transform a cost matrix through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('optimalTransportTransformCoupling', 'Optimal Transport', '(value, mapping)', 'Transform a coupling through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('optimalTransportTransformDiscreteMeasure', 'Optimal Transport', '(value, mapping)', 'Transform a discrete measure through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('optimalTransportTransformTransportPlan', 'Optimal Transport', '(value, mapping)', 'Transform a transport plan through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('optimalTransportTransformWassersteinEstimate', 'Optimal Transport', '(value, mapping)', 'Transform a Wasserstein estimate through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('optimalTransportValidateCostMatrix', 'Optimal Transport', '(value)', 'Validate the cost matrix representation and domain rules for Optimal Transport.', 'professional_function_catalog.md'), + ('optimalTransportValidateCoupling', 'Optimal Transport', '(value)', 'Validate the coupling representation and domain rules for Optimal Transport.', 'professional_function_catalog.md'), + ('optimalTransportValidateDiscreteMeasure', 'Optimal Transport', '(value)', 'Validate the discrete measure representation and domain rules for Optimal Transport.', 'professional_function_catalog.md'), + ('optimalTransportValidateTransportPlan', 'Optimal Transport', '(value)', 'Validate the transport plan representation and domain rules for Optimal Transport.', 'professional_function_catalog.md'), + ('optimalTransportValidateWassersteinEstimate', 'Optimal Transport', '(value)', 'Validate the Wasserstein estimate representation and domain rules for Optimal Transport.', 'professional_function_catalog.md'), + ('transportCost', 'Optimal Transport', '(coupling, costMatrix)', 'Planned roadmap function for Optimal Transport from upcoming.md.', 'upcoming.md'), + ('wasserstein1D', 'Optimal Transport', '(sourceValues, targetValues, weightsA=None, weightsB=None)', 'Planned roadmap function for Optimal Transport from upcoming.md.', 'upcoming.md'), + ('argMaxFunction', 'Optimization', '(f, candidates)', 'Planned roadmap function for Optimization from upcoming.md.', 'upcoming.md'), + ('argMinFunction', 'Optimization', '(f, candidates)', 'Planned roadmap function for Optimization from upcoming.md.', 'upcoming.md'), + ('convexOnSamples', 'Optimization', '(values)', 'Planned roadmap function for Optimization from upcoming.md.', 'upcoming.md'), + ('coordinateDescent', 'Optimization', '(f, start, step, iterations)', 'Planned roadmap function for Optimization from upcoming.md.', 'upcoming.md'), + ('goldenSectionSearch', 'Optimization', '(f, a, b, tolerance=1e-9)', 'Planned roadmap function for Optimization from upcoming.md.', 'upcoming.md'), + ('gradientDescent', 'Optimization', '(f, gradientFunction, start, learningRate, steps)', 'Planned roadmap function for Optimization from upcoming.md.', 'upcoming.md'), + ('optimizationApproximateConstraintSet', 'Optimization', '(value, tolerance=1e-9)', 'Approximate a constraint set with explicit tolerance controls.', 'professional_function_catalog.md'), + ('optimizationApproximateDescentStep', 'Optimization', '(value, tolerance=1e-9)', 'Approximate a descent step with explicit tolerance controls.', 'professional_function_catalog.md'), + ('optimizationApproximateObjectiveFunction', 'Optimization', '(value, tolerance=1e-9)', 'Approximate a objective function with explicit tolerance controls.', 'professional_function_catalog.md'), + ('optimizationApproximateOptimalityCondition', 'Optimization', '(value, tolerance=1e-9)', 'Approximate a optimality condition with explicit tolerance controls.', 'professional_function_catalog.md'), + ('optimizationApproximateSearchState', 'Optimization', '(value, tolerance=1e-9)', 'Approximate a search state with explicit tolerance controls.', 'professional_function_catalog.md'), + ('optimizationCanonicalizeConstraintSet', 'Optimization', '(value)', 'Canonicalize a constraint set so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('optimizationCanonicalizeDescentStep', 'Optimization', '(value)', 'Canonicalize a descent step so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('optimizationCanonicalizeObjectiveFunction', 'Optimization', '(value)', 'Canonicalize a objective function so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('optimizationCanonicalizeOptimalityCondition', 'Optimization', '(value)', 'Canonicalize a optimality condition so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('optimizationCanonicalizeSearchState', 'Optimization', '(value)', 'Canonicalize a search state so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('optimizationClassifyConstraintSet', 'Optimization', '(value)', 'Classify a constraint set by its standard Optimization invariants.', 'professional_function_catalog.md'), + ('optimizationClassifyDescentStep', 'Optimization', '(value)', 'Classify a descent step by its standard Optimization invariants.', 'professional_function_catalog.md'), + ('optimizationClassifyObjectiveFunction', 'Optimization', '(value)', 'Classify a objective function by its standard Optimization invariants.', 'professional_function_catalog.md'), + ('optimizationClassifyOptimalityCondition', 'Optimization', '(value)', 'Classify a optimality condition by its standard Optimization invariants.', 'professional_function_catalog.md'), + ('optimizationClassifySearchState', 'Optimization', '(value)', 'Classify a search state by its standard Optimization invariants.', 'professional_function_catalog.md'), + ('optimizationCombineConstraintSet', 'Optimization', '(left, right)', 'Combine two constraint set values with the natural operation for Optimization.', 'professional_function_catalog.md'), + ('optimizationCombineDescentStep', 'Optimization', '(left, right)', 'Combine two descent step values with the natural operation for Optimization.', 'professional_function_catalog.md'), + ('optimizationCombineObjectiveFunction', 'Optimization', '(left, right)', 'Combine two objective function values with the natural operation for Optimization.', 'professional_function_catalog.md'), + ('optimizationCombineOptimalityCondition', 'Optimization', '(left, right)', 'Combine two optimality condition values with the natural operation for Optimization.', 'professional_function_catalog.md'), + ('optimizationCombineSearchState', 'Optimization', '(left, right)', 'Combine two search state values with the natural operation for Optimization.', 'professional_function_catalog.md'), + ('optimizationCompareConstraintSet', 'Optimization', '(left, right)', 'Compare two constraint set values under the conventions of Optimization.', 'professional_function_catalog.md'), + ('optimizationCompareDescentStep', 'Optimization', '(left, right)', 'Compare two descent step values under the conventions of Optimization.', 'professional_function_catalog.md'), + ('optimizationCompareObjectiveFunction', 'Optimization', '(left, right)', 'Compare two objective function values under the conventions of Optimization.', 'professional_function_catalog.md'), + ('optimizationCompareOptimalityCondition', 'Optimization', '(left, right)', 'Compare two optimality condition values under the conventions of Optimization.', 'professional_function_catalog.md'), + ('optimizationCompareSearchState', 'Optimization', '(left, right)', 'Compare two search state values under the conventions of Optimization.', 'professional_function_catalog.md'), + ('optimizationComputeConstraintSet', 'Optimization', '(value)', 'Compute the central numerical or symbolic data of a constraint set.', 'professional_function_catalog.md'), + ('optimizationComputeDescentStep', 'Optimization', '(value)', 'Compute the central numerical or symbolic data of a descent step.', 'professional_function_catalog.md'), + ('optimizationComputeObjectiveFunction', 'Optimization', '(value)', 'Compute the central numerical or symbolic data of a objective function.', 'professional_function_catalog.md'), + ('optimizationComputeOptimalityCondition', 'Optimization', '(value)', 'Compute the central numerical or symbolic data of a optimality condition.', 'professional_function_catalog.md'), + ('optimizationComputeSearchState', 'Optimization', '(value)', 'Compute the central numerical or symbolic data of a search state.', 'professional_function_catalog.md'), + ('optimizationConstructConstraintSet', 'Optimization', '(*args)', 'Construct a constraint set from explicit inputs for Optimization.', 'professional_function_catalog.md'), + ('optimizationConstructDescentStep', 'Optimization', '(*args)', 'Construct a descent step from explicit inputs for Optimization.', 'professional_function_catalog.md'), + ('optimizationConstructObjectiveFunction', 'Optimization', '(*args)', 'Construct a objective function from explicit inputs for Optimization.', 'professional_function_catalog.md'), + ('optimizationConstructOptimalityCondition', 'Optimization', '(*args)', 'Construct a optimality condition from explicit inputs for Optimization.', 'professional_function_catalog.md'), + ('optimizationConstructSearchState', 'Optimization', '(*args)', 'Construct a search state from explicit inputs for Optimization.', 'professional_function_catalog.md'), + ('optimizationDecomposeConstraintSet', 'Optimization', '(value)', 'Decompose a constraint set into simpler or canonical components.', 'professional_function_catalog.md'), + ('optimizationDecomposeDescentStep', 'Optimization', '(value)', 'Decompose a descent step into simpler or canonical components.', 'professional_function_catalog.md'), + ('optimizationDecomposeObjectiveFunction', 'Optimization', '(value)', 'Decompose a objective function into simpler or canonical components.', 'professional_function_catalog.md'), + ('optimizationDecomposeOptimalityCondition', 'Optimization', '(value)', 'Decompose a optimality condition into simpler or canonical components.', 'professional_function_catalog.md'), + ('optimizationDecomposeSearchState', 'Optimization', '(value)', 'Decompose a search state into simpler or canonical components.', 'professional_function_catalog.md'), + ('optimizationDocumentConstraintSet', 'Optimization', '(value)', 'Return a structured explanation of a constraint set and related assumptions.', 'professional_function_catalog.md'), + ('optimizationDocumentDescentStep', 'Optimization', '(value)', 'Return a structured explanation of a descent step and related assumptions.', 'professional_function_catalog.md'), + ('optimizationDocumentObjectiveFunction', 'Optimization', '(value)', 'Return a structured explanation of a objective function and related assumptions.', 'professional_function_catalog.md'), + ('optimizationDocumentOptimalityCondition', 'Optimization', '(value)', 'Return a structured explanation of a optimality condition and related assumptions.', 'professional_function_catalog.md'), + ('optimizationDocumentSearchState', 'Optimization', '(value)', 'Return a structured explanation of a search state and related assumptions.', 'professional_function_catalog.md'), + ('optimizationEnumerateConstraintSet', 'Optimization', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a constraint set.', 'professional_function_catalog.md'), + ('optimizationEnumerateDescentStep', 'Optimization', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a descent step.', 'professional_function_catalog.md'), + ('optimizationEnumerateObjectiveFunction', 'Optimization', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a objective function.', 'professional_function_catalog.md'), + ('optimizationEnumerateOptimalityCondition', 'Optimization', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a optimality condition.', 'professional_function_catalog.md'), + ('optimizationEnumerateSearchState', 'Optimization', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a search state.', 'professional_function_catalog.md'), + ('optimizationEstimateConstraintSet', 'Optimization', '(value, samples=None)', 'Estimate a constraint set property from finite samples or approximations.', 'professional_function_catalog.md'), + ('optimizationEstimateDescentStep', 'Optimization', '(value, samples=None)', 'Estimate a descent step property from finite samples or approximations.', 'professional_function_catalog.md'), + ('optimizationEstimateObjectiveFunction', 'Optimization', '(value, samples=None)', 'Estimate a objective function property from finite samples or approximations.', 'professional_function_catalog.md'), + ('optimizationEstimateOptimalityCondition', 'Optimization', '(value, samples=None)', 'Estimate a optimality condition property from finite samples or approximations.', 'professional_function_catalog.md'), + ('optimizationEstimateSearchState', 'Optimization', '(value, samples=None)', 'Estimate a search state property from finite samples or approximations.', 'professional_function_catalog.md'), + ('optimizationEvaluateConstraintSet', 'Optimization', '(value, point=None)', 'Evaluate a constraint set at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('optimizationEvaluateDescentStep', 'Optimization', '(value, point=None)', 'Evaluate a descent step at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('optimizationEvaluateObjectiveFunction', 'Optimization', '(value, point=None)', 'Evaluate a objective function at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('optimizationEvaluateOptimalityCondition', 'Optimization', '(value, point=None)', 'Evaluate a optimality condition at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('optimizationEvaluateSearchState', 'Optimization', '(value, point=None)', 'Evaluate a search state at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('optimizationFormatConstraintSet', 'Optimization', '(value)', 'Format a constraint set for deterministic user-facing output.', 'professional_function_catalog.md'), + ('optimizationFormatDescentStep', 'Optimization', '(value)', 'Format a descent step for deterministic user-facing output.', 'professional_function_catalog.md'), + ('optimizationFormatObjectiveFunction', 'Optimization', '(value)', 'Format a objective function for deterministic user-facing output.', 'professional_function_catalog.md'), + ('optimizationFormatOptimalityCondition', 'Optimization', '(value)', 'Format a optimality condition for deterministic user-facing output.', 'professional_function_catalog.md'), + ('optimizationFormatSearchState', 'Optimization', '(value)', 'Format a search state for deterministic user-facing output.', 'professional_function_catalog.md'), + ('optimizationGenerateExampleConstraintSet', 'Optimization', '(size=3)', 'Generate a small documented example of a constraint set.', 'professional_function_catalog.md'), + ('optimizationGenerateExampleDescentStep', 'Optimization', '(size=3)', 'Generate a small documented example of a descent step.', 'professional_function_catalog.md'), + ('optimizationGenerateExampleObjectiveFunction', 'Optimization', '(size=3)', 'Generate a small documented example of a objective function.', 'professional_function_catalog.md'), + ('optimizationGenerateExampleOptimalityCondition', 'Optimization', '(size=3)', 'Generate a small documented example of a optimality condition.', 'professional_function_catalog.md'), + ('optimizationGenerateExampleSearchState', 'Optimization', '(size=3)', 'Generate a small documented example of a search state.', 'professional_function_catalog.md'), + ('optimizationNormalizeConstraintSet', 'Optimization', '(value)', 'Normalize a constraint set into the standard Optimization representation.', 'professional_function_catalog.md'), + ('optimizationNormalizeDescentStep', 'Optimization', '(value)', 'Normalize a descent step into the standard Optimization representation.', 'professional_function_catalog.md'), + ('optimizationNormalizeObjectiveFunction', 'Optimization', '(value)', 'Normalize a objective function into the standard Optimization representation.', 'professional_function_catalog.md'), + ('optimizationNormalizeOptimalityCondition', 'Optimization', '(value)', 'Normalize a optimality condition into the standard Optimization representation.', 'professional_function_catalog.md'), + ('optimizationNormalizeSearchState', 'Optimization', '(value)', 'Normalize a search state into the standard Optimization representation.', 'professional_function_catalog.md'), + ('optimizationParseConstraintSet', 'Optimization', '(text)', 'Parse a text or structured value into a constraint set.', 'professional_function_catalog.md'), + ('optimizationParseDescentStep', 'Optimization', '(text)', 'Parse a text or structured value into a descent step.', 'professional_function_catalog.md'), + ('optimizationParseObjectiveFunction', 'Optimization', '(text)', 'Parse a text or structured value into a objective function.', 'professional_function_catalog.md'), + ('optimizationParseOptimalityCondition', 'Optimization', '(text)', 'Parse a text or structured value into a optimality condition.', 'professional_function_catalog.md'), + ('optimizationParseSearchState', 'Optimization', '(text)', 'Parse a text or structured value into a search state.', 'professional_function_catalog.md'), + ('optimizationSimplifyConstraintSet', 'Optimization', '(value)', 'Simplify a constraint set without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('optimizationSimplifyDescentStep', 'Optimization', '(value)', 'Simplify a descent step without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('optimizationSimplifyObjectiveFunction', 'Optimization', '(value)', 'Simplify a objective function without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('optimizationSimplifyOptimalityCondition', 'Optimization', '(value)', 'Simplify a optimality condition without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('optimizationSimplifySearchState', 'Optimization', '(value)', 'Simplify a search state without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('optimizationTestEquivalenceConstraintSet', 'Optimization', '(left, right)', 'Test whether two constraint set values are equivalent in Optimization.', 'professional_function_catalog.md'), + ('optimizationTestEquivalenceDescentStep', 'Optimization', '(left, right)', 'Test whether two descent step values are equivalent in Optimization.', 'professional_function_catalog.md'), + ('optimizationTestEquivalenceObjectiveFunction', 'Optimization', '(left, right)', 'Test whether two objective function values are equivalent in Optimization.', 'professional_function_catalog.md'), + ('optimizationTestEquivalenceOptimalityCondition', 'Optimization', '(left, right)', 'Test whether two optimality condition values are equivalent in Optimization.', 'professional_function_catalog.md'), + ('optimizationTestEquivalenceSearchState', 'Optimization', '(left, right)', 'Test whether two search state values are equivalent in Optimization.', 'professional_function_catalog.md'), + ('optimizationTransformConstraintSet', 'Optimization', '(value, mapping)', 'Transform a constraint set through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('optimizationTransformDescentStep', 'Optimization', '(value, mapping)', 'Transform a descent step through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('optimizationTransformObjectiveFunction', 'Optimization', '(value, mapping)', 'Transform a objective function through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('optimizationTransformOptimalityCondition', 'Optimization', '(value, mapping)', 'Transform a optimality condition through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('optimizationTransformSearchState', 'Optimization', '(value, mapping)', 'Transform a search state through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('optimizationValidateConstraintSet', 'Optimization', '(value)', 'Validate the constraint set representation and domain rules for Optimization.', 'professional_function_catalog.md'), + ('optimizationValidateDescentStep', 'Optimization', '(value)', 'Validate the descent step representation and domain rules for Optimization.', 'professional_function_catalog.md'), + ('optimizationValidateObjectiveFunction', 'Optimization', '(value)', 'Validate the objective function representation and domain rules for Optimization.', 'professional_function_catalog.md'), + ('optimizationValidateOptimalityCondition', 'Optimization', '(value)', 'Validate the optimality condition representation and domain rules for Optimization.', 'professional_function_catalog.md'), + ('optimizationValidateSearchState', 'Optimization', '(value)', 'Validate the search state representation and domain rules for Optimization.', 'professional_function_catalog.md'), + ('projectToInterval', 'Optimization', '(x, lower, upper)', 'Planned roadmap function for Optimization from upcoming.md.', 'upcoming.md'), + ('isAntisymmetricRelation', 'Order Theory', '(relation, elements)', 'Planned roadmap function for Order Theory from upcoming.md.', 'upcoming.md'), + ('isPartialOrder', 'Order Theory', '(relation, elements)', 'Planned roadmap function for Order Theory from upcoming.md.', 'upcoming.md'), + ('isReflexiveRelation', 'Order Theory', '(relation, elements)', 'Planned roadmap function for Order Theory from upcoming.md.', 'upcoming.md'), + ('isTotalOrder', 'Order Theory', '(relation, elements)', 'Planned roadmap function for Order Theory from upcoming.md.', 'upcoming.md'), + ('isTransitiveRelation', 'Order Theory', '(relation, elements)', 'Planned roadmap function for Order Theory from upcoming.md.', 'upcoming.md'), + ('maximalElements', 'Order Theory', '(elements, orderRelation)', 'Planned roadmap function for Order Theory from upcoming.md.', 'upcoming.md'), + ('minimalElements', 'Order Theory', '(elements, orderRelation)', 'Planned roadmap function for Order Theory from upcoming.md.', 'upcoming.md'), + ('orderTheoryApproximateAntichain', 'Order Theory', '(value, tolerance=1e-9)', 'Approximate a antichain with explicit tolerance controls.', 'professional_function_catalog.md'), + ('orderTheoryApproximateChain', 'Order Theory', '(value, tolerance=1e-9)', 'Approximate a chain with explicit tolerance controls.', 'professional_function_catalog.md'), + ('orderTheoryApproximateMinimalElement', 'Order Theory', '(value, tolerance=1e-9)', 'Approximate a minimal element with explicit tolerance controls.', 'professional_function_catalog.md'), + ('orderTheoryApproximateOrderedSet', 'Order Theory', '(value, tolerance=1e-9)', 'Approximate a ordered set with explicit tolerance controls.', 'professional_function_catalog.md'), + ('orderTheoryApproximateOrderRelation', 'Order Theory', '(value, tolerance=1e-9)', 'Approximate a order relation with explicit tolerance controls.', 'professional_function_catalog.md'), + ('orderTheoryCanonicalizeAntichain', 'Order Theory', '(value)', 'Canonicalize a antichain so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('orderTheoryCanonicalizeChain', 'Order Theory', '(value)', 'Canonicalize a chain so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('orderTheoryCanonicalizeMinimalElement', 'Order Theory', '(value)', 'Canonicalize a minimal element so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('orderTheoryCanonicalizeOrderedSet', 'Order Theory', '(value)', 'Canonicalize a ordered set so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('orderTheoryCanonicalizeOrderRelation', 'Order Theory', '(value)', 'Canonicalize a order relation so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('orderTheoryClassifyAntichain', 'Order Theory', '(value)', 'Classify a antichain by its standard Order Theory invariants.', 'professional_function_catalog.md'), + ('orderTheoryClassifyChain', 'Order Theory', '(value)', 'Classify a chain by its standard Order Theory invariants.', 'professional_function_catalog.md'), + ('orderTheoryClassifyMinimalElement', 'Order Theory', '(value)', 'Classify a minimal element by its standard Order Theory invariants.', 'professional_function_catalog.md'), + ('orderTheoryClassifyOrderedSet', 'Order Theory', '(value)', 'Classify a ordered set by its standard Order Theory invariants.', 'professional_function_catalog.md'), + ('orderTheoryClassifyOrderRelation', 'Order Theory', '(value)', 'Classify a order relation by its standard Order Theory invariants.', 'professional_function_catalog.md'), + ('orderTheoryCombineAntichain', 'Order Theory', '(left, right)', 'Combine two antichain values with the natural operation for Order Theory.', 'professional_function_catalog.md'), + ('orderTheoryCombineChain', 'Order Theory', '(left, right)', 'Combine two chain values with the natural operation for Order Theory.', 'professional_function_catalog.md'), + ('orderTheoryCombineMinimalElement', 'Order Theory', '(left, right)', 'Combine two minimal element values with the natural operation for Order Theory.', 'professional_function_catalog.md'), + ('orderTheoryCombineOrderedSet', 'Order Theory', '(left, right)', 'Combine two ordered set values with the natural operation for Order Theory.', 'professional_function_catalog.md'), + ('orderTheoryCombineOrderRelation', 'Order Theory', '(left, right)', 'Combine two order relation values with the natural operation for Order Theory.', 'professional_function_catalog.md'), + ('orderTheoryCompareAntichain', 'Order Theory', '(left, right)', 'Compare two antichain values under the conventions of Order Theory.', 'professional_function_catalog.md'), + ('orderTheoryCompareChain', 'Order Theory', '(left, right)', 'Compare two chain values under the conventions of Order Theory.', 'professional_function_catalog.md'), + ('orderTheoryCompareMinimalElement', 'Order Theory', '(left, right)', 'Compare two minimal element values under the conventions of Order Theory.', 'professional_function_catalog.md'), + ('orderTheoryCompareOrderedSet', 'Order Theory', '(left, right)', 'Compare two ordered set values under the conventions of Order Theory.', 'professional_function_catalog.md'), + ('orderTheoryCompareOrderRelation', 'Order Theory', '(left, right)', 'Compare two order relation values under the conventions of Order Theory.', 'professional_function_catalog.md'), + ('orderTheoryComputeAntichain', 'Order Theory', '(value)', 'Compute the central numerical or symbolic data of a antichain.', 'professional_function_catalog.md'), + ('orderTheoryComputeChain', 'Order Theory', '(value)', 'Compute the central numerical or symbolic data of a chain.', 'professional_function_catalog.md'), + ('orderTheoryComputeMinimalElement', 'Order Theory', '(value)', 'Compute the central numerical or symbolic data of a minimal element.', 'professional_function_catalog.md'), + ('orderTheoryComputeOrderedSet', 'Order Theory', '(value)', 'Compute the central numerical or symbolic data of a ordered set.', 'professional_function_catalog.md'), + ('orderTheoryComputeOrderRelation', 'Order Theory', '(value)', 'Compute the central numerical or symbolic data of a order relation.', 'professional_function_catalog.md'), + ('orderTheoryConstructAntichain', 'Order Theory', '(*args)', 'Construct a antichain from explicit inputs for Order Theory.', 'professional_function_catalog.md'), + ('orderTheoryConstructChain', 'Order Theory', '(*args)', 'Construct a chain from explicit inputs for Order Theory.', 'professional_function_catalog.md'), + ('orderTheoryConstructMinimalElement', 'Order Theory', '(*args)', 'Construct a minimal element from explicit inputs for Order Theory.', 'professional_function_catalog.md'), + ('orderTheoryConstructOrderedSet', 'Order Theory', '(*args)', 'Construct a ordered set from explicit inputs for Order Theory.', 'professional_function_catalog.md'), + ('orderTheoryConstructOrderRelation', 'Order Theory', '(*args)', 'Construct a order relation from explicit inputs for Order Theory.', 'professional_function_catalog.md'), + ('orderTheoryDecomposeAntichain', 'Order Theory', '(value)', 'Decompose a antichain into simpler or canonical components.', 'professional_function_catalog.md'), + ('orderTheoryDecomposeChain', 'Order Theory', '(value)', 'Decompose a chain into simpler or canonical components.', 'professional_function_catalog.md'), + ('orderTheoryDecomposeMinimalElement', 'Order Theory', '(value)', 'Decompose a minimal element into simpler or canonical components.', 'professional_function_catalog.md'), + ('orderTheoryDecomposeOrderedSet', 'Order Theory', '(value)', 'Decompose a ordered set into simpler or canonical components.', 'professional_function_catalog.md'), + ('orderTheoryDecomposeOrderRelation', 'Order Theory', '(value)', 'Decompose a order relation into simpler or canonical components.', 'professional_function_catalog.md'), + ('orderTheoryDocumentAntichain', 'Order Theory', '(value)', 'Return a structured explanation of a antichain and related assumptions.', 'professional_function_catalog.md'), + ('orderTheoryDocumentChain', 'Order Theory', '(value)', 'Return a structured explanation of a chain and related assumptions.', 'professional_function_catalog.md'), + ('orderTheoryDocumentMinimalElement', 'Order Theory', '(value)', 'Return a structured explanation of a minimal element and related assumptions.', 'professional_function_catalog.md'), + ('orderTheoryDocumentOrderedSet', 'Order Theory', '(value)', 'Return a structured explanation of a ordered set and related assumptions.', 'professional_function_catalog.md'), + ('orderTheoryDocumentOrderRelation', 'Order Theory', '(value)', 'Return a structured explanation of a order relation and related assumptions.', 'professional_function_catalog.md'), + ('orderTheoryEnumerateAntichain', 'Order Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a antichain.', 'professional_function_catalog.md'), + ('orderTheoryEnumerateChain', 'Order Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a chain.', 'professional_function_catalog.md'), + ('orderTheoryEnumerateMinimalElement', 'Order Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a minimal element.', 'professional_function_catalog.md'), + ('orderTheoryEnumerateOrderedSet', 'Order Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a ordered set.', 'professional_function_catalog.md'), + ('orderTheoryEnumerateOrderRelation', 'Order Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a order relation.', 'professional_function_catalog.md'), + ('orderTheoryEstimateAntichain', 'Order Theory', '(value, samples=None)', 'Estimate a antichain property from finite samples or approximations.', 'professional_function_catalog.md'), + ('orderTheoryEstimateChain', 'Order Theory', '(value, samples=None)', 'Estimate a chain property from finite samples or approximations.', 'professional_function_catalog.md'), + ('orderTheoryEstimateMinimalElement', 'Order Theory', '(value, samples=None)', 'Estimate a minimal element property from finite samples or approximations.', 'professional_function_catalog.md'), + ('orderTheoryEstimateOrderedSet', 'Order Theory', '(value, samples=None)', 'Estimate a ordered set property from finite samples or approximations.', 'professional_function_catalog.md'), + ('orderTheoryEstimateOrderRelation', 'Order Theory', '(value, samples=None)', 'Estimate a order relation property from finite samples or approximations.', 'professional_function_catalog.md'), + ('orderTheoryEvaluateAntichain', 'Order Theory', '(value, point=None)', 'Evaluate a antichain at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('orderTheoryEvaluateChain', 'Order Theory', '(value, point=None)', 'Evaluate a chain at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('orderTheoryEvaluateMinimalElement', 'Order Theory', '(value, point=None)', 'Evaluate a minimal element at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('orderTheoryEvaluateOrderedSet', 'Order Theory', '(value, point=None)', 'Evaluate a ordered set at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('orderTheoryEvaluateOrderRelation', 'Order Theory', '(value, point=None)', 'Evaluate a order relation at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('orderTheoryFormatAntichain', 'Order Theory', '(value)', 'Format a antichain for deterministic user-facing output.', 'professional_function_catalog.md'), + ('orderTheoryFormatChain', 'Order Theory', '(value)', 'Format a chain for deterministic user-facing output.', 'professional_function_catalog.md'), + ('orderTheoryFormatMinimalElement', 'Order Theory', '(value)', 'Format a minimal element for deterministic user-facing output.', 'professional_function_catalog.md'), + ('orderTheoryFormatOrderedSet', 'Order Theory', '(value)', 'Format a ordered set for deterministic user-facing output.', 'professional_function_catalog.md'), + ('orderTheoryFormatOrderRelation', 'Order Theory', '(value)', 'Format a order relation for deterministic user-facing output.', 'professional_function_catalog.md'), + ('orderTheoryGenerateExampleAntichain', 'Order Theory', '(size=3)', 'Generate a small documented example of a antichain.', 'professional_function_catalog.md'), + ('orderTheoryGenerateExampleChain', 'Order Theory', '(size=3)', 'Generate a small documented example of a chain.', 'professional_function_catalog.md'), + ('orderTheoryGenerateExampleMinimalElement', 'Order Theory', '(size=3)', 'Generate a small documented example of a minimal element.', 'professional_function_catalog.md'), + ('orderTheoryGenerateExampleOrderedSet', 'Order Theory', '(size=3)', 'Generate a small documented example of a ordered set.', 'professional_function_catalog.md'), + ('orderTheoryGenerateExampleOrderRelation', 'Order Theory', '(size=3)', 'Generate a small documented example of a order relation.', 'professional_function_catalog.md'), + ('orderTheoryNormalizeAntichain', 'Order Theory', '(value)', 'Normalize a antichain into the standard Order Theory representation.', 'professional_function_catalog.md'), + ('orderTheoryNormalizeChain', 'Order Theory', '(value)', 'Normalize a chain into the standard Order Theory representation.', 'professional_function_catalog.md'), + ('orderTheoryNormalizeMinimalElement', 'Order Theory', '(value)', 'Normalize a minimal element into the standard Order Theory representation.', 'professional_function_catalog.md'), + ('orderTheoryNormalizeOrderedSet', 'Order Theory', '(value)', 'Normalize a ordered set into the standard Order Theory representation.', 'professional_function_catalog.md'), + ('orderTheoryNormalizeOrderRelation', 'Order Theory', '(value)', 'Normalize a order relation into the standard Order Theory representation.', 'professional_function_catalog.md'), + ('orderTheoryParseAntichain', 'Order Theory', '(text)', 'Parse a text or structured value into a antichain.', 'professional_function_catalog.md'), + ('orderTheoryParseChain', 'Order Theory', '(text)', 'Parse a text or structured value into a chain.', 'professional_function_catalog.md'), + ('orderTheoryParseMinimalElement', 'Order Theory', '(text)', 'Parse a text or structured value into a minimal element.', 'professional_function_catalog.md'), + ('orderTheoryParseOrderedSet', 'Order Theory', '(text)', 'Parse a text or structured value into a ordered set.', 'professional_function_catalog.md'), + ('orderTheoryParseOrderRelation', 'Order Theory', '(text)', 'Parse a text or structured value into a order relation.', 'professional_function_catalog.md'), + ('orderTheorySimplifyAntichain', 'Order Theory', '(value)', 'Simplify a antichain without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('orderTheorySimplifyChain', 'Order Theory', '(value)', 'Simplify a chain without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('orderTheorySimplifyMinimalElement', 'Order Theory', '(value)', 'Simplify a minimal element without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('orderTheorySimplifyOrderedSet', 'Order Theory', '(value)', 'Simplify a ordered set without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('orderTheorySimplifyOrderRelation', 'Order Theory', '(value)', 'Simplify a order relation without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('orderTheoryTestEquivalenceAntichain', 'Order Theory', '(left, right)', 'Test whether two antichain values are equivalent in Order Theory.', 'professional_function_catalog.md'), + ('orderTheoryTestEquivalenceChain', 'Order Theory', '(left, right)', 'Test whether two chain values are equivalent in Order Theory.', 'professional_function_catalog.md'), + ('orderTheoryTestEquivalenceMinimalElement', 'Order Theory', '(left, right)', 'Test whether two minimal element values are equivalent in Order Theory.', 'professional_function_catalog.md'), + ('orderTheoryTestEquivalenceOrderedSet', 'Order Theory', '(left, right)', 'Test whether two ordered set values are equivalent in Order Theory.', 'professional_function_catalog.md'), + ('orderTheoryTestEquivalenceOrderRelation', 'Order Theory', '(left, right)', 'Test whether two order relation values are equivalent in Order Theory.', 'professional_function_catalog.md'), + ('orderTheoryTransformAntichain', 'Order Theory', '(value, mapping)', 'Transform a antichain through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('orderTheoryTransformChain', 'Order Theory', '(value, mapping)', 'Transform a chain through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('orderTheoryTransformMinimalElement', 'Order Theory', '(value, mapping)', 'Transform a minimal element through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('orderTheoryTransformOrderedSet', 'Order Theory', '(value, mapping)', 'Transform a ordered set through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('orderTheoryTransformOrderRelation', 'Order Theory', '(value, mapping)', 'Transform a order relation through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('orderTheoryValidateAntichain', 'Order Theory', '(value)', 'Validate the antichain representation and domain rules for Order Theory.', 'professional_function_catalog.md'), + ('orderTheoryValidateChain', 'Order Theory', '(value)', 'Validate the chain representation and domain rules for Order Theory.', 'professional_function_catalog.md'), + ('orderTheoryValidateMinimalElement', 'Order Theory', '(value)', 'Validate the minimal element representation and domain rules for Order Theory.', 'professional_function_catalog.md'), + ('orderTheoryValidateOrderedSet', 'Order Theory', '(value)', 'Validate the ordered set representation and domain rules for Order Theory.', 'professional_function_catalog.md'), + ('orderTheoryValidateOrderRelation', 'Order Theory', '(value)', 'Validate the order relation representation and domain rules for Order Theory.', 'professional_function_catalog.md'), + ('topologicalSort', 'Order Theory', '(poset)', 'Planned roadmap function for Order Theory from upcoming.md.', 'upcoming.md'), + ('eulerODE', 'Ordinary Differential Equations', '(f, x0, y0, h, steps)', 'Planned roadmap function for Ordinary Differential Equations from upcoming.md.', 'upcoming.md'), + ('improvedEulerODE', 'Ordinary Differential Equations', '(f, x0, y0, h, steps)', 'Planned roadmap function for Ordinary Differential Equations from upcoming.md.', 'upcoming.md'), + ('isEquilibriumPoint', 'Ordinary Differential Equations', '(f, y)', 'Planned roadmap function for Ordinary Differential Equations from upcoming.md.', 'upcoming.md'), + ('linearFirstOrderSolution', 'Ordinary Differential Equations', '(p, q, x0, y0)', 'Planned roadmap function for Ordinary Differential Equations from upcoming.md.', 'upcoming.md'), + ('ordinaryDifferentialEquationsApproximateEquilibrium', 'Ordinary Differential Equations', '(value, tolerance=1e-9)', 'Approximate a equilibrium with explicit tolerance controls.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsApproximateInitialValueProblem', 'Ordinary Differential Equations', '(value, tolerance=1e-9)', 'Approximate a initial value problem with explicit tolerance controls.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsApproximateOdeModel', 'Ordinary Differential Equations', '(value, tolerance=1e-9)', 'Approximate a ode model with explicit tolerance controls.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsApproximateSolutionCurve', 'Ordinary Differential Equations', '(value, tolerance=1e-9)', 'Approximate a solution curve with explicit tolerance controls.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsApproximateSolverStep', 'Ordinary Differential Equations', '(value, tolerance=1e-9)', 'Approximate a solver step with explicit tolerance controls.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsCanonicalizeEquilibrium', 'Ordinary Differential Equations', '(value)', 'Canonicalize a equilibrium so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsCanonicalizeInitialValueProblem', 'Ordinary Differential Equations', '(value)', 'Canonicalize a initial value problem so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsCanonicalizeOdeModel', 'Ordinary Differential Equations', '(value)', 'Canonicalize a ode model so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsCanonicalizeSolutionCurve', 'Ordinary Differential Equations', '(value)', 'Canonicalize a solution curve so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsCanonicalizeSolverStep', 'Ordinary Differential Equations', '(value)', 'Canonicalize a solver step so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsClassifyEquilibrium', 'Ordinary Differential Equations', '(value)', 'Classify a equilibrium by its standard Ordinary Differential Equations invariants.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsClassifyInitialValueProblem', 'Ordinary Differential Equations', '(value)', 'Classify a initial value problem by its standard Ordinary Differential Equations invariants.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsClassifyOdeModel', 'Ordinary Differential Equations', '(value)', 'Classify a ode model by its standard Ordinary Differential Equations invariants.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsClassifySolutionCurve', 'Ordinary Differential Equations', '(value)', 'Classify a solution curve by its standard Ordinary Differential Equations invariants.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsClassifySolverStep', 'Ordinary Differential Equations', '(value)', 'Classify a solver step by its standard Ordinary Differential Equations invariants.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsCombineEquilibrium', 'Ordinary Differential Equations', '(left, right)', 'Combine two equilibrium values with the natural operation for Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsCombineInitialValueProblem', 'Ordinary Differential Equations', '(left, right)', 'Combine two initial value problem values with the natural operation for Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsCombineOdeModel', 'Ordinary Differential Equations', '(left, right)', 'Combine two ode model values with the natural operation for Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsCombineSolutionCurve', 'Ordinary Differential Equations', '(left, right)', 'Combine two solution curve values with the natural operation for Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsCombineSolverStep', 'Ordinary Differential Equations', '(left, right)', 'Combine two solver step values with the natural operation for Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsCompareEquilibrium', 'Ordinary Differential Equations', '(left, right)', 'Compare two equilibrium values under the conventions of Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsCompareInitialValueProblem', 'Ordinary Differential Equations', '(left, right)', 'Compare two initial value problem values under the conventions of Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsCompareOdeModel', 'Ordinary Differential Equations', '(left, right)', 'Compare two ode model values under the conventions of Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsCompareSolutionCurve', 'Ordinary Differential Equations', '(left, right)', 'Compare two solution curve values under the conventions of Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsCompareSolverStep', 'Ordinary Differential Equations', '(left, right)', 'Compare two solver step values under the conventions of Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsComputeEquilibrium', 'Ordinary Differential Equations', '(value)', 'Compute the central numerical or symbolic data of a equilibrium.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsComputeInitialValueProblem', 'Ordinary Differential Equations', '(value)', 'Compute the central numerical or symbolic data of a initial value problem.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsComputeOdeModel', 'Ordinary Differential Equations', '(value)', 'Compute the central numerical or symbolic data of a ode model.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsComputeSolutionCurve', 'Ordinary Differential Equations', '(value)', 'Compute the central numerical or symbolic data of a solution curve.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsComputeSolverStep', 'Ordinary Differential Equations', '(value)', 'Compute the central numerical or symbolic data of a solver step.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsConstructEquilibrium', 'Ordinary Differential Equations', '(*args)', 'Construct a equilibrium from explicit inputs for Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsConstructInitialValueProblem', 'Ordinary Differential Equations', '(*args)', 'Construct a initial value problem from explicit inputs for Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsConstructOdeModel', 'Ordinary Differential Equations', '(*args)', 'Construct a ode model from explicit inputs for Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsConstructSolutionCurve', 'Ordinary Differential Equations', '(*args)', 'Construct a solution curve from explicit inputs for Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsConstructSolverStep', 'Ordinary Differential Equations', '(*args)', 'Construct a solver step from explicit inputs for Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsDecomposeEquilibrium', 'Ordinary Differential Equations', '(value)', 'Decompose a equilibrium into simpler or canonical components.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsDecomposeInitialValueProblem', 'Ordinary Differential Equations', '(value)', 'Decompose a initial value problem into simpler or canonical components.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsDecomposeOdeModel', 'Ordinary Differential Equations', '(value)', 'Decompose a ode model into simpler or canonical components.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsDecomposeSolutionCurve', 'Ordinary Differential Equations', '(value)', 'Decompose a solution curve into simpler or canonical components.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsDecomposeSolverStep', 'Ordinary Differential Equations', '(value)', 'Decompose a solver step into simpler or canonical components.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsDocumentEquilibrium', 'Ordinary Differential Equations', '(value)', 'Return a structured explanation of a equilibrium and related assumptions.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsDocumentInitialValueProblem', 'Ordinary Differential Equations', '(value)', 'Return a structured explanation of a initial value problem and related assumptions.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsDocumentOdeModel', 'Ordinary Differential Equations', '(value)', 'Return a structured explanation of a ode model and related assumptions.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsDocumentSolutionCurve', 'Ordinary Differential Equations', '(value)', 'Return a structured explanation of a solution curve and related assumptions.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsDocumentSolverStep', 'Ordinary Differential Equations', '(value)', 'Return a structured explanation of a solver step and related assumptions.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsEnumerateEquilibrium', 'Ordinary Differential Equations', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a equilibrium.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsEnumerateInitialValueProblem', 'Ordinary Differential Equations', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a initial value problem.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsEnumerateOdeModel', 'Ordinary Differential Equations', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a ode model.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsEnumerateSolutionCurve', 'Ordinary Differential Equations', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a solution curve.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsEnumerateSolverStep', 'Ordinary Differential Equations', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a solver step.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsEstimateEquilibrium', 'Ordinary Differential Equations', '(value, samples=None)', 'Estimate a equilibrium property from finite samples or approximations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsEstimateInitialValueProblem', 'Ordinary Differential Equations', '(value, samples=None)', 'Estimate a initial value problem property from finite samples or approximations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsEstimateOdeModel', 'Ordinary Differential Equations', '(value, samples=None)', 'Estimate a ode model property from finite samples or approximations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsEstimateSolutionCurve', 'Ordinary Differential Equations', '(value, samples=None)', 'Estimate a solution curve property from finite samples or approximations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsEstimateSolverStep', 'Ordinary Differential Equations', '(value, samples=None)', 'Estimate a solver step property from finite samples or approximations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsEvaluateEquilibrium', 'Ordinary Differential Equations', '(value, point=None)', 'Evaluate a equilibrium at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsEvaluateInitialValueProblem', 'Ordinary Differential Equations', '(value, point=None)', 'Evaluate a initial value problem at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsEvaluateOdeModel', 'Ordinary Differential Equations', '(value, point=None)', 'Evaluate a ode model at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsEvaluateSolutionCurve', 'Ordinary Differential Equations', '(value, point=None)', 'Evaluate a solution curve at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsEvaluateSolverStep', 'Ordinary Differential Equations', '(value, point=None)', 'Evaluate a solver step at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsFormatEquilibrium', 'Ordinary Differential Equations', '(value)', 'Format a equilibrium for deterministic user-facing output.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsFormatInitialValueProblem', 'Ordinary Differential Equations', '(value)', 'Format a initial value problem for deterministic user-facing output.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsFormatOdeModel', 'Ordinary Differential Equations', '(value)', 'Format a ode model for deterministic user-facing output.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsFormatSolutionCurve', 'Ordinary Differential Equations', '(value)', 'Format a solution curve for deterministic user-facing output.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsFormatSolverStep', 'Ordinary Differential Equations', '(value)', 'Format a solver step for deterministic user-facing output.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsGenerateExampleEquilibrium', 'Ordinary Differential Equations', '(size=3)', 'Generate a small documented example of a equilibrium.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsGenerateExampleInitialValueProblem', 'Ordinary Differential Equations', '(size=3)', 'Generate a small documented example of a initial value problem.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsGenerateExampleOdeModel', 'Ordinary Differential Equations', '(size=3)', 'Generate a small documented example of a ode model.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsGenerateExampleSolutionCurve', 'Ordinary Differential Equations', '(size=3)', 'Generate a small documented example of a solution curve.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsGenerateExampleSolverStep', 'Ordinary Differential Equations', '(size=3)', 'Generate a small documented example of a solver step.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsNormalizeEquilibrium', 'Ordinary Differential Equations', '(value)', 'Normalize a equilibrium into the standard Ordinary Differential Equations representation.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsNormalizeInitialValueProblem', 'Ordinary Differential Equations', '(value)', 'Normalize a initial value problem into the standard Ordinary Differential Equations representation.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsNormalizeOdeModel', 'Ordinary Differential Equations', '(value)', 'Normalize a ode model into the standard Ordinary Differential Equations representation.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsNormalizeSolutionCurve', 'Ordinary Differential Equations', '(value)', 'Normalize a solution curve into the standard Ordinary Differential Equations representation.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsNormalizeSolverStep', 'Ordinary Differential Equations', '(value)', 'Normalize a solver step into the standard Ordinary Differential Equations representation.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsParseEquilibrium', 'Ordinary Differential Equations', '(text)', 'Parse a text or structured value into a equilibrium.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsParseInitialValueProblem', 'Ordinary Differential Equations', '(text)', 'Parse a text or structured value into a initial value problem.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsParseOdeModel', 'Ordinary Differential Equations', '(text)', 'Parse a text or structured value into a ode model.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsParseSolutionCurve', 'Ordinary Differential Equations', '(text)', 'Parse a text or structured value into a solution curve.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsParseSolverStep', 'Ordinary Differential Equations', '(text)', 'Parse a text or structured value into a solver step.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsSimplifyEquilibrium', 'Ordinary Differential Equations', '(value)', 'Simplify a equilibrium without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsSimplifyInitialValueProblem', 'Ordinary Differential Equations', '(value)', 'Simplify a initial value problem without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsSimplifyOdeModel', 'Ordinary Differential Equations', '(value)', 'Simplify a ode model without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsSimplifySolutionCurve', 'Ordinary Differential Equations', '(value)', 'Simplify a solution curve without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsSimplifySolverStep', 'Ordinary Differential Equations', '(value)', 'Simplify a solver step without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsTestEquivalenceEquilibrium', 'Ordinary Differential Equations', '(left, right)', 'Test whether two equilibrium values are equivalent in Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsTestEquivalenceInitialValueProblem', 'Ordinary Differential Equations', '(left, right)', 'Test whether two initial value problem values are equivalent in Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsTestEquivalenceOdeModel', 'Ordinary Differential Equations', '(left, right)', 'Test whether two ode model values are equivalent in Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsTestEquivalenceSolutionCurve', 'Ordinary Differential Equations', '(left, right)', 'Test whether two solution curve values are equivalent in Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsTestEquivalenceSolverStep', 'Ordinary Differential Equations', '(left, right)', 'Test whether two solver step values are equivalent in Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsTransformEquilibrium', 'Ordinary Differential Equations', '(value, mapping)', 'Transform a equilibrium through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsTransformInitialValueProblem', 'Ordinary Differential Equations', '(value, mapping)', 'Transform a initial value problem through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsTransformOdeModel', 'Ordinary Differential Equations', '(value, mapping)', 'Transform a ode model through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsTransformSolutionCurve', 'Ordinary Differential Equations', '(value, mapping)', 'Transform a solution curve through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsTransformSolverStep', 'Ordinary Differential Equations', '(value, mapping)', 'Transform a solver step through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsValidateEquilibrium', 'Ordinary Differential Equations', '(value)', 'Validate the equilibrium representation and domain rules for Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsValidateInitialValueProblem', 'Ordinary Differential Equations', '(value)', 'Validate the initial value problem representation and domain rules for Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsValidateOdeModel', 'Ordinary Differential Equations', '(value)', 'Validate the ode model representation and domain rules for Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsValidateSolutionCurve', 'Ordinary Differential Equations', '(value)', 'Validate the solution curve representation and domain rules for Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('ordinaryDifferentialEquationsValidateSolverStep', 'Ordinary Differential Equations', '(value)', 'Validate the solver step representation and domain rules for Ordinary Differential Equations.', 'professional_function_catalog.md'), + ('rungeKuttaODE', 'Ordinary Differential Equations', '(f, x0, y0, h, steps)', 'Planned roadmap function for Ordinary Differential Equations from upcoming.md.', 'upcoming.md'), + ('separableStep', 'Ordinary Differential Equations', '(f, x, y, h)', 'Planned roadmap function for Ordinary Differential Equations from upcoming.md.', 'upcoming.md'), + ('slopeField', 'Ordinary Differential Equations', '(f, xValues, yValues)', 'Planned roadmap function for Ordinary Differential Equations from upcoming.md.', 'upcoming.md'), + ('dirichletBoundary', 'Partial Differential Equations', '(grid, value)', 'Planned roadmap function for Partial Differential Equations from upcoming.md.', 'upcoming.md'), + ('finiteDifferenceGrid', 'Partial Differential Equations', '(xPoints, tPoints)', 'Planned roadmap function for Partial Differential Equations from upcoming.md.', 'upcoming.md'), + ('heatEquationStep', 'Partial Differential Equations', '(grid, alpha, dt, dx)', 'Planned roadmap function for Partial Differential Equations from upcoming.md.', 'upcoming.md'), + ('laplacian2D', 'Partial Differential Equations', '(grid, i, j, h)', 'Planned roadmap function for Partial Differential Equations from upcoming.md.', 'upcoming.md'), + ('neumannBoundary', 'Partial Differential Equations', '(grid, derivative)', 'Planned roadmap function for Partial Differential Equations from upcoming.md.', 'upcoming.md'), + ('partialDifferentialEquationsApproximateBoundaryCondition', 'Partial Differential Equations', '(value, tolerance=1e-9)', 'Approximate a boundary condition with explicit tolerance controls.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsApproximateDifferenceStencil', 'Partial Differential Equations', '(value, tolerance=1e-9)', 'Approximate a difference stencil with explicit tolerance controls.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsApproximateGridFunction', 'Partial Differential Equations', '(value, tolerance=1e-9)', 'Approximate a grid function with explicit tolerance controls.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsApproximatePdeModel', 'Partial Differential Equations', '(value, tolerance=1e-9)', 'Approximate a pde model with explicit tolerance controls.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsApproximateStabilityCondition', 'Partial Differential Equations', '(value, tolerance=1e-9)', 'Approximate a stability condition with explicit tolerance controls.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsCanonicalizeBoundaryCondition', 'Partial Differential Equations', '(value)', 'Canonicalize a boundary condition so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsCanonicalizeDifferenceStencil', 'Partial Differential Equations', '(value)', 'Canonicalize a difference stencil so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsCanonicalizeGridFunction', 'Partial Differential Equations', '(value)', 'Canonicalize a grid function so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsCanonicalizePdeModel', 'Partial Differential Equations', '(value)', 'Canonicalize a pde model so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsCanonicalizeStabilityCondition', 'Partial Differential Equations', '(value)', 'Canonicalize a stability condition so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsClassifyBoundaryCondition', 'Partial Differential Equations', '(value)', 'Classify a boundary condition by its standard Partial Differential Equations invariants.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsClassifyDifferenceStencil', 'Partial Differential Equations', '(value)', 'Classify a difference stencil by its standard Partial Differential Equations invariants.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsClassifyGridFunction', 'Partial Differential Equations', '(value)', 'Classify a grid function by its standard Partial Differential Equations invariants.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsClassifyPdeModel', 'Partial Differential Equations', '(value)', 'Classify a pde model by its standard Partial Differential Equations invariants.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsClassifyStabilityCondition', 'Partial Differential Equations', '(value)', 'Classify a stability condition by its standard Partial Differential Equations invariants.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsCombineBoundaryCondition', 'Partial Differential Equations', '(left, right)', 'Combine two boundary condition values with the natural operation for Partial Differential Equations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsCombineDifferenceStencil', 'Partial Differential Equations', '(left, right)', 'Combine two difference stencil values with the natural operation for Partial Differential Equations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsCombineGridFunction', 'Partial Differential Equations', '(left, right)', 'Combine two grid function values with the natural operation for Partial Differential Equations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsCombinePdeModel', 'Partial Differential Equations', '(left, right)', 'Combine two pde model values with the natural operation for Partial Differential Equations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsCombineStabilityCondition', 'Partial Differential Equations', '(left, right)', 'Combine two stability condition values with the natural operation for Partial Differential Equations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsCompareBoundaryCondition', 'Partial Differential Equations', '(left, right)', 'Compare two boundary condition values under the conventions of Partial Differential Equations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsCompareDifferenceStencil', 'Partial Differential Equations', '(left, right)', 'Compare two difference stencil values under the conventions of Partial Differential Equations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsCompareGridFunction', 'Partial Differential Equations', '(left, right)', 'Compare two grid function values under the conventions of Partial Differential Equations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsComparePdeModel', 'Partial Differential Equations', '(left, right)', 'Compare two pde model values under the conventions of Partial Differential Equations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsCompareStabilityCondition', 'Partial Differential Equations', '(left, right)', 'Compare two stability condition values under the conventions of Partial Differential Equations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsComputeBoundaryCondition', 'Partial Differential Equations', '(value)', 'Compute the central numerical or symbolic data of a boundary condition.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsComputeDifferenceStencil', 'Partial Differential Equations', '(value)', 'Compute the central numerical or symbolic data of a difference stencil.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsComputeGridFunction', 'Partial Differential Equations', '(value)', 'Compute the central numerical or symbolic data of a grid function.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsComputePdeModel', 'Partial Differential Equations', '(value)', 'Compute the central numerical or symbolic data of a pde model.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsComputeStabilityCondition', 'Partial Differential Equations', '(value)', 'Compute the central numerical or symbolic data of a stability condition.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsConstructBoundaryCondition', 'Partial Differential Equations', '(*args)', 'Construct a boundary condition from explicit inputs for Partial Differential Equations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsConstructDifferenceStencil', 'Partial Differential Equations', '(*args)', 'Construct a difference stencil from explicit inputs for Partial Differential Equations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsConstructGridFunction', 'Partial Differential Equations', '(*args)', 'Construct a grid function from explicit inputs for Partial Differential Equations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsConstructPdeModel', 'Partial Differential Equations', '(*args)', 'Construct a pde model from explicit inputs for Partial Differential Equations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsConstructStabilityCondition', 'Partial Differential Equations', '(*args)', 'Construct a stability condition from explicit inputs for Partial Differential Equations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsDecomposeBoundaryCondition', 'Partial Differential Equations', '(value)', 'Decompose a boundary condition into simpler or canonical components.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsDecomposeDifferenceStencil', 'Partial Differential Equations', '(value)', 'Decompose a difference stencil into simpler or canonical components.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsDecomposeGridFunction', 'Partial Differential Equations', '(value)', 'Decompose a grid function into simpler or canonical components.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsDecomposePdeModel', 'Partial Differential Equations', '(value)', 'Decompose a pde model into simpler or canonical components.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsDecomposeStabilityCondition', 'Partial Differential Equations', '(value)', 'Decompose a stability condition into simpler or canonical components.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsDocumentBoundaryCondition', 'Partial Differential Equations', '(value)', 'Return a structured explanation of a boundary condition and related assumptions.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsDocumentDifferenceStencil', 'Partial Differential Equations', '(value)', 'Return a structured explanation of a difference stencil and related assumptions.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsDocumentGridFunction', 'Partial Differential Equations', '(value)', 'Return a structured explanation of a grid function and related assumptions.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsDocumentPdeModel', 'Partial Differential Equations', '(value)', 'Return a structured explanation of a pde model and related assumptions.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsDocumentStabilityCondition', 'Partial Differential Equations', '(value)', 'Return a structured explanation of a stability condition and related assumptions.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsEnumerateBoundaryCondition', 'Partial Differential Equations', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a boundary condition.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsEnumerateDifferenceStencil', 'Partial Differential Equations', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a difference stencil.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsEnumerateGridFunction', 'Partial Differential Equations', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a grid function.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsEnumeratePdeModel', 'Partial Differential Equations', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a pde model.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsEnumerateStabilityCondition', 'Partial Differential Equations', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a stability condition.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsEstimateBoundaryCondition', 'Partial Differential Equations', '(value, samples=None)', 'Estimate a boundary condition property from finite samples or approximations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsEstimateDifferenceStencil', 'Partial Differential Equations', '(value, samples=None)', 'Estimate a difference stencil property from finite samples or approximations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsEstimateGridFunction', 'Partial Differential Equations', '(value, samples=None)', 'Estimate a grid function property from finite samples or approximations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsEstimatePdeModel', 'Partial Differential Equations', '(value, samples=None)', 'Estimate a pde model property from finite samples or approximations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsEstimateStabilityCondition', 'Partial Differential Equations', '(value, samples=None)', 'Estimate a stability condition property from finite samples or approximations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsEvaluateBoundaryCondition', 'Partial Differential Equations', '(value, point=None)', 'Evaluate a boundary condition at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsEvaluateDifferenceStencil', 'Partial Differential Equations', '(value, point=None)', 'Evaluate a difference stencil at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsEvaluateGridFunction', 'Partial Differential Equations', '(value, point=None)', 'Evaluate a grid function at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsEvaluatePdeModel', 'Partial Differential Equations', '(value, point=None)', 'Evaluate a pde model at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsEvaluateStabilityCondition', 'Partial Differential Equations', '(value, point=None)', 'Evaluate a stability condition at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsFormatBoundaryCondition', 'Partial Differential Equations', '(value)', 'Format a boundary condition for deterministic user-facing output.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsFormatDifferenceStencil', 'Partial Differential Equations', '(value)', 'Format a difference stencil for deterministic user-facing output.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsFormatGridFunction', 'Partial Differential Equations', '(value)', 'Format a grid function for deterministic user-facing output.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsFormatPdeModel', 'Partial Differential Equations', '(value)', 'Format a pde model for deterministic user-facing output.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsFormatStabilityCondition', 'Partial Differential Equations', '(value)', 'Format a stability condition for deterministic user-facing output.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsGenerateExampleBoundaryCondition', 'Partial Differential Equations', '(size=3)', 'Generate a small documented example of a boundary condition.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsGenerateExampleDifferenceStencil', 'Partial Differential Equations', '(size=3)', 'Generate a small documented example of a difference stencil.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsGenerateExampleGridFunction', 'Partial Differential Equations', '(size=3)', 'Generate a small documented example of a grid function.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsGenerateExamplePdeModel', 'Partial Differential Equations', '(size=3)', 'Generate a small documented example of a pde model.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsGenerateExampleStabilityCondition', 'Partial Differential Equations', '(size=3)', 'Generate a small documented example of a stability condition.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsNormalizeBoundaryCondition', 'Partial Differential Equations', '(value)', 'Normalize a boundary condition into the standard Partial Differential Equations representation.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsNormalizeDifferenceStencil', 'Partial Differential Equations', '(value)', 'Normalize a difference stencil into the standard Partial Differential Equations representation.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsNormalizeGridFunction', 'Partial Differential Equations', '(value)', 'Normalize a grid function into the standard Partial Differential Equations representation.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsNormalizePdeModel', 'Partial Differential Equations', '(value)', 'Normalize a pde model into the standard Partial Differential Equations representation.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsNormalizeStabilityCondition', 'Partial Differential Equations', '(value)', 'Normalize a stability condition into the standard Partial Differential Equations representation.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsParseBoundaryCondition', 'Partial Differential Equations', '(text)', 'Parse a text or structured value into a boundary condition.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsParseDifferenceStencil', 'Partial Differential Equations', '(text)', 'Parse a text or structured value into a difference stencil.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsParseGridFunction', 'Partial Differential Equations', '(text)', 'Parse a text or structured value into a grid function.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsParsePdeModel', 'Partial Differential Equations', '(text)', 'Parse a text or structured value into a pde model.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsParseStabilityCondition', 'Partial Differential Equations', '(text)', 'Parse a text or structured value into a stability condition.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsSimplifyBoundaryCondition', 'Partial Differential Equations', '(value)', 'Simplify a boundary condition without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsSimplifyDifferenceStencil', 'Partial Differential Equations', '(value)', 'Simplify a difference stencil without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsSimplifyGridFunction', 'Partial Differential Equations', '(value)', 'Simplify a grid function without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsSimplifyPdeModel', 'Partial Differential Equations', '(value)', 'Simplify a pde model without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsSimplifyStabilityCondition', 'Partial Differential Equations', '(value)', 'Simplify a stability condition without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsTestEquivalenceBoundaryCondition', 'Partial Differential Equations', '(left, right)', 'Test whether two boundary condition values are equivalent in Partial Differential Equations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsTestEquivalenceDifferenceStencil', 'Partial Differential Equations', '(left, right)', 'Test whether two difference stencil values are equivalent in Partial Differential Equations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsTestEquivalenceGridFunction', 'Partial Differential Equations', '(left, right)', 'Test whether two grid function values are equivalent in Partial Differential Equations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsTestEquivalencePdeModel', 'Partial Differential Equations', '(left, right)', 'Test whether two pde model values are equivalent in Partial Differential Equations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsTestEquivalenceStabilityCondition', 'Partial Differential Equations', '(left, right)', 'Test whether two stability condition values are equivalent in Partial Differential Equations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsTransformBoundaryCondition', 'Partial Differential Equations', '(value, mapping)', 'Transform a boundary condition through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsTransformDifferenceStencil', 'Partial Differential Equations', '(value, mapping)', 'Transform a difference stencil through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsTransformGridFunction', 'Partial Differential Equations', '(value, mapping)', 'Transform a grid function through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsTransformPdeModel', 'Partial Differential Equations', '(value, mapping)', 'Transform a pde model through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsTransformStabilityCondition', 'Partial Differential Equations', '(value, mapping)', 'Transform a stability condition through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsValidateBoundaryCondition', 'Partial Differential Equations', '(value)', 'Validate the boundary condition representation and domain rules for Partial Differential Equations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsValidateDifferenceStencil', 'Partial Differential Equations', '(value)', 'Validate the difference stencil representation and domain rules for Partial Differential Equations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsValidateGridFunction', 'Partial Differential Equations', '(value)', 'Validate the grid function representation and domain rules for Partial Differential Equations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsValidatePdeModel', 'Partial Differential Equations', '(value)', 'Validate the pde model representation and domain rules for Partial Differential Equations.', 'professional_function_catalog.md'), + ('partialDifferentialEquationsValidateStabilityCondition', 'Partial Differential Equations', '(value)', 'Validate the stability condition representation and domain rules for Partial Differential Equations.', 'professional_function_catalog.md'), + ('solveLaplace2D', 'Partial Differential Equations', '(boundaryGrid, iterations)', 'Planned roadmap function for Partial Differential Equations from upcoming.md.', 'upcoming.md'), + ('stabilityHeatEquation', 'Partial Differential Equations', '(alpha, dt, dx)', 'Planned roadmap function for Partial Differential Equations from upcoming.md.', 'upcoming.md'), + ('waveEquationStep', 'Partial Differential Equations', '(previous, current, c, dt, dx)', 'Planned roadmap function for Partial Differential Equations from upcoming.md.', 'upcoming.md'), + ('polyAdd', 'Polynomials', '(p, q)', 'Planned roadmap function for Polynomials from upcoming.md.', 'upcoming.md'), + ('polyDegree', 'Polynomials', '(coefficients)', 'Planned roadmap function for Polynomials from upcoming.md.', 'upcoming.md'), + ('polyDerivative', 'Polynomials', '(coefficients)', 'Planned roadmap function for Polynomials from upcoming.md.', 'upcoming.md'), + ('polyGcd', 'Polynomials', '(p, q)', 'Planned roadmap function for Polynomials from upcoming.md.', 'upcoming.md'), + ('polyIntegral', 'Polynomials', '(coefficients, constant=0)', 'Planned roadmap function for Polynomials from upcoming.md.', 'upcoming.md'), + ('polyLeadingCoefficient', 'Polynomials', '(coefficients)', 'Planned roadmap function for Polynomials from upcoming.md.', 'upcoming.md'), + ('polyMultiply', 'Polynomials', '(p, q)', 'Planned roadmap function for Polynomials from upcoming.md.', 'upcoming.md'), + ('polynomialsApproximateCoefficientList', 'Polynomials', '(value, tolerance=1e-9)', 'Approximate a coefficient list with explicit tolerance controls.', 'professional_function_catalog.md'), + ('polynomialsApproximateFactorization', 'Polynomials', '(value, tolerance=1e-9)', 'Approximate a factorization with explicit tolerance controls.', 'professional_function_catalog.md'), + ('polynomialsApproximatePolynomial', 'Polynomials', '(value, tolerance=1e-9)', 'Approximate a polynomial with explicit tolerance controls.', 'professional_function_catalog.md'), + ('polynomialsApproximatePolynomialQuotient', 'Polynomials', '(value, tolerance=1e-9)', 'Approximate a polynomial quotient with explicit tolerance controls.', 'professional_function_catalog.md'), + ('polynomialsApproximateRootSet', 'Polynomials', '(value, tolerance=1e-9)', 'Approximate a root set with explicit tolerance controls.', 'professional_function_catalog.md'), + ('polynomialsCanonicalizeCoefficientList', 'Polynomials', '(value)', 'Canonicalize a coefficient list so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('polynomialsCanonicalizeFactorization', 'Polynomials', '(value)', 'Canonicalize a factorization so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('polynomialsCanonicalizePolynomial', 'Polynomials', '(value)', 'Canonicalize a polynomial so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('polynomialsCanonicalizePolynomialQuotient', 'Polynomials', '(value)', 'Canonicalize a polynomial quotient so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('polynomialsCanonicalizeRootSet', 'Polynomials', '(value)', 'Canonicalize a root set so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('polynomialsClassifyCoefficientList', 'Polynomials', '(value)', 'Classify a coefficient list by its standard Polynomials invariants.', 'professional_function_catalog.md'), + ('polynomialsClassifyFactorization', 'Polynomials', '(value)', 'Classify a factorization by its standard Polynomials invariants.', 'professional_function_catalog.md'), + ('polynomialsClassifyPolynomial', 'Polynomials', '(value)', 'Classify a polynomial by its standard Polynomials invariants.', 'professional_function_catalog.md'), + ('polynomialsClassifyPolynomialQuotient', 'Polynomials', '(value)', 'Classify a polynomial quotient by its standard Polynomials invariants.', 'professional_function_catalog.md'), + ('polynomialsClassifyRootSet', 'Polynomials', '(value)', 'Classify a root set by its standard Polynomials invariants.', 'professional_function_catalog.md'), + ('polynomialsCombineCoefficientList', 'Polynomials', '(left, right)', 'Combine two coefficient list values with the natural operation for Polynomials.', 'professional_function_catalog.md'), + ('polynomialsCombineFactorization', 'Polynomials', '(left, right)', 'Combine two factorization values with the natural operation for Polynomials.', 'professional_function_catalog.md'), + ('polynomialsCombinePolynomial', 'Polynomials', '(left, right)', 'Combine two polynomial values with the natural operation for Polynomials.', 'professional_function_catalog.md'), + ('polynomialsCombinePolynomialQuotient', 'Polynomials', '(left, right)', 'Combine two polynomial quotient values with the natural operation for Polynomials.', 'professional_function_catalog.md'), + ('polynomialsCombineRootSet', 'Polynomials', '(left, right)', 'Combine two root set values with the natural operation for Polynomials.', 'professional_function_catalog.md'), + ('polynomialsCompareCoefficientList', 'Polynomials', '(left, right)', 'Compare two coefficient list values under the conventions of Polynomials.', 'professional_function_catalog.md'), + ('polynomialsCompareFactorization', 'Polynomials', '(left, right)', 'Compare two factorization values under the conventions of Polynomials.', 'professional_function_catalog.md'), + ('polynomialsComparePolynomial', 'Polynomials', '(left, right)', 'Compare two polynomial values under the conventions of Polynomials.', 'professional_function_catalog.md'), + ('polynomialsComparePolynomialQuotient', 'Polynomials', '(left, right)', 'Compare two polynomial quotient values under the conventions of Polynomials.', 'professional_function_catalog.md'), + ('polynomialsCompareRootSet', 'Polynomials', '(left, right)', 'Compare two root set values under the conventions of Polynomials.', 'professional_function_catalog.md'), + ('polynomialsComputeCoefficientList', 'Polynomials', '(value)', 'Compute the central numerical or symbolic data of a coefficient list.', 'professional_function_catalog.md'), + ('polynomialsComputeFactorization', 'Polynomials', '(value)', 'Compute the central numerical or symbolic data of a factorization.', 'professional_function_catalog.md'), + ('polynomialsComputePolynomial', 'Polynomials', '(value)', 'Compute the central numerical or symbolic data of a polynomial.', 'professional_function_catalog.md'), + ('polynomialsComputePolynomialQuotient', 'Polynomials', '(value)', 'Compute the central numerical or symbolic data of a polynomial quotient.', 'professional_function_catalog.md'), + ('polynomialsComputeRootSet', 'Polynomials', '(value)', 'Compute the central numerical or symbolic data of a root set.', 'professional_function_catalog.md'), + ('polynomialsConstructCoefficientList', 'Polynomials', '(*args)', 'Construct a coefficient list from explicit inputs for Polynomials.', 'professional_function_catalog.md'), + ('polynomialsConstructFactorization', 'Polynomials', '(*args)', 'Construct a factorization from explicit inputs for Polynomials.', 'professional_function_catalog.md'), + ('polynomialsConstructPolynomial', 'Polynomials', '(*args)', 'Construct a polynomial from explicit inputs for Polynomials.', 'professional_function_catalog.md'), + ('polynomialsConstructPolynomialQuotient', 'Polynomials', '(*args)', 'Construct a polynomial quotient from explicit inputs for Polynomials.', 'professional_function_catalog.md'), + ('polynomialsConstructRootSet', 'Polynomials', '(*args)', 'Construct a root set from explicit inputs for Polynomials.', 'professional_function_catalog.md'), + ('polynomialsDecomposeCoefficientList', 'Polynomials', '(value)', 'Decompose a coefficient list into simpler or canonical components.', 'professional_function_catalog.md'), + ('polynomialsDecomposeFactorization', 'Polynomials', '(value)', 'Decompose a factorization into simpler or canonical components.', 'professional_function_catalog.md'), + ('polynomialsDecomposePolynomial', 'Polynomials', '(value)', 'Decompose a polynomial into simpler or canonical components.', 'professional_function_catalog.md'), + ('polynomialsDecomposePolynomialQuotient', 'Polynomials', '(value)', 'Decompose a polynomial quotient into simpler or canonical components.', 'professional_function_catalog.md'), + ('polynomialsDecomposeRootSet', 'Polynomials', '(value)', 'Decompose a root set into simpler or canonical components.', 'professional_function_catalog.md'), + ('polynomialsDocumentCoefficientList', 'Polynomials', '(value)', 'Return a structured explanation of a coefficient list and related assumptions.', 'professional_function_catalog.md'), + ('polynomialsDocumentFactorization', 'Polynomials', '(value)', 'Return a structured explanation of a factorization and related assumptions.', 'professional_function_catalog.md'), + ('polynomialsDocumentPolynomial', 'Polynomials', '(value)', 'Return a structured explanation of a polynomial and related assumptions.', 'professional_function_catalog.md'), + ('polynomialsDocumentPolynomialQuotient', 'Polynomials', '(value)', 'Return a structured explanation of a polynomial quotient and related assumptions.', 'professional_function_catalog.md'), + ('polynomialsDocumentRootSet', 'Polynomials', '(value)', 'Return a structured explanation of a root set and related assumptions.', 'professional_function_catalog.md'), + ('polynomialsEnumerateCoefficientList', 'Polynomials', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a coefficient list.', 'professional_function_catalog.md'), + ('polynomialsEnumerateFactorization', 'Polynomials', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a factorization.', 'professional_function_catalog.md'), + ('polynomialsEnumeratePolynomial', 'Polynomials', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a polynomial.', 'professional_function_catalog.md'), + ('polynomialsEnumeratePolynomialQuotient', 'Polynomials', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a polynomial quotient.', 'professional_function_catalog.md'), + ('polynomialsEnumerateRootSet', 'Polynomials', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a root set.', 'professional_function_catalog.md'), + ('polynomialsEstimateCoefficientList', 'Polynomials', '(value, samples=None)', 'Estimate a coefficient list property from finite samples or approximations.', 'professional_function_catalog.md'), + ('polynomialsEstimateFactorization', 'Polynomials', '(value, samples=None)', 'Estimate a factorization property from finite samples or approximations.', 'professional_function_catalog.md'), + ('polynomialsEstimatePolynomial', 'Polynomials', '(value, samples=None)', 'Estimate a polynomial property from finite samples or approximations.', 'professional_function_catalog.md'), + ('polynomialsEstimatePolynomialQuotient', 'Polynomials', '(value, samples=None)', 'Estimate a polynomial quotient property from finite samples or approximations.', 'professional_function_catalog.md'), + ('polynomialsEstimateRootSet', 'Polynomials', '(value, samples=None)', 'Estimate a root set property from finite samples or approximations.', 'professional_function_catalog.md'), + ('polynomialsEvaluateCoefficientList', 'Polynomials', '(value, point=None)', 'Evaluate a coefficient list at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('polynomialsEvaluateFactorization', 'Polynomials', '(value, point=None)', 'Evaluate a factorization at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('polynomialsEvaluatePolynomial', 'Polynomials', '(value, point=None)', 'Evaluate a polynomial at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('polynomialsEvaluatePolynomialQuotient', 'Polynomials', '(value, point=None)', 'Evaluate a polynomial quotient at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('polynomialsEvaluateRootSet', 'Polynomials', '(value, point=None)', 'Evaluate a root set at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('polynomialsFormatCoefficientList', 'Polynomials', '(value)', 'Format a coefficient list for deterministic user-facing output.', 'professional_function_catalog.md'), + ('polynomialsFormatFactorization', 'Polynomials', '(value)', 'Format a factorization for deterministic user-facing output.', 'professional_function_catalog.md'), + ('polynomialsFormatPolynomial', 'Polynomials', '(value)', 'Format a polynomial for deterministic user-facing output.', 'professional_function_catalog.md'), + ('polynomialsFormatPolynomialQuotient', 'Polynomials', '(value)', 'Format a polynomial quotient for deterministic user-facing output.', 'professional_function_catalog.md'), + ('polynomialsFormatRootSet', 'Polynomials', '(value)', 'Format a root set for deterministic user-facing output.', 'professional_function_catalog.md'), + ('polynomialsGenerateExampleCoefficientList', 'Polynomials', '(size=3)', 'Generate a small documented example of a coefficient list.', 'professional_function_catalog.md'), + ('polynomialsGenerateExampleFactorization', 'Polynomials', '(size=3)', 'Generate a small documented example of a factorization.', 'professional_function_catalog.md'), + ('polynomialsGenerateExamplePolynomial', 'Polynomials', '(size=3)', 'Generate a small documented example of a polynomial.', 'professional_function_catalog.md'), + ('polynomialsGenerateExamplePolynomialQuotient', 'Polynomials', '(size=3)', 'Generate a small documented example of a polynomial quotient.', 'professional_function_catalog.md'), + ('polynomialsGenerateExampleRootSet', 'Polynomials', '(size=3)', 'Generate a small documented example of a root set.', 'professional_function_catalog.md'), + ('polynomialsNormalizeCoefficientList', 'Polynomials', '(value)', 'Normalize a coefficient list into the standard Polynomials representation.', 'professional_function_catalog.md'), + ('polynomialsNormalizeFactorization', 'Polynomials', '(value)', 'Normalize a factorization into the standard Polynomials representation.', 'professional_function_catalog.md'), + ('polynomialsNormalizePolynomial', 'Polynomials', '(value)', 'Normalize a polynomial into the standard Polynomials representation.', 'professional_function_catalog.md'), + ('polynomialsNormalizePolynomialQuotient', 'Polynomials', '(value)', 'Normalize a polynomial quotient into the standard Polynomials representation.', 'professional_function_catalog.md'), + ('polynomialsNormalizeRootSet', 'Polynomials', '(value)', 'Normalize a root set into the standard Polynomials representation.', 'professional_function_catalog.md'), + ('polynomialsParseCoefficientList', 'Polynomials', '(text)', 'Parse a text or structured value into a coefficient list.', 'professional_function_catalog.md'), + ('polynomialsParseFactorization', 'Polynomials', '(text)', 'Parse a text or structured value into a factorization.', 'professional_function_catalog.md'), + ('polynomialsParsePolynomial', 'Polynomials', '(text)', 'Parse a text or structured value into a polynomial.', 'professional_function_catalog.md'), + ('polynomialsParsePolynomialQuotient', 'Polynomials', '(text)', 'Parse a text or structured value into a polynomial quotient.', 'professional_function_catalog.md'), + ('polynomialsParseRootSet', 'Polynomials', '(text)', 'Parse a text or structured value into a root set.', 'professional_function_catalog.md'), + ('polynomialsSimplifyCoefficientList', 'Polynomials', '(value)', 'Simplify a coefficient list without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('polynomialsSimplifyFactorization', 'Polynomials', '(value)', 'Simplify a factorization without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('polynomialsSimplifyPolynomial', 'Polynomials', '(value)', 'Simplify a polynomial without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('polynomialsSimplifyPolynomialQuotient', 'Polynomials', '(value)', 'Simplify a polynomial quotient without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('polynomialsSimplifyRootSet', 'Polynomials', '(value)', 'Simplify a root set without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('polynomialsTestEquivalenceCoefficientList', 'Polynomials', '(left, right)', 'Test whether two coefficient list values are equivalent in Polynomials.', 'professional_function_catalog.md'), + ('polynomialsTestEquivalenceFactorization', 'Polynomials', '(left, right)', 'Test whether two factorization values are equivalent in Polynomials.', 'professional_function_catalog.md'), + ('polynomialsTestEquivalencePolynomial', 'Polynomials', '(left, right)', 'Test whether two polynomial values are equivalent in Polynomials.', 'professional_function_catalog.md'), + ('polynomialsTestEquivalencePolynomialQuotient', 'Polynomials', '(left, right)', 'Test whether two polynomial quotient values are equivalent in Polynomials.', 'professional_function_catalog.md'), + ('polynomialsTestEquivalenceRootSet', 'Polynomials', '(left, right)', 'Test whether two root set values are equivalent in Polynomials.', 'professional_function_catalog.md'), + ('polynomialsTransformCoefficientList', 'Polynomials', '(value, mapping)', 'Transform a coefficient list through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('polynomialsTransformFactorization', 'Polynomials', '(value, mapping)', 'Transform a factorization through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('polynomialsTransformPolynomial', 'Polynomials', '(value, mapping)', 'Transform a polynomial through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('polynomialsTransformPolynomialQuotient', 'Polynomials', '(value, mapping)', 'Transform a polynomial quotient through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('polynomialsTransformRootSet', 'Polynomials', '(value, mapping)', 'Transform a root set through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('polynomialsValidateCoefficientList', 'Polynomials', '(value)', 'Validate the coefficient list representation and domain rules for Polynomials.', 'professional_function_catalog.md'), + ('polynomialsValidateFactorization', 'Polynomials', '(value)', 'Validate the factorization representation and domain rules for Polynomials.', 'professional_function_catalog.md'), + ('polynomialsValidatePolynomial', 'Polynomials', '(value)', 'Validate the polynomial representation and domain rules for Polynomials.', 'professional_function_catalog.md'), + ('polynomialsValidatePolynomialQuotient', 'Polynomials', '(value)', 'Validate the polynomial quotient representation and domain rules for Polynomials.', 'professional_function_catalog.md'), + ('polynomialsValidateRootSet', 'Polynomials', '(value)', 'Validate the root set representation and domain rules for Polynomials.', 'professional_function_catalog.md'), + ('polyNormalize', 'Polynomials', '(coefficients)', 'Planned roadmap function for Polynomials from upcoming.md.', 'upcoming.md'), + ('polySubtract', 'Polynomials', '(p, q)', 'Planned roadmap function for Polynomials from upcoming.md.', 'upcoming.md'), + ('rationalRootCandidates', 'Polynomials', '(coefficients)', 'Planned roadmap function for Polynomials from upcoming.md.', 'upcoming.md'), + ('syntheticDivision', 'Polynomials', '(coefficients, root)', 'Planned roadmap function for Polynomials from upcoming.md.', 'upcoming.md'), + ('bernoulliPMF', 'Probability', '(x, p)', 'Planned roadmap function for Probability from upcoming.md.', 'upcoming.md'), + ('binomialCDF', 'Probability', '(k, n, p)', 'Planned roadmap function for Probability from upcoming.md.', 'upcoming.md'), + ('binomialPMF', 'Probability', '(k, n, p)', 'Planned roadmap function for Probability from upcoming.md.', 'upcoming.md'), + ('conditionalProbability', 'Probability', '(pAB, pB)', 'Planned roadmap function for Probability from upcoming.md.', 'upcoming.md'), + ('expectedValue', 'Probability', '(values, probabilities)', 'Planned roadmap function for Probability from upcoming.md.', 'upcoming.md'), + ('exponentialCDF', 'Probability', '(x, lam)', 'Planned roadmap function for Probability from upcoming.md.', 'upcoming.md'), + ('exponentialPDF', 'Probability', '(x, lam)', 'Planned roadmap function for Probability from upcoming.md.', 'upcoming.md'), + ('gammaCDF', 'Probability', '(x, a, b)', 'Planned roadmap function for Probability from upcoming.md.', 'upcoming.md'), + ('independent', 'Probability', '(pA, pB, pAB, tolerance=1e-9)', 'Planned roadmap function for Probability from upcoming.md.', 'upcoming.md'), + ('poissonCDF', 'Probability', '(k, lam)', 'Planned roadmap function for Probability from upcoming.md.', 'upcoming.md'), + ('poissonPMF', 'Probability', '(k, lam)', 'Planned roadmap function for Probability from upcoming.md.', 'upcoming.md'), + ('probabilityApproximateDensityFunction', 'Probability', '(value, tolerance=1e-9)', 'Approximate a density function with explicit tolerance controls.', 'professional_function_catalog.md'), + ('probabilityApproximateDistribution', 'Probability', '(value, tolerance=1e-9)', 'Approximate a distribution with explicit tolerance controls.', 'professional_function_catalog.md'), + ('probabilityApproximateEventModel', 'Probability', '(value, tolerance=1e-9)', 'Approximate a event model with explicit tolerance controls.', 'professional_function_catalog.md'), + ('probabilityApproximateMassFunction', 'Probability', '(value, tolerance=1e-9)', 'Approximate a mass function with explicit tolerance controls.', 'professional_function_catalog.md'), + ('probabilityApproximateProbabilitySpace', 'Probability', '(value, tolerance=1e-9)', 'Approximate a probability space with explicit tolerance controls.', 'professional_function_catalog.md'), + ('probabilityCanonicalizeDensityFunction', 'Probability', '(value)', 'Canonicalize a density function so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('probabilityCanonicalizeDistribution', 'Probability', '(value)', 'Canonicalize a distribution so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('probabilityCanonicalizeEventModel', 'Probability', '(value)', 'Canonicalize a event model so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('probabilityCanonicalizeMassFunction', 'Probability', '(value)', 'Canonicalize a mass function so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('probabilityCanonicalizeProbabilitySpace', 'Probability', '(value)', 'Canonicalize a probability space so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('probabilityClassifyDensityFunction', 'Probability', '(value)', 'Classify a density function by its standard Probability invariants.', 'professional_function_catalog.md'), + ('probabilityClassifyDistribution', 'Probability', '(value)', 'Classify a distribution by its standard Probability invariants.', 'professional_function_catalog.md'), + ('probabilityClassifyEventModel', 'Probability', '(value)', 'Classify a event model by its standard Probability invariants.', 'professional_function_catalog.md'), + ('probabilityClassifyMassFunction', 'Probability', '(value)', 'Classify a mass function by its standard Probability invariants.', 'professional_function_catalog.md'), + ('probabilityClassifyProbabilitySpace', 'Probability', '(value)', 'Classify a probability space by its standard Probability invariants.', 'professional_function_catalog.md'), + ('probabilityCombineDensityFunction', 'Probability', '(left, right)', 'Combine two density function values with the natural operation for Probability.', 'professional_function_catalog.md'), + ('probabilityCombineDistribution', 'Probability', '(left, right)', 'Combine two distribution values with the natural operation for Probability.', 'professional_function_catalog.md'), + ('probabilityCombineEventModel', 'Probability', '(left, right)', 'Combine two event model values with the natural operation for Probability.', 'professional_function_catalog.md'), + ('probabilityCombineMassFunction', 'Probability', '(left, right)', 'Combine two mass function values with the natural operation for Probability.', 'professional_function_catalog.md'), + ('probabilityCombineProbabilitySpace', 'Probability', '(left, right)', 'Combine two probability space values with the natural operation for Probability.', 'professional_function_catalog.md'), + ('probabilityCompareDensityFunction', 'Probability', '(left, right)', 'Compare two density function values under the conventions of Probability.', 'professional_function_catalog.md'), + ('probabilityCompareDistribution', 'Probability', '(left, right)', 'Compare two distribution values under the conventions of Probability.', 'professional_function_catalog.md'), + ('probabilityCompareEventModel', 'Probability', '(left, right)', 'Compare two event model values under the conventions of Probability.', 'professional_function_catalog.md'), + ('probabilityCompareMassFunction', 'Probability', '(left, right)', 'Compare two mass function values under the conventions of Probability.', 'professional_function_catalog.md'), + ('probabilityCompareProbabilitySpace', 'Probability', '(left, right)', 'Compare two probability space values under the conventions of Probability.', 'professional_function_catalog.md'), + ('probabilityComputeDensityFunction', 'Probability', '(value)', 'Compute the central numerical or symbolic data of a density function.', 'professional_function_catalog.md'), + ('probabilityComputeDistribution', 'Probability', '(value)', 'Compute the central numerical or symbolic data of a distribution.', 'professional_function_catalog.md'), + ('probabilityComputeEventModel', 'Probability', '(value)', 'Compute the central numerical or symbolic data of a event model.', 'professional_function_catalog.md'), + ('probabilityComputeMassFunction', 'Probability', '(value)', 'Compute the central numerical or symbolic data of a mass function.', 'professional_function_catalog.md'), + ('probabilityComputeProbabilitySpace', 'Probability', '(value)', 'Compute the central numerical or symbolic data of a probability space.', 'professional_function_catalog.md'), + ('probabilityConstructDensityFunction', 'Probability', '(*args)', 'Construct a density function from explicit inputs for Probability.', 'professional_function_catalog.md'), + ('probabilityConstructDistribution', 'Probability', '(*args)', 'Construct a distribution from explicit inputs for Probability.', 'professional_function_catalog.md'), + ('probabilityConstructEventModel', 'Probability', '(*args)', 'Construct a event model from explicit inputs for Probability.', 'professional_function_catalog.md'), + ('probabilityConstructMassFunction', 'Probability', '(*args)', 'Construct a mass function from explicit inputs for Probability.', 'professional_function_catalog.md'), + ('probabilityConstructProbabilitySpace', 'Probability', '(*args)', 'Construct a probability space from explicit inputs for Probability.', 'professional_function_catalog.md'), + ('probabilityDecomposeDensityFunction', 'Probability', '(value)', 'Decompose a density function into simpler or canonical components.', 'professional_function_catalog.md'), + ('probabilityDecomposeDistribution', 'Probability', '(value)', 'Decompose a distribution into simpler or canonical components.', 'professional_function_catalog.md'), + ('probabilityDecomposeEventModel', 'Probability', '(value)', 'Decompose a event model into simpler or canonical components.', 'professional_function_catalog.md'), + ('probabilityDecomposeMassFunction', 'Probability', '(value)', 'Decompose a mass function into simpler or canonical components.', 'professional_function_catalog.md'), + ('probabilityDecomposeProbabilitySpace', 'Probability', '(value)', 'Decompose a probability space into simpler or canonical components.', 'professional_function_catalog.md'), + ('probabilityDocumentDensityFunction', 'Probability', '(value)', 'Return a structured explanation of a density function and related assumptions.', 'professional_function_catalog.md'), + ('probabilityDocumentDistribution', 'Probability', '(value)', 'Return a structured explanation of a distribution and related assumptions.', 'professional_function_catalog.md'), + ('probabilityDocumentEventModel', 'Probability', '(value)', 'Return a structured explanation of a event model and related assumptions.', 'professional_function_catalog.md'), + ('probabilityDocumentMassFunction', 'Probability', '(value)', 'Return a structured explanation of a mass function and related assumptions.', 'professional_function_catalog.md'), + ('probabilityDocumentProbabilitySpace', 'Probability', '(value)', 'Return a structured explanation of a probability space and related assumptions.', 'professional_function_catalog.md'), + ('probabilityEnumerateDensityFunction', 'Probability', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a density function.', 'professional_function_catalog.md'), + ('probabilityEnumerateDistribution', 'Probability', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a distribution.', 'professional_function_catalog.md'), + ('probabilityEnumerateEventModel', 'Probability', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a event model.', 'professional_function_catalog.md'), + ('probabilityEnumerateMassFunction', 'Probability', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a mass function.', 'professional_function_catalog.md'), + ('probabilityEnumerateProbabilitySpace', 'Probability', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a probability space.', 'professional_function_catalog.md'), + ('probabilityEstimateDensityFunction', 'Probability', '(value, samples=None)', 'Estimate a density function property from finite samples or approximations.', 'professional_function_catalog.md'), + ('probabilityEstimateDistribution', 'Probability', '(value, samples=None)', 'Estimate a distribution property from finite samples or approximations.', 'professional_function_catalog.md'), + ('probabilityEstimateEventModel', 'Probability', '(value, samples=None)', 'Estimate a event model property from finite samples or approximations.', 'professional_function_catalog.md'), + ('probabilityEstimateMassFunction', 'Probability', '(value, samples=None)', 'Estimate a mass function property from finite samples or approximations.', 'professional_function_catalog.md'), + ('probabilityEstimateProbabilitySpace', 'Probability', '(value, samples=None)', 'Estimate a probability space property from finite samples or approximations.', 'professional_function_catalog.md'), + ('probabilityEvaluateDensityFunction', 'Probability', '(value, point=None)', 'Evaluate a density function at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('probabilityEvaluateDistribution', 'Probability', '(value, point=None)', 'Evaluate a distribution at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('probabilityEvaluateEventModel', 'Probability', '(value, point=None)', 'Evaluate a event model at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('probabilityEvaluateMassFunction', 'Probability', '(value, point=None)', 'Evaluate a mass function at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('probabilityEvaluateProbabilitySpace', 'Probability', '(value, point=None)', 'Evaluate a probability space at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('probabilityFormatDensityFunction', 'Probability', '(value)', 'Format a density function for deterministic user-facing output.', 'professional_function_catalog.md'), + ('probabilityFormatDistribution', 'Probability', '(value)', 'Format a distribution for deterministic user-facing output.', 'professional_function_catalog.md'), + ('probabilityFormatEventModel', 'Probability', '(value)', 'Format a event model for deterministic user-facing output.', 'professional_function_catalog.md'), + ('probabilityFormatMassFunction', 'Probability', '(value)', 'Format a mass function for deterministic user-facing output.', 'professional_function_catalog.md'), + ('probabilityFormatProbabilitySpace', 'Probability', '(value)', 'Format a probability space for deterministic user-facing output.', 'professional_function_catalog.md'), + ('probabilityGenerateExampleDensityFunction', 'Probability', '(size=3)', 'Generate a small documented example of a density function.', 'professional_function_catalog.md'), + ('probabilityGenerateExampleDistribution', 'Probability', '(size=3)', 'Generate a small documented example of a distribution.', 'professional_function_catalog.md'), + ('probabilityGenerateExampleEventModel', 'Probability', '(size=3)', 'Generate a small documented example of a event model.', 'professional_function_catalog.md'), + ('probabilityGenerateExampleMassFunction', 'Probability', '(size=3)', 'Generate a small documented example of a mass function.', 'professional_function_catalog.md'), + ('probabilityGenerateExampleProbabilitySpace', 'Probability', '(size=3)', 'Generate a small documented example of a probability space.', 'professional_function_catalog.md'), + ('probabilityNormalizeDensityFunction', 'Probability', '(value)', 'Normalize a density function into the standard Probability representation.', 'professional_function_catalog.md'), + ('probabilityNormalizeDistribution', 'Probability', '(value)', 'Normalize a distribution into the standard Probability representation.', 'professional_function_catalog.md'), + ('probabilityNormalizeEventModel', 'Probability', '(value)', 'Normalize a event model into the standard Probability representation.', 'professional_function_catalog.md'), + ('probabilityNormalizeMassFunction', 'Probability', '(value)', 'Normalize a mass function into the standard Probability representation.', 'professional_function_catalog.md'), + ('probabilityNormalizeProbabilitySpace', 'Probability', '(value)', 'Normalize a probability space into the standard Probability representation.', 'professional_function_catalog.md'), + ('probabilityParseDensityFunction', 'Probability', '(text)', 'Parse a text or structured value into a density function.', 'professional_function_catalog.md'), + ('probabilityParseDistribution', 'Probability', '(text)', 'Parse a text or structured value into a distribution.', 'professional_function_catalog.md'), + ('probabilityParseEventModel', 'Probability', '(text)', 'Parse a text or structured value into a event model.', 'professional_function_catalog.md'), + ('probabilityParseMassFunction', 'Probability', '(text)', 'Parse a text or structured value into a mass function.', 'professional_function_catalog.md'), + ('probabilityParseProbabilitySpace', 'Probability', '(text)', 'Parse a text or structured value into a probability space.', 'professional_function_catalog.md'), + ('probabilitySimplifyDensityFunction', 'Probability', '(value)', 'Simplify a density function without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('probabilitySimplifyDistribution', 'Probability', '(value)', 'Simplify a distribution without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('probabilitySimplifyEventModel', 'Probability', '(value)', 'Simplify a event model without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('probabilitySimplifyMassFunction', 'Probability', '(value)', 'Simplify a mass function without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('probabilitySimplifyProbabilitySpace', 'Probability', '(value)', 'Simplify a probability space without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('probabilityTestEquivalenceDensityFunction', 'Probability', '(left, right)', 'Test whether two density function values are equivalent in Probability.', 'professional_function_catalog.md'), + ('probabilityTestEquivalenceDistribution', 'Probability', '(left, right)', 'Test whether two distribution values are equivalent in Probability.', 'professional_function_catalog.md'), + ('probabilityTestEquivalenceEventModel', 'Probability', '(left, right)', 'Test whether two event model values are equivalent in Probability.', 'professional_function_catalog.md'), + ('probabilityTestEquivalenceMassFunction', 'Probability', '(left, right)', 'Test whether two mass function values are equivalent in Probability.', 'professional_function_catalog.md'), + ('probabilityTestEquivalenceProbabilitySpace', 'Probability', '(left, right)', 'Test whether two probability space values are equivalent in Probability.', 'professional_function_catalog.md'), + ('probabilityTransformDensityFunction', 'Probability', '(value, mapping)', 'Transform a density function through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('probabilityTransformDistribution', 'Probability', '(value, mapping)', 'Transform a distribution through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('probabilityTransformEventModel', 'Probability', '(value, mapping)', 'Transform a event model through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('probabilityTransformMassFunction', 'Probability', '(value, mapping)', 'Transform a mass function through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('probabilityTransformProbabilitySpace', 'Probability', '(value, mapping)', 'Transform a probability space through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('probabilityValidateDensityFunction', 'Probability', '(value)', 'Validate the density function representation and domain rules for Probability.', 'professional_function_catalog.md'), + ('probabilityValidateDistribution', 'Probability', '(value)', 'Validate the distribution representation and domain rules for Probability.', 'professional_function_catalog.md'), + ('probabilityValidateEventModel', 'Probability', '(value)', 'Validate the event model representation and domain rules for Probability.', 'professional_function_catalog.md'), + ('probabilityValidateMassFunction', 'Probability', '(value)', 'Validate the mass function representation and domain rules for Probability.', 'professional_function_catalog.md'), + ('probabilityValidateProbabilitySpace', 'Probability', '(value)', 'Validate the probability space representation and domain rules for Probability.', 'professional_function_catalog.md'), + ('applyModusPonens', 'Proof Theory', '(rule, premises)', 'Planned roadmap function for Proof Theory from upcoming.md.', 'upcoming.md'), + ('checkProof', 'Proof Theory', '(steps, rules)', 'Planned roadmap function for Proof Theory from upcoming.md.', 'upcoming.md'), + ('cutEliminationStep', 'Proof Theory', '(proof)', 'Planned roadmap function for Proof Theory from upcoming.md.', 'upcoming.md'), + ('deductionTheoremTransform', 'Proof Theory', '(proof)', 'Planned roadmap function for Proof Theory from upcoming.md.', 'upcoming.md'), + ('isValidInference', 'Proof Theory', '(rule, premises, conclusion)', 'Planned roadmap function for Proof Theory from upcoming.md.', 'upcoming.md'), + ('normalFormProof', 'Proof Theory', '(proof)', 'Planned roadmap function for Proof Theory from upcoming.md.', 'upcoming.md'), + ('proofTheoryApproximateDerivation', 'Proof Theory', '(value, tolerance=1e-9)', 'Approximate a derivation with explicit tolerance controls.', 'professional_function_catalog.md'), + ('proofTheoryApproximateInferenceRule', 'Proof Theory', '(value, tolerance=1e-9)', 'Approximate a inference rule with explicit tolerance controls.', 'professional_function_catalog.md'), + ('proofTheoryApproximateNormalForm', 'Proof Theory', '(value, tolerance=1e-9)', 'Approximate a normal form with explicit tolerance controls.', 'professional_function_catalog.md'), + ('proofTheoryApproximateProofTree', 'Proof Theory', '(value, tolerance=1e-9)', 'Approximate a proof tree with explicit tolerance controls.', 'professional_function_catalog.md'), + ('proofTheoryApproximateSequent', 'Proof Theory', '(value, tolerance=1e-9)', 'Approximate a sequent with explicit tolerance controls.', 'professional_function_catalog.md'), + ('proofTheoryCanonicalizeDerivation', 'Proof Theory', '(value)', 'Canonicalize a derivation so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('proofTheoryCanonicalizeInferenceRule', 'Proof Theory', '(value)', 'Canonicalize a inference rule so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('proofTheoryCanonicalizeNormalForm', 'Proof Theory', '(value)', 'Canonicalize a normal form so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('proofTheoryCanonicalizeProofTree', 'Proof Theory', '(value)', 'Canonicalize a proof tree so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('proofTheoryCanonicalizeSequent', 'Proof Theory', '(value)', 'Canonicalize a sequent so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('proofTheoryClassifyDerivation', 'Proof Theory', '(value)', 'Classify a derivation by its standard Proof Theory invariants.', 'professional_function_catalog.md'), + ('proofTheoryClassifyInferenceRule', 'Proof Theory', '(value)', 'Classify a inference rule by its standard Proof Theory invariants.', 'professional_function_catalog.md'), + ('proofTheoryClassifyNormalForm', 'Proof Theory', '(value)', 'Classify a normal form by its standard Proof Theory invariants.', 'professional_function_catalog.md'), + ('proofTheoryClassifyProofTree', 'Proof Theory', '(value)', 'Classify a proof tree by its standard Proof Theory invariants.', 'professional_function_catalog.md'), + ('proofTheoryClassifySequent', 'Proof Theory', '(value)', 'Classify a sequent by its standard Proof Theory invariants.', 'professional_function_catalog.md'), + ('proofTheoryCombineDerivation', 'Proof Theory', '(left, right)', 'Combine two derivation values with the natural operation for Proof Theory.', 'professional_function_catalog.md'), + ('proofTheoryCombineInferenceRule', 'Proof Theory', '(left, right)', 'Combine two inference rule values with the natural operation for Proof Theory.', 'professional_function_catalog.md'), + ('proofTheoryCombineNormalForm', 'Proof Theory', '(left, right)', 'Combine two normal form values with the natural operation for Proof Theory.', 'professional_function_catalog.md'), + ('proofTheoryCombineProofTree', 'Proof Theory', '(left, right)', 'Combine two proof tree values with the natural operation for Proof Theory.', 'professional_function_catalog.md'), + ('proofTheoryCombineSequent', 'Proof Theory', '(left, right)', 'Combine two sequent values with the natural operation for Proof Theory.', 'professional_function_catalog.md'), + ('proofTheoryCompareDerivation', 'Proof Theory', '(left, right)', 'Compare two derivation values under the conventions of Proof Theory.', 'professional_function_catalog.md'), + ('proofTheoryCompareInferenceRule', 'Proof Theory', '(left, right)', 'Compare two inference rule values under the conventions of Proof Theory.', 'professional_function_catalog.md'), + ('proofTheoryCompareNormalForm', 'Proof Theory', '(left, right)', 'Compare two normal form values under the conventions of Proof Theory.', 'professional_function_catalog.md'), + ('proofTheoryCompareProofTree', 'Proof Theory', '(left, right)', 'Compare two proof tree values under the conventions of Proof Theory.', 'professional_function_catalog.md'), + ('proofTheoryCompareSequent', 'Proof Theory', '(left, right)', 'Compare two sequent values under the conventions of Proof Theory.', 'professional_function_catalog.md'), + ('proofTheoryComputeDerivation', 'Proof Theory', '(value)', 'Compute the central numerical or symbolic data of a derivation.', 'professional_function_catalog.md'), + ('proofTheoryComputeInferenceRule', 'Proof Theory', '(value)', 'Compute the central numerical or symbolic data of a inference rule.', 'professional_function_catalog.md'), + ('proofTheoryComputeNormalForm', 'Proof Theory', '(value)', 'Compute the central numerical or symbolic data of a normal form.', 'professional_function_catalog.md'), + ('proofTheoryComputeProofTree', 'Proof Theory', '(value)', 'Compute the central numerical or symbolic data of a proof tree.', 'professional_function_catalog.md'), + ('proofTheoryComputeSequent', 'Proof Theory', '(value)', 'Compute the central numerical or symbolic data of a sequent.', 'professional_function_catalog.md'), + ('proofTheoryConstructDerivation', 'Proof Theory', '(*args)', 'Construct a derivation from explicit inputs for Proof Theory.', 'professional_function_catalog.md'), + ('proofTheoryConstructInferenceRule', 'Proof Theory', '(*args)', 'Construct a inference rule from explicit inputs for Proof Theory.', 'professional_function_catalog.md'), + ('proofTheoryConstructNormalForm', 'Proof Theory', '(*args)', 'Construct a normal form from explicit inputs for Proof Theory.', 'professional_function_catalog.md'), + ('proofTheoryConstructProofTree', 'Proof Theory', '(*args)', 'Construct a proof tree from explicit inputs for Proof Theory.', 'professional_function_catalog.md'), + ('proofTheoryConstructSequent', 'Proof Theory', '(*args)', 'Construct a sequent from explicit inputs for Proof Theory.', 'professional_function_catalog.md'), + ('proofTheoryDecomposeDerivation', 'Proof Theory', '(value)', 'Decompose a derivation into simpler or canonical components.', 'professional_function_catalog.md'), + ('proofTheoryDecomposeInferenceRule', 'Proof Theory', '(value)', 'Decompose a inference rule into simpler or canonical components.', 'professional_function_catalog.md'), + ('proofTheoryDecomposeNormalForm', 'Proof Theory', '(value)', 'Decompose a normal form into simpler or canonical components.', 'professional_function_catalog.md'), + ('proofTheoryDecomposeProofTree', 'Proof Theory', '(value)', 'Decompose a proof tree into simpler or canonical components.', 'professional_function_catalog.md'), + ('proofTheoryDecomposeSequent', 'Proof Theory', '(value)', 'Decompose a sequent into simpler or canonical components.', 'professional_function_catalog.md'), + ('proofTheoryDocumentDerivation', 'Proof Theory', '(value)', 'Return a structured explanation of a derivation and related assumptions.', 'professional_function_catalog.md'), + ('proofTheoryDocumentInferenceRule', 'Proof Theory', '(value)', 'Return a structured explanation of a inference rule and related assumptions.', 'professional_function_catalog.md'), + ('proofTheoryDocumentNormalForm', 'Proof Theory', '(value)', 'Return a structured explanation of a normal form and related assumptions.', 'professional_function_catalog.md'), + ('proofTheoryDocumentProofTree', 'Proof Theory', '(value)', 'Return a structured explanation of a proof tree and related assumptions.', 'professional_function_catalog.md'), + ('proofTheoryDocumentSequent', 'Proof Theory', '(value)', 'Return a structured explanation of a sequent and related assumptions.', 'professional_function_catalog.md'), + ('proofTheoryEnumerateDerivation', 'Proof Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a derivation.', 'professional_function_catalog.md'), + ('proofTheoryEnumerateInferenceRule', 'Proof Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a inference rule.', 'professional_function_catalog.md'), + ('proofTheoryEnumerateNormalForm', 'Proof Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a normal form.', 'professional_function_catalog.md'), + ('proofTheoryEnumerateProofTree', 'Proof Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a proof tree.', 'professional_function_catalog.md'), + ('proofTheoryEnumerateSequent', 'Proof Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a sequent.', 'professional_function_catalog.md'), + ('proofTheoryEstimateDerivation', 'Proof Theory', '(value, samples=None)', 'Estimate a derivation property from finite samples or approximations.', 'professional_function_catalog.md'), + ('proofTheoryEstimateInferenceRule', 'Proof Theory', '(value, samples=None)', 'Estimate a inference rule property from finite samples or approximations.', 'professional_function_catalog.md'), + ('proofTheoryEstimateNormalForm', 'Proof Theory', '(value, samples=None)', 'Estimate a normal form property from finite samples or approximations.', 'professional_function_catalog.md'), + ('proofTheoryEstimateProofTree', 'Proof Theory', '(value, samples=None)', 'Estimate a proof tree property from finite samples or approximations.', 'professional_function_catalog.md'), + ('proofTheoryEstimateSequent', 'Proof Theory', '(value, samples=None)', 'Estimate a sequent property from finite samples or approximations.', 'professional_function_catalog.md'), + ('proofTheoryEvaluateDerivation', 'Proof Theory', '(value, point=None)', 'Evaluate a derivation at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('proofTheoryEvaluateInferenceRule', 'Proof Theory', '(value, point=None)', 'Evaluate a inference rule at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('proofTheoryEvaluateNormalForm', 'Proof Theory', '(value, point=None)', 'Evaluate a normal form at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('proofTheoryEvaluateProofTree', 'Proof Theory', '(value, point=None)', 'Evaluate a proof tree at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('proofTheoryEvaluateSequent', 'Proof Theory', '(value, point=None)', 'Evaluate a sequent at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('proofTheoryFormatDerivation', 'Proof Theory', '(value)', 'Format a derivation for deterministic user-facing output.', 'professional_function_catalog.md'), + ('proofTheoryFormatInferenceRule', 'Proof Theory', '(value)', 'Format a inference rule for deterministic user-facing output.', 'professional_function_catalog.md'), + ('proofTheoryFormatNormalForm', 'Proof Theory', '(value)', 'Format a normal form for deterministic user-facing output.', 'professional_function_catalog.md'), + ('proofTheoryFormatProofTree', 'Proof Theory', '(value)', 'Format a proof tree for deterministic user-facing output.', 'professional_function_catalog.md'), + ('proofTheoryFormatSequent', 'Proof Theory', '(value)', 'Format a sequent for deterministic user-facing output.', 'professional_function_catalog.md'), + ('proofTheoryGenerateExampleDerivation', 'Proof Theory', '(size=3)', 'Generate a small documented example of a derivation.', 'professional_function_catalog.md'), + ('proofTheoryGenerateExampleInferenceRule', 'Proof Theory', '(size=3)', 'Generate a small documented example of a inference rule.', 'professional_function_catalog.md'), + ('proofTheoryGenerateExampleNormalForm', 'Proof Theory', '(size=3)', 'Generate a small documented example of a normal form.', 'professional_function_catalog.md'), + ('proofTheoryGenerateExampleProofTree', 'Proof Theory', '(size=3)', 'Generate a small documented example of a proof tree.', 'professional_function_catalog.md'), + ('proofTheoryGenerateExampleSequent', 'Proof Theory', '(size=3)', 'Generate a small documented example of a sequent.', 'professional_function_catalog.md'), + ('proofTheoryNormalizeDerivation', 'Proof Theory', '(value)', 'Normalize a derivation into the standard Proof Theory representation.', 'professional_function_catalog.md'), + ('proofTheoryNormalizeInferenceRule', 'Proof Theory', '(value)', 'Normalize a inference rule into the standard Proof Theory representation.', 'professional_function_catalog.md'), + ('proofTheoryNormalizeNormalForm', 'Proof Theory', '(value)', 'Normalize a normal form into the standard Proof Theory representation.', 'professional_function_catalog.md'), + ('proofTheoryNormalizeProofTree', 'Proof Theory', '(value)', 'Normalize a proof tree into the standard Proof Theory representation.', 'professional_function_catalog.md'), + ('proofTheoryNormalizeSequent', 'Proof Theory', '(value)', 'Normalize a sequent into the standard Proof Theory representation.', 'professional_function_catalog.md'), + ('proofTheoryParseDerivation', 'Proof Theory', '(text)', 'Parse a text or structured value into a derivation.', 'professional_function_catalog.md'), + ('proofTheoryParseInferenceRule', 'Proof Theory', '(text)', 'Parse a text or structured value into a inference rule.', 'professional_function_catalog.md'), + ('proofTheoryParseNormalForm', 'Proof Theory', '(text)', 'Parse a text or structured value into a normal form.', 'professional_function_catalog.md'), + ('proofTheoryParseProofTree', 'Proof Theory', '(text)', 'Parse a text or structured value into a proof tree.', 'professional_function_catalog.md'), + ('proofTheoryParseSequent', 'Proof Theory', '(text)', 'Parse a text or structured value into a sequent.', 'professional_function_catalog.md'), + ('proofTheorySimplifyDerivation', 'Proof Theory', '(value)', 'Simplify a derivation without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('proofTheorySimplifyInferenceRule', 'Proof Theory', '(value)', 'Simplify a inference rule without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('proofTheorySimplifyNormalForm', 'Proof Theory', '(value)', 'Simplify a normal form without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('proofTheorySimplifyProofTree', 'Proof Theory', '(value)', 'Simplify a proof tree without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('proofTheorySimplifySequent', 'Proof Theory', '(value)', 'Simplify a sequent without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('proofTheoryTestEquivalenceDerivation', 'Proof Theory', '(left, right)', 'Test whether two derivation values are equivalent in Proof Theory.', 'professional_function_catalog.md'), + ('proofTheoryTestEquivalenceInferenceRule', 'Proof Theory', '(left, right)', 'Test whether two inference rule values are equivalent in Proof Theory.', 'professional_function_catalog.md'), + ('proofTheoryTestEquivalenceNormalForm', 'Proof Theory', '(left, right)', 'Test whether two normal form values are equivalent in Proof Theory.', 'professional_function_catalog.md'), + ('proofTheoryTestEquivalenceProofTree', 'Proof Theory', '(left, right)', 'Test whether two proof tree values are equivalent in Proof Theory.', 'professional_function_catalog.md'), + ('proofTheoryTestEquivalenceSequent', 'Proof Theory', '(left, right)', 'Test whether two sequent values are equivalent in Proof Theory.', 'professional_function_catalog.md'), + ('proofTheoryTransformDerivation', 'Proof Theory', '(value, mapping)', 'Transform a derivation through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('proofTheoryTransformInferenceRule', 'Proof Theory', '(value, mapping)', 'Transform a inference rule through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('proofTheoryTransformNormalForm', 'Proof Theory', '(value, mapping)', 'Transform a normal form through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('proofTheoryTransformProofTree', 'Proof Theory', '(value, mapping)', 'Transform a proof tree through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('proofTheoryTransformSequent', 'Proof Theory', '(value, mapping)', 'Transform a sequent through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('proofTheoryValidateDerivation', 'Proof Theory', '(value)', 'Validate the derivation representation and domain rules for Proof Theory.', 'professional_function_catalog.md'), + ('proofTheoryValidateInferenceRule', 'Proof Theory', '(value)', 'Validate the inference rule representation and domain rules for Proof Theory.', 'professional_function_catalog.md'), + ('proofTheoryValidateNormalForm', 'Proof Theory', '(value)', 'Validate the normal form representation and domain rules for Proof Theory.', 'professional_function_catalog.md'), + ('proofTheoryValidateProofTree', 'Proof Theory', '(value)', 'Validate the proof tree representation and domain rules for Proof Theory.', 'professional_function_catalog.md'), + ('proofTheoryValidateSequent', 'Proof Theory', '(value)', 'Validate the sequent representation and domain rules for Proof Theory.', 'professional_function_catalog.md'), + ('proofTree', 'Proof Theory', '(conclusion, premises)', 'Planned roadmap function for Proof Theory from upcoming.md.', 'upcoming.md'), + ('sequent', 'Proof Theory', '(assumptions, conclusion)', 'Planned roadmap function for Proof Theory from upcoming.md.', 'upcoming.md'), + ('argMax', 'Quantitative Analysis', '(arr)', 'Planned roadmap function for Quantitative Analysis from upcoming.md.', 'upcoming.md'), + ('argMin', 'Quantitative Analysis', '(arr)', 'Planned roadmap function for Quantitative Analysis from upcoming.md.', 'upcoming.md'), + ('criticalPoints', 'Quantitative Analysis', '(f, a, b, step=0.01)', 'Planned roadmap function for Quantitative Analysis from upcoming.md.', 'upcoming.md'), + ('isDecreasing', 'Quantitative Analysis', '(arr)', 'Planned roadmap function for Quantitative Analysis from upcoming.md.', 'upcoming.md'), + ('isIncreasing', 'Quantitative Analysis', '(arr)', 'Planned roadmap function for Quantitative Analysis from upcoming.md.', 'upcoming.md'), + ('monotonicIntervals', 'Quantitative Analysis', '(arr)', 'Planned roadmap function for Quantitative Analysis from upcoming.md.', 'upcoming.md'), + ('movingAverage', 'Quantitative Analysis', '(arr, window)', 'Planned roadmap function for Quantitative Analysis from upcoming.md.', 'upcoming.md'), + ('quantitativeAnalysisApproximateChangeProfile', 'Quantitative Analysis', '(value, tolerance=1e-9)', 'Approximate a change profile with explicit tolerance controls.', 'professional_function_catalog.md'), + ('quantitativeAnalysisApproximateDataSequence', 'Quantitative Analysis', '(value, tolerance=1e-9)', 'Approximate a data sequence with explicit tolerance controls.', 'professional_function_catalog.md'), + ('quantitativeAnalysisApproximateExtremumProfile', 'Quantitative Analysis', '(value, tolerance=1e-9)', 'Approximate a extremum profile with explicit tolerance controls.', 'professional_function_catalog.md'), + ('quantitativeAnalysisApproximateRankingModel', 'Quantitative Analysis', '(value, tolerance=1e-9)', 'Approximate a ranking model with explicit tolerance controls.', 'professional_function_catalog.md'), + ('quantitativeAnalysisApproximateTrendSegment', 'Quantitative Analysis', '(value, tolerance=1e-9)', 'Approximate a trend segment with explicit tolerance controls.', 'professional_function_catalog.md'), + ('quantitativeAnalysisCanonicalizeChangeProfile', 'Quantitative Analysis', '(value)', 'Canonicalize a change profile so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('quantitativeAnalysisCanonicalizeDataSequence', 'Quantitative Analysis', '(value)', 'Canonicalize a data sequence so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('quantitativeAnalysisCanonicalizeExtremumProfile', 'Quantitative Analysis', '(value)', 'Canonicalize a extremum profile so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('quantitativeAnalysisCanonicalizeRankingModel', 'Quantitative Analysis', '(value)', 'Canonicalize a ranking model so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('quantitativeAnalysisCanonicalizeTrendSegment', 'Quantitative Analysis', '(value)', 'Canonicalize a trend segment so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('quantitativeAnalysisClassifyChangeProfile', 'Quantitative Analysis', '(value)', 'Classify a change profile by its standard Quantitative Analysis invariants.', 'professional_function_catalog.md'), + ('quantitativeAnalysisClassifyDataSequence', 'Quantitative Analysis', '(value)', 'Classify a data sequence by its standard Quantitative Analysis invariants.', 'professional_function_catalog.md'), + ('quantitativeAnalysisClassifyExtremumProfile', 'Quantitative Analysis', '(value)', 'Classify a extremum profile by its standard Quantitative Analysis invariants.', 'professional_function_catalog.md'), + ('quantitativeAnalysisClassifyRankingModel', 'Quantitative Analysis', '(value)', 'Classify a ranking model by its standard Quantitative Analysis invariants.', 'professional_function_catalog.md'), + ('quantitativeAnalysisClassifyTrendSegment', 'Quantitative Analysis', '(value)', 'Classify a trend segment by its standard Quantitative Analysis invariants.', 'professional_function_catalog.md'), + ('quantitativeAnalysisCombineChangeProfile', 'Quantitative Analysis', '(left, right)', 'Combine two change profile values with the natural operation for Quantitative Analysis.', 'professional_function_catalog.md'), + ('quantitativeAnalysisCombineDataSequence', 'Quantitative Analysis', '(left, right)', 'Combine two data sequence values with the natural operation for Quantitative Analysis.', 'professional_function_catalog.md'), + ('quantitativeAnalysisCombineExtremumProfile', 'Quantitative Analysis', '(left, right)', 'Combine two extremum profile values with the natural operation for Quantitative Analysis.', 'professional_function_catalog.md'), + ('quantitativeAnalysisCombineRankingModel', 'Quantitative Analysis', '(left, right)', 'Combine two ranking model values with the natural operation for Quantitative Analysis.', 'professional_function_catalog.md'), + ('quantitativeAnalysisCombineTrendSegment', 'Quantitative Analysis', '(left, right)', 'Combine two trend segment values with the natural operation for Quantitative Analysis.', 'professional_function_catalog.md'), + ('quantitativeAnalysisCompareChangeProfile', 'Quantitative Analysis', '(left, right)', 'Compare two change profile values under the conventions of Quantitative Analysis.', 'professional_function_catalog.md'), + ('quantitativeAnalysisCompareDataSequence', 'Quantitative Analysis', '(left, right)', 'Compare two data sequence values under the conventions of Quantitative Analysis.', 'professional_function_catalog.md'), + ('quantitativeAnalysisCompareExtremumProfile', 'Quantitative Analysis', '(left, right)', 'Compare two extremum profile values under the conventions of Quantitative Analysis.', 'professional_function_catalog.md'), + ('quantitativeAnalysisCompareRankingModel', 'Quantitative Analysis', '(left, right)', 'Compare two ranking model values under the conventions of Quantitative Analysis.', 'professional_function_catalog.md'), + ('quantitativeAnalysisCompareTrendSegment', 'Quantitative Analysis', '(left, right)', 'Compare two trend segment values under the conventions of Quantitative Analysis.', 'professional_function_catalog.md'), + ('quantitativeAnalysisComputeChangeProfile', 'Quantitative Analysis', '(value)', 'Compute the central numerical or symbolic data of a change profile.', 'professional_function_catalog.md'), + ('quantitativeAnalysisComputeDataSequence', 'Quantitative Analysis', '(value)', 'Compute the central numerical or symbolic data of a data sequence.', 'professional_function_catalog.md'), + ('quantitativeAnalysisComputeExtremumProfile', 'Quantitative Analysis', '(value)', 'Compute the central numerical or symbolic data of a extremum profile.', 'professional_function_catalog.md'), + ('quantitativeAnalysisComputeRankingModel', 'Quantitative Analysis', '(value)', 'Compute the central numerical or symbolic data of a ranking model.', 'professional_function_catalog.md'), + ('quantitativeAnalysisComputeTrendSegment', 'Quantitative Analysis', '(value)', 'Compute the central numerical or symbolic data of a trend segment.', 'professional_function_catalog.md'), + ('quantitativeAnalysisConstructChangeProfile', 'Quantitative Analysis', '(*args)', 'Construct a change profile from explicit inputs for Quantitative Analysis.', 'professional_function_catalog.md'), + ('quantitativeAnalysisConstructDataSequence', 'Quantitative Analysis', '(*args)', 'Construct a data sequence from explicit inputs for Quantitative Analysis.', 'professional_function_catalog.md'), + ('quantitativeAnalysisConstructExtremumProfile', 'Quantitative Analysis', '(*args)', 'Construct a extremum profile from explicit inputs for Quantitative Analysis.', 'professional_function_catalog.md'), + ('quantitativeAnalysisConstructRankingModel', 'Quantitative Analysis', '(*args)', 'Construct a ranking model from explicit inputs for Quantitative Analysis.', 'professional_function_catalog.md'), + ('quantitativeAnalysisConstructTrendSegment', 'Quantitative Analysis', '(*args)', 'Construct a trend segment from explicit inputs for Quantitative Analysis.', 'professional_function_catalog.md'), + ('quantitativeAnalysisDecomposeChangeProfile', 'Quantitative Analysis', '(value)', 'Decompose a change profile into simpler or canonical components.', 'professional_function_catalog.md'), + ('quantitativeAnalysisDecomposeDataSequence', 'Quantitative Analysis', '(value)', 'Decompose a data sequence into simpler or canonical components.', 'professional_function_catalog.md'), + ('quantitativeAnalysisDecomposeExtremumProfile', 'Quantitative Analysis', '(value)', 'Decompose a extremum profile into simpler or canonical components.', 'professional_function_catalog.md'), + ('quantitativeAnalysisDecomposeRankingModel', 'Quantitative Analysis', '(value)', 'Decompose a ranking model into simpler or canonical components.', 'professional_function_catalog.md'), + ('quantitativeAnalysisDecomposeTrendSegment', 'Quantitative Analysis', '(value)', 'Decompose a trend segment into simpler or canonical components.', 'professional_function_catalog.md'), + ('quantitativeAnalysisDocumentChangeProfile', 'Quantitative Analysis', '(value)', 'Return a structured explanation of a change profile and related assumptions.', 'professional_function_catalog.md'), + ('quantitativeAnalysisDocumentDataSequence', 'Quantitative Analysis', '(value)', 'Return a structured explanation of a data sequence and related assumptions.', 'professional_function_catalog.md'), + ('quantitativeAnalysisDocumentExtremumProfile', 'Quantitative Analysis', '(value)', 'Return a structured explanation of a extremum profile and related assumptions.', 'professional_function_catalog.md'), + ('quantitativeAnalysisDocumentRankingModel', 'Quantitative Analysis', '(value)', 'Return a structured explanation of a ranking model and related assumptions.', 'professional_function_catalog.md'), + ('quantitativeAnalysisDocumentTrendSegment', 'Quantitative Analysis', '(value)', 'Return a structured explanation of a trend segment and related assumptions.', 'professional_function_catalog.md'), + ('quantitativeAnalysisEnumerateChangeProfile', 'Quantitative Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a change profile.', 'professional_function_catalog.md'), + ('quantitativeAnalysisEnumerateDataSequence', 'Quantitative Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a data sequence.', 'professional_function_catalog.md'), + ('quantitativeAnalysisEnumerateExtremumProfile', 'Quantitative Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a extremum profile.', 'professional_function_catalog.md'), + ('quantitativeAnalysisEnumerateRankingModel', 'Quantitative Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a ranking model.', 'professional_function_catalog.md'), + ('quantitativeAnalysisEnumerateTrendSegment', 'Quantitative Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a trend segment.', 'professional_function_catalog.md'), + ('quantitativeAnalysisEstimateChangeProfile', 'Quantitative Analysis', '(value, samples=None)', 'Estimate a change profile property from finite samples or approximations.', 'professional_function_catalog.md'), + ('quantitativeAnalysisEstimateDataSequence', 'Quantitative Analysis', '(value, samples=None)', 'Estimate a data sequence property from finite samples or approximations.', 'professional_function_catalog.md'), + ('quantitativeAnalysisEstimateExtremumProfile', 'Quantitative Analysis', '(value, samples=None)', 'Estimate a extremum profile property from finite samples or approximations.', 'professional_function_catalog.md'), + ('quantitativeAnalysisEstimateRankingModel', 'Quantitative Analysis', '(value, samples=None)', 'Estimate a ranking model property from finite samples or approximations.', 'professional_function_catalog.md'), + ('quantitativeAnalysisEstimateTrendSegment', 'Quantitative Analysis', '(value, samples=None)', 'Estimate a trend segment property from finite samples or approximations.', 'professional_function_catalog.md'), + ('quantitativeAnalysisEvaluateChangeProfile', 'Quantitative Analysis', '(value, point=None)', 'Evaluate a change profile at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('quantitativeAnalysisEvaluateDataSequence', 'Quantitative Analysis', '(value, point=None)', 'Evaluate a data sequence at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('quantitativeAnalysisEvaluateExtremumProfile', 'Quantitative Analysis', '(value, point=None)', 'Evaluate a extremum profile at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('quantitativeAnalysisEvaluateRankingModel', 'Quantitative Analysis', '(value, point=None)', 'Evaluate a ranking model at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('quantitativeAnalysisEvaluateTrendSegment', 'Quantitative Analysis', '(value, point=None)', 'Evaluate a trend segment at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('quantitativeAnalysisFormatChangeProfile', 'Quantitative Analysis', '(value)', 'Format a change profile for deterministic user-facing output.', 'professional_function_catalog.md'), + ('quantitativeAnalysisFormatDataSequence', 'Quantitative Analysis', '(value)', 'Format a data sequence for deterministic user-facing output.', 'professional_function_catalog.md'), + ('quantitativeAnalysisFormatExtremumProfile', 'Quantitative Analysis', '(value)', 'Format a extremum profile for deterministic user-facing output.', 'professional_function_catalog.md'), + ('quantitativeAnalysisFormatRankingModel', 'Quantitative Analysis', '(value)', 'Format a ranking model for deterministic user-facing output.', 'professional_function_catalog.md'), + ('quantitativeAnalysisFormatTrendSegment', 'Quantitative Analysis', '(value)', 'Format a trend segment for deterministic user-facing output.', 'professional_function_catalog.md'), + ('quantitativeAnalysisGenerateExampleChangeProfile', 'Quantitative Analysis', '(size=3)', 'Generate a small documented example of a change profile.', 'professional_function_catalog.md'), + ('quantitativeAnalysisGenerateExampleDataSequence', 'Quantitative Analysis', '(size=3)', 'Generate a small documented example of a data sequence.', 'professional_function_catalog.md'), + ('quantitativeAnalysisGenerateExampleExtremumProfile', 'Quantitative Analysis', '(size=3)', 'Generate a small documented example of a extremum profile.', 'professional_function_catalog.md'), + ('quantitativeAnalysisGenerateExampleRankingModel', 'Quantitative Analysis', '(size=3)', 'Generate a small documented example of a ranking model.', 'professional_function_catalog.md'), + ('quantitativeAnalysisGenerateExampleTrendSegment', 'Quantitative Analysis', '(size=3)', 'Generate a small documented example of a trend segment.', 'professional_function_catalog.md'), + ('quantitativeAnalysisNormalizeChangeProfile', 'Quantitative Analysis', '(value)', 'Normalize a change profile into the standard Quantitative Analysis representation.', 'professional_function_catalog.md'), + ('quantitativeAnalysisNormalizeDataSequence', 'Quantitative Analysis', '(value)', 'Normalize a data sequence into the standard Quantitative Analysis representation.', 'professional_function_catalog.md'), + ('quantitativeAnalysisNormalizeExtremumProfile', 'Quantitative Analysis', '(value)', 'Normalize a extremum profile into the standard Quantitative Analysis representation.', 'professional_function_catalog.md'), + ('quantitativeAnalysisNormalizeRankingModel', 'Quantitative Analysis', '(value)', 'Normalize a ranking model into the standard Quantitative Analysis representation.', 'professional_function_catalog.md'), + ('quantitativeAnalysisNormalizeTrendSegment', 'Quantitative Analysis', '(value)', 'Normalize a trend segment into the standard Quantitative Analysis representation.', 'professional_function_catalog.md'), + ('quantitativeAnalysisParseChangeProfile', 'Quantitative Analysis', '(text)', 'Parse a text or structured value into a change profile.', 'professional_function_catalog.md'), + ('quantitativeAnalysisParseDataSequence', 'Quantitative Analysis', '(text)', 'Parse a text or structured value into a data sequence.', 'professional_function_catalog.md'), + ('quantitativeAnalysisParseExtremumProfile', 'Quantitative Analysis', '(text)', 'Parse a text or structured value into a extremum profile.', 'professional_function_catalog.md'), + ('quantitativeAnalysisParseRankingModel', 'Quantitative Analysis', '(text)', 'Parse a text or structured value into a ranking model.', 'professional_function_catalog.md'), + ('quantitativeAnalysisParseTrendSegment', 'Quantitative Analysis', '(text)', 'Parse a text or structured value into a trend segment.', 'professional_function_catalog.md'), + ('quantitativeAnalysisSimplifyChangeProfile', 'Quantitative Analysis', '(value)', 'Simplify a change profile without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('quantitativeAnalysisSimplifyDataSequence', 'Quantitative Analysis', '(value)', 'Simplify a data sequence without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('quantitativeAnalysisSimplifyExtremumProfile', 'Quantitative Analysis', '(value)', 'Simplify a extremum profile without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('quantitativeAnalysisSimplifyRankingModel', 'Quantitative Analysis', '(value)', 'Simplify a ranking model without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('quantitativeAnalysisSimplifyTrendSegment', 'Quantitative Analysis', '(value)', 'Simplify a trend segment without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('quantitativeAnalysisTestEquivalenceChangeProfile', 'Quantitative Analysis', '(left, right)', 'Test whether two change profile values are equivalent in Quantitative Analysis.', 'professional_function_catalog.md'), + ('quantitativeAnalysisTestEquivalenceDataSequence', 'Quantitative Analysis', '(left, right)', 'Test whether two data sequence values are equivalent in Quantitative Analysis.', 'professional_function_catalog.md'), + ('quantitativeAnalysisTestEquivalenceExtremumProfile', 'Quantitative Analysis', '(left, right)', 'Test whether two extremum profile values are equivalent in Quantitative Analysis.', 'professional_function_catalog.md'), + ('quantitativeAnalysisTestEquivalenceRankingModel', 'Quantitative Analysis', '(left, right)', 'Test whether two ranking model values are equivalent in Quantitative Analysis.', 'professional_function_catalog.md'), + ('quantitativeAnalysisTestEquivalenceTrendSegment', 'Quantitative Analysis', '(left, right)', 'Test whether two trend segment values are equivalent in Quantitative Analysis.', 'professional_function_catalog.md'), + ('quantitativeAnalysisTransformChangeProfile', 'Quantitative Analysis', '(value, mapping)', 'Transform a change profile through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('quantitativeAnalysisTransformDataSequence', 'Quantitative Analysis', '(value, mapping)', 'Transform a data sequence through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('quantitativeAnalysisTransformExtremumProfile', 'Quantitative Analysis', '(value, mapping)', 'Transform a extremum profile through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('quantitativeAnalysisTransformRankingModel', 'Quantitative Analysis', '(value, mapping)', 'Transform a ranking model through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('quantitativeAnalysisTransformTrendSegment', 'Quantitative Analysis', '(value, mapping)', 'Transform a trend segment through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('quantitativeAnalysisValidateChangeProfile', 'Quantitative Analysis', '(value)', 'Validate the change profile representation and domain rules for Quantitative Analysis.', 'professional_function_catalog.md'), + ('quantitativeAnalysisValidateDataSequence', 'Quantitative Analysis', '(value)', 'Validate the data sequence representation and domain rules for Quantitative Analysis.', 'professional_function_catalog.md'), + ('quantitativeAnalysisValidateExtremumProfile', 'Quantitative Analysis', '(value)', 'Validate the extremum profile representation and domain rules for Quantitative Analysis.', 'professional_function_catalog.md'), + ('quantitativeAnalysisValidateRankingModel', 'Quantitative Analysis', '(value)', 'Validate the ranking model representation and domain rules for Quantitative Analysis.', 'professional_function_catalog.md'), + ('quantitativeAnalysisValidateTrendSegment', 'Quantitative Analysis', '(value)', 'Validate the trend segment representation and domain rules for Quantitative Analysis.', 'professional_function_catalog.md'), + ('rangeOfData', 'Quantitative Analysis', '(arr)', 'Planned roadmap function for Quantitative Analysis from upcoming.md.', 'upcoming.md'), + ('boundedAbove', 'Real Analysis', '(values)', 'Planned roadmap function for Real Analysis from upcoming.md.', 'upcoming.md'), + ('boundedBelow', 'Real Analysis', '(values)', 'Planned roadmap function for Real Analysis from upcoming.md.', 'upcoming.md'), + ('epsilonDeltaLimit', 'Real Analysis', '(f, a, L, epsilonValues)', 'Planned roadmap function for Real Analysis from upcoming.md.', 'upcoming.md'), + ('infimum', 'Real Analysis', '(values)', 'Planned roadmap function for Real Analysis from upcoming.md.', 'upcoming.md'), + ('isCauchySequence', 'Real Analysis', '(sequence, tolerance=1e-9)', 'Planned roadmap function for Real Analysis from upcoming.md.', 'upcoming.md'), + ('isConvergentSequence', 'Real Analysis', '(sequence, tolerance=1e-9)', 'Planned roadmap function for Real Analysis from upcoming.md.', 'upcoming.md'), + ('isConvergentSeries', 'Real Analysis', '(terms, tolerance=1e-9)', 'Planned roadmap function for Real Analysis from upcoming.md.', 'upcoming.md'), + ('ratioTest', 'Real Analysis', '(terms, n)', 'Planned roadmap function for Real Analysis from upcoming.md.', 'upcoming.md'), + ('realAnalysisApproximateBoundedSet', 'Real Analysis', '(value, tolerance=1e-9)', 'Approximate a bounded set with explicit tolerance controls.', 'professional_function_catalog.md'), + ('realAnalysisApproximateEpsilonDeltaProof', 'Real Analysis', '(value, tolerance=1e-9)', 'Approximate a epsilon delta proof with explicit tolerance controls.', 'professional_function_catalog.md'), + ('realAnalysisApproximateRealFunction', 'Real Analysis', '(value, tolerance=1e-9)', 'Approximate a real function with explicit tolerance controls.', 'professional_function_catalog.md'), + ('realAnalysisApproximateSequence', 'Real Analysis', '(value, tolerance=1e-9)', 'Approximate a sequence with explicit tolerance controls.', 'professional_function_catalog.md'), + ('realAnalysisApproximateSeries', 'Real Analysis', '(value, tolerance=1e-9)', 'Approximate a series with explicit tolerance controls.', 'professional_function_catalog.md'), + ('realAnalysisCanonicalizeBoundedSet', 'Real Analysis', '(value)', 'Canonicalize a bounded set so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('realAnalysisCanonicalizeEpsilonDeltaProof', 'Real Analysis', '(value)', 'Canonicalize a epsilon delta proof so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('realAnalysisCanonicalizeRealFunction', 'Real Analysis', '(value)', 'Canonicalize a real function so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('realAnalysisCanonicalizeSequence', 'Real Analysis', '(value)', 'Canonicalize a sequence so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('realAnalysisCanonicalizeSeries', 'Real Analysis', '(value)', 'Canonicalize a series so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('realAnalysisClassifyBoundedSet', 'Real Analysis', '(value)', 'Classify a bounded set by its standard Real Analysis invariants.', 'professional_function_catalog.md'), + ('realAnalysisClassifyEpsilonDeltaProof', 'Real Analysis', '(value)', 'Classify a epsilon delta proof by its standard Real Analysis invariants.', 'professional_function_catalog.md'), + ('realAnalysisClassifyRealFunction', 'Real Analysis', '(value)', 'Classify a real function by its standard Real Analysis invariants.', 'professional_function_catalog.md'), + ('realAnalysisClassifySequence', 'Real Analysis', '(value)', 'Classify a sequence by its standard Real Analysis invariants.', 'professional_function_catalog.md'), + ('realAnalysisClassifySeries', 'Real Analysis', '(value)', 'Classify a series by its standard Real Analysis invariants.', 'professional_function_catalog.md'), + ('realAnalysisCombineBoundedSet', 'Real Analysis', '(left, right)', 'Combine two bounded set values with the natural operation for Real Analysis.', 'professional_function_catalog.md'), + ('realAnalysisCombineEpsilonDeltaProof', 'Real Analysis', '(left, right)', 'Combine two epsilon delta proof values with the natural operation for Real Analysis.', 'professional_function_catalog.md'), + ('realAnalysisCombineRealFunction', 'Real Analysis', '(left, right)', 'Combine two real function values with the natural operation for Real Analysis.', 'professional_function_catalog.md'), + ('realAnalysisCombineSequence', 'Real Analysis', '(left, right)', 'Combine two sequence values with the natural operation for Real Analysis.', 'professional_function_catalog.md'), + ('realAnalysisCombineSeries', 'Real Analysis', '(left, right)', 'Combine two series values with the natural operation for Real Analysis.', 'professional_function_catalog.md'), + ('realAnalysisCompareBoundedSet', 'Real Analysis', '(left, right)', 'Compare two bounded set values under the conventions of Real Analysis.', 'professional_function_catalog.md'), + ('realAnalysisCompareEpsilonDeltaProof', 'Real Analysis', '(left, right)', 'Compare two epsilon delta proof values under the conventions of Real Analysis.', 'professional_function_catalog.md'), + ('realAnalysisCompareRealFunction', 'Real Analysis', '(left, right)', 'Compare two real function values under the conventions of Real Analysis.', 'professional_function_catalog.md'), + ('realAnalysisCompareSequence', 'Real Analysis', '(left, right)', 'Compare two sequence values under the conventions of Real Analysis.', 'professional_function_catalog.md'), + ('realAnalysisCompareSeries', 'Real Analysis', '(left, right)', 'Compare two series values under the conventions of Real Analysis.', 'professional_function_catalog.md'), + ('realAnalysisComputeBoundedSet', 'Real Analysis', '(value)', 'Compute the central numerical or symbolic data of a bounded set.', 'professional_function_catalog.md'), + ('realAnalysisComputeEpsilonDeltaProof', 'Real Analysis', '(value)', 'Compute the central numerical or symbolic data of a epsilon delta proof.', 'professional_function_catalog.md'), + ('realAnalysisComputeRealFunction', 'Real Analysis', '(value)', 'Compute the central numerical or symbolic data of a real function.', 'professional_function_catalog.md'), + ('realAnalysisComputeSequence', 'Real Analysis', '(value)', 'Compute the central numerical or symbolic data of a sequence.', 'professional_function_catalog.md'), + ('realAnalysisComputeSeries', 'Real Analysis', '(value)', 'Compute the central numerical or symbolic data of a series.', 'professional_function_catalog.md'), + ('realAnalysisConstructBoundedSet', 'Real Analysis', '(*args)', 'Construct a bounded set from explicit inputs for Real Analysis.', 'professional_function_catalog.md'), + ('realAnalysisConstructEpsilonDeltaProof', 'Real Analysis', '(*args)', 'Construct a epsilon delta proof from explicit inputs for Real Analysis.', 'professional_function_catalog.md'), + ('realAnalysisConstructRealFunction', 'Real Analysis', '(*args)', 'Construct a real function from explicit inputs for Real Analysis.', 'professional_function_catalog.md'), + ('realAnalysisConstructSequence', 'Real Analysis', '(*args)', 'Construct a sequence from explicit inputs for Real Analysis.', 'professional_function_catalog.md'), + ('realAnalysisConstructSeries', 'Real Analysis', '(*args)', 'Construct a series from explicit inputs for Real Analysis.', 'professional_function_catalog.md'), + ('realAnalysisDecomposeBoundedSet', 'Real Analysis', '(value)', 'Decompose a bounded set into simpler or canonical components.', 'professional_function_catalog.md'), + ('realAnalysisDecomposeEpsilonDeltaProof', 'Real Analysis', '(value)', 'Decompose a epsilon delta proof into simpler or canonical components.', 'professional_function_catalog.md'), + ('realAnalysisDecomposeRealFunction', 'Real Analysis', '(value)', 'Decompose a real function into simpler or canonical components.', 'professional_function_catalog.md'), + ('realAnalysisDecomposeSequence', 'Real Analysis', '(value)', 'Decompose a sequence into simpler or canonical components.', 'professional_function_catalog.md'), + ('realAnalysisDecomposeSeries', 'Real Analysis', '(value)', 'Decompose a series into simpler or canonical components.', 'professional_function_catalog.md'), + ('realAnalysisDocumentBoundedSet', 'Real Analysis', '(value)', 'Return a structured explanation of a bounded set and related assumptions.', 'professional_function_catalog.md'), + ('realAnalysisDocumentEpsilonDeltaProof', 'Real Analysis', '(value)', 'Return a structured explanation of a epsilon delta proof and related assumptions.', 'professional_function_catalog.md'), + ('realAnalysisDocumentRealFunction', 'Real Analysis', '(value)', 'Return a structured explanation of a real function and related assumptions.', 'professional_function_catalog.md'), + ('realAnalysisDocumentSequence', 'Real Analysis', '(value)', 'Return a structured explanation of a sequence and related assumptions.', 'professional_function_catalog.md'), + ('realAnalysisDocumentSeries', 'Real Analysis', '(value)', 'Return a structured explanation of a series and related assumptions.', 'professional_function_catalog.md'), + ('realAnalysisEnumerateBoundedSet', 'Real Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a bounded set.', 'professional_function_catalog.md'), + ('realAnalysisEnumerateEpsilonDeltaProof', 'Real Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a epsilon delta proof.', 'professional_function_catalog.md'), + ('realAnalysisEnumerateRealFunction', 'Real Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a real function.', 'professional_function_catalog.md'), + ('realAnalysisEnumerateSequence', 'Real Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a sequence.', 'professional_function_catalog.md'), + ('realAnalysisEnumerateSeries', 'Real Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a series.', 'professional_function_catalog.md'), + ('realAnalysisEstimateBoundedSet', 'Real Analysis', '(value, samples=None)', 'Estimate a bounded set property from finite samples or approximations.', 'professional_function_catalog.md'), + ('realAnalysisEstimateEpsilonDeltaProof', 'Real Analysis', '(value, samples=None)', 'Estimate a epsilon delta proof property from finite samples or approximations.', 'professional_function_catalog.md'), + ('realAnalysisEstimateRealFunction', 'Real Analysis', '(value, samples=None)', 'Estimate a real function property from finite samples or approximations.', 'professional_function_catalog.md'), + ('realAnalysisEstimateSequence', 'Real Analysis', '(value, samples=None)', 'Estimate a sequence property from finite samples or approximations.', 'professional_function_catalog.md'), + ('realAnalysisEstimateSeries', 'Real Analysis', '(value, samples=None)', 'Estimate a series property from finite samples or approximations.', 'professional_function_catalog.md'), + ('realAnalysisEvaluateBoundedSet', 'Real Analysis', '(value, point=None)', 'Evaluate a bounded set at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('realAnalysisEvaluateEpsilonDeltaProof', 'Real Analysis', '(value, point=None)', 'Evaluate a epsilon delta proof at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('realAnalysisEvaluateRealFunction', 'Real Analysis', '(value, point=None)', 'Evaluate a real function at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('realAnalysisEvaluateSequence', 'Real Analysis', '(value, point=None)', 'Evaluate a sequence at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('realAnalysisEvaluateSeries', 'Real Analysis', '(value, point=None)', 'Evaluate a series at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('realAnalysisFormatBoundedSet', 'Real Analysis', '(value)', 'Format a bounded set for deterministic user-facing output.', 'professional_function_catalog.md'), + ('realAnalysisFormatEpsilonDeltaProof', 'Real Analysis', '(value)', 'Format a epsilon delta proof for deterministic user-facing output.', 'professional_function_catalog.md'), + ('realAnalysisFormatRealFunction', 'Real Analysis', '(value)', 'Format a real function for deterministic user-facing output.', 'professional_function_catalog.md'), + ('realAnalysisFormatSequence', 'Real Analysis', '(value)', 'Format a sequence for deterministic user-facing output.', 'professional_function_catalog.md'), + ('realAnalysisFormatSeries', 'Real Analysis', '(value)', 'Format a series for deterministic user-facing output.', 'professional_function_catalog.md'), + ('realAnalysisGenerateExampleBoundedSet', 'Real Analysis', '(size=3)', 'Generate a small documented example of a bounded set.', 'professional_function_catalog.md'), + ('realAnalysisGenerateExampleEpsilonDeltaProof', 'Real Analysis', '(size=3)', 'Generate a small documented example of a epsilon delta proof.', 'professional_function_catalog.md'), + ('realAnalysisGenerateExampleRealFunction', 'Real Analysis', '(size=3)', 'Generate a small documented example of a real function.', 'professional_function_catalog.md'), + ('realAnalysisGenerateExampleSequence', 'Real Analysis', '(size=3)', 'Generate a small documented example of a sequence.', 'professional_function_catalog.md'), + ('realAnalysisGenerateExampleSeries', 'Real Analysis', '(size=3)', 'Generate a small documented example of a series.', 'professional_function_catalog.md'), + ('realAnalysisNormalizeBoundedSet', 'Real Analysis', '(value)', 'Normalize a bounded set into the standard Real Analysis representation.', 'professional_function_catalog.md'), + ('realAnalysisNormalizeEpsilonDeltaProof', 'Real Analysis', '(value)', 'Normalize a epsilon delta proof into the standard Real Analysis representation.', 'professional_function_catalog.md'), + ('realAnalysisNormalizeRealFunction', 'Real Analysis', '(value)', 'Normalize a real function into the standard Real Analysis representation.', 'professional_function_catalog.md'), + ('realAnalysisNormalizeSequence', 'Real Analysis', '(value)', 'Normalize a sequence into the standard Real Analysis representation.', 'professional_function_catalog.md'), + ('realAnalysisNormalizeSeries', 'Real Analysis', '(value)', 'Normalize a series into the standard Real Analysis representation.', 'professional_function_catalog.md'), + ('realAnalysisParseBoundedSet', 'Real Analysis', '(text)', 'Parse a text or structured value into a bounded set.', 'professional_function_catalog.md'), + ('realAnalysisParseEpsilonDeltaProof', 'Real Analysis', '(text)', 'Parse a text or structured value into a epsilon delta proof.', 'professional_function_catalog.md'), + ('realAnalysisParseRealFunction', 'Real Analysis', '(text)', 'Parse a text or structured value into a real function.', 'professional_function_catalog.md'), + ('realAnalysisParseSequence', 'Real Analysis', '(text)', 'Parse a text or structured value into a sequence.', 'professional_function_catalog.md'), + ('realAnalysisParseSeries', 'Real Analysis', '(text)', 'Parse a text or structured value into a series.', 'professional_function_catalog.md'), + ('realAnalysisSimplifyBoundedSet', 'Real Analysis', '(value)', 'Simplify a bounded set without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('realAnalysisSimplifyEpsilonDeltaProof', 'Real Analysis', '(value)', 'Simplify a epsilon delta proof without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('realAnalysisSimplifyRealFunction', 'Real Analysis', '(value)', 'Simplify a real function without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('realAnalysisSimplifySequence', 'Real Analysis', '(value)', 'Simplify a sequence without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('realAnalysisSimplifySeries', 'Real Analysis', '(value)', 'Simplify a series without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('realAnalysisTestEquivalenceBoundedSet', 'Real Analysis', '(left, right)', 'Test whether two bounded set values are equivalent in Real Analysis.', 'professional_function_catalog.md'), + ('realAnalysisTestEquivalenceEpsilonDeltaProof', 'Real Analysis', '(left, right)', 'Test whether two epsilon delta proof values are equivalent in Real Analysis.', 'professional_function_catalog.md'), + ('realAnalysisTestEquivalenceRealFunction', 'Real Analysis', '(left, right)', 'Test whether two real function values are equivalent in Real Analysis.', 'professional_function_catalog.md'), + ('realAnalysisTestEquivalenceSequence', 'Real Analysis', '(left, right)', 'Test whether two sequence values are equivalent in Real Analysis.', 'professional_function_catalog.md'), + ('realAnalysisTestEquivalenceSeries', 'Real Analysis', '(left, right)', 'Test whether two series values are equivalent in Real Analysis.', 'professional_function_catalog.md'), + ('realAnalysisTransformBoundedSet', 'Real Analysis', '(value, mapping)', 'Transform a bounded set through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('realAnalysisTransformEpsilonDeltaProof', 'Real Analysis', '(value, mapping)', 'Transform a epsilon delta proof through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('realAnalysisTransformRealFunction', 'Real Analysis', '(value, mapping)', 'Transform a real function through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('realAnalysisTransformSequence', 'Real Analysis', '(value, mapping)', 'Transform a sequence through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('realAnalysisTransformSeries', 'Real Analysis', '(value, mapping)', 'Transform a series through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('realAnalysisValidateBoundedSet', 'Real Analysis', '(value)', 'Validate the bounded set representation and domain rules for Real Analysis.', 'professional_function_catalog.md'), + ('realAnalysisValidateEpsilonDeltaProof', 'Real Analysis', '(value)', 'Validate the epsilon delta proof representation and domain rules for Real Analysis.', 'professional_function_catalog.md'), + ('realAnalysisValidateRealFunction', 'Real Analysis', '(value)', 'Validate the real function representation and domain rules for Real Analysis.', 'professional_function_catalog.md'), + ('realAnalysisValidateSequence', 'Real Analysis', '(value)', 'Validate the sequence representation and domain rules for Real Analysis.', 'professional_function_catalog.md'), + ('realAnalysisValidateSeries', 'Real Analysis', '(value)', 'Validate the series representation and domain rules for Real Analysis.', 'professional_function_catalog.md'), + ('rootTest', 'Real Analysis', '(terms, n)', 'Planned roadmap function for Real Analysis from upcoming.md.', 'upcoming.md'), + ('sequenceLimit', 'Real Analysis', '(sequence, tolerance=1e-9)', 'Planned roadmap function for Real Analysis from upcoming.md.', 'upcoming.md'), + ('seriesPartialSums', 'Real Analysis', '(terms, n)', 'Planned roadmap function for Real Analysis from upcoming.md.', 'upcoming.md'), + ('supremum', 'Real Analysis', '(values)', 'Planned roadmap function for Real Analysis from upcoming.md.', 'upcoming.md'), + ('uniformContinuity', 'Real Analysis', '(f, domainPoints, tolerance=1e-9)', 'Planned roadmap function for Real Analysis from upcoming.md.', 'upcoming.md'), + ('burnsideLemma', 'Representation Theory', '(group, setValues, action)', 'Planned roadmap function for Representation Theory from upcoming.md.', 'upcoming.md'), + ('characterOfRepresentation', 'Representation Theory', '(matrices)', 'Planned roadmap function for Representation Theory from upcoming.md.', 'upcoming.md'), + ('groupAction', 'Representation Theory', '(group, setValues, action)', 'Planned roadmap function for Representation Theory from upcoming.md.', 'upcoming.md'), + ('isInvariantSubspace', 'Representation Theory', '(subspace, matrices)', 'Planned roadmap function for Representation Theory from upcoming.md.', 'upcoming.md'), + ('orbitOfElement', 'Representation Theory', '(group, element, action)', 'Planned roadmap function for Representation Theory from upcoming.md.', 'upcoming.md'), + ('regularRepresentation', 'Representation Theory', '(group)', 'Planned roadmap function for Representation Theory from upcoming.md.', 'upcoming.md'), + ('representationMatrices', 'Representation Theory', '(group, mapping)', 'Planned roadmap function for Representation Theory from upcoming.md.', 'upcoming.md'), + ('representationTheoryApproximateCharacter', 'Representation Theory', '(value, tolerance=1e-9)', 'Approximate a character with explicit tolerance controls.', 'professional_function_catalog.md'), + ('representationTheoryApproximateGroupAction', 'Representation Theory', '(value, tolerance=1e-9)', 'Approximate a group action with explicit tolerance controls.', 'professional_function_catalog.md'), + ('representationTheoryApproximateInvariantSubspace', 'Representation Theory', '(value, tolerance=1e-9)', 'Approximate a invariant subspace with explicit tolerance controls.', 'professional_function_catalog.md'), + ('representationTheoryApproximateModule', 'Representation Theory', '(value, tolerance=1e-9)', 'Approximate a module with explicit tolerance controls.', 'professional_function_catalog.md'), + ('representationTheoryApproximateRepresentation', 'Representation Theory', '(value, tolerance=1e-9)', 'Approximate a representation with explicit tolerance controls.', 'professional_function_catalog.md'), + ('representationTheoryCanonicalizeCharacter', 'Representation Theory', '(value)', 'Canonicalize a character so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('representationTheoryCanonicalizeGroupAction', 'Representation Theory', '(value)', 'Canonicalize a group action so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('representationTheoryCanonicalizeInvariantSubspace', 'Representation Theory', '(value)', 'Canonicalize a invariant subspace so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('representationTheoryCanonicalizeModule', 'Representation Theory', '(value)', 'Canonicalize a module so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('representationTheoryCanonicalizeRepresentation', 'Representation Theory', '(value)', 'Canonicalize a representation so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('representationTheoryClassifyCharacter', 'Representation Theory', '(value)', 'Classify a character by its standard Representation Theory invariants.', 'professional_function_catalog.md'), + ('representationTheoryClassifyGroupAction', 'Representation Theory', '(value)', 'Classify a group action by its standard Representation Theory invariants.', 'professional_function_catalog.md'), + ('representationTheoryClassifyInvariantSubspace', 'Representation Theory', '(value)', 'Classify a invariant subspace by its standard Representation Theory invariants.', 'professional_function_catalog.md'), + ('representationTheoryClassifyModule', 'Representation Theory', '(value)', 'Classify a module by its standard Representation Theory invariants.', 'professional_function_catalog.md'), + ('representationTheoryClassifyRepresentation', 'Representation Theory', '(value)', 'Classify a representation by its standard Representation Theory invariants.', 'professional_function_catalog.md'), + ('representationTheoryCombineCharacter', 'Representation Theory', '(left, right)', 'Combine two character values with the natural operation for Representation Theory.', 'professional_function_catalog.md'), + ('representationTheoryCombineGroupAction', 'Representation Theory', '(left, right)', 'Combine two group action values with the natural operation for Representation Theory.', 'professional_function_catalog.md'), + ('representationTheoryCombineInvariantSubspace', 'Representation Theory', '(left, right)', 'Combine two invariant subspace values with the natural operation for Representation Theory.', 'professional_function_catalog.md'), + ('representationTheoryCombineModule', 'Representation Theory', '(left, right)', 'Combine two module values with the natural operation for Representation Theory.', 'professional_function_catalog.md'), + ('representationTheoryCombineRepresentation', 'Representation Theory', '(left, right)', 'Combine two representation values with the natural operation for Representation Theory.', 'professional_function_catalog.md'), + ('representationTheoryCompareCharacter', 'Representation Theory', '(left, right)', 'Compare two character values under the conventions of Representation Theory.', 'professional_function_catalog.md'), + ('representationTheoryCompareGroupAction', 'Representation Theory', '(left, right)', 'Compare two group action values under the conventions of Representation Theory.', 'professional_function_catalog.md'), + ('representationTheoryCompareInvariantSubspace', 'Representation Theory', '(left, right)', 'Compare two invariant subspace values under the conventions of Representation Theory.', 'professional_function_catalog.md'), + ('representationTheoryCompareModule', 'Representation Theory', '(left, right)', 'Compare two module values under the conventions of Representation Theory.', 'professional_function_catalog.md'), + ('representationTheoryCompareRepresentation', 'Representation Theory', '(left, right)', 'Compare two representation values under the conventions of Representation Theory.', 'professional_function_catalog.md'), + ('representationTheoryComputeCharacter', 'Representation Theory', '(value)', 'Compute the central numerical or symbolic data of a character.', 'professional_function_catalog.md'), + ('representationTheoryComputeGroupAction', 'Representation Theory', '(value)', 'Compute the central numerical or symbolic data of a group action.', 'professional_function_catalog.md'), + ('representationTheoryComputeInvariantSubspace', 'Representation Theory', '(value)', 'Compute the central numerical or symbolic data of a invariant subspace.', 'professional_function_catalog.md'), + ('representationTheoryComputeModule', 'Representation Theory', '(value)', 'Compute the central numerical or symbolic data of a module.', 'professional_function_catalog.md'), + ('representationTheoryComputeRepresentation', 'Representation Theory', '(value)', 'Compute the central numerical or symbolic data of a representation.', 'professional_function_catalog.md'), + ('representationTheoryConstructCharacter', 'Representation Theory', '(*args)', 'Construct a character from explicit inputs for Representation Theory.', 'professional_function_catalog.md'), + ('representationTheoryConstructGroupAction', 'Representation Theory', '(*args)', 'Construct a group action from explicit inputs for Representation Theory.', 'professional_function_catalog.md'), + ('representationTheoryConstructInvariantSubspace', 'Representation Theory', '(*args)', 'Construct a invariant subspace from explicit inputs for Representation Theory.', 'professional_function_catalog.md'), + ('representationTheoryConstructModule', 'Representation Theory', '(*args)', 'Construct a module from explicit inputs for Representation Theory.', 'professional_function_catalog.md'), + ('representationTheoryConstructRepresentation', 'Representation Theory', '(*args)', 'Construct a representation from explicit inputs for Representation Theory.', 'professional_function_catalog.md'), + ('representationTheoryDecomposeCharacter', 'Representation Theory', '(value)', 'Decompose a character into simpler or canonical components.', 'professional_function_catalog.md'), + ('representationTheoryDecomposeGroupAction', 'Representation Theory', '(value)', 'Decompose a group action into simpler or canonical components.', 'professional_function_catalog.md'), + ('representationTheoryDecomposeInvariantSubspace', 'Representation Theory', '(value)', 'Decompose a invariant subspace into simpler or canonical components.', 'professional_function_catalog.md'), + ('representationTheoryDecomposeModule', 'Representation Theory', '(value)', 'Decompose a module into simpler or canonical components.', 'professional_function_catalog.md'), + ('representationTheoryDecomposeRepresentation', 'Representation Theory', '(value)', 'Decompose a representation into simpler or canonical components.', 'professional_function_catalog.md'), + ('representationTheoryDocumentCharacter', 'Representation Theory', '(value)', 'Return a structured explanation of a character and related assumptions.', 'professional_function_catalog.md'), + ('representationTheoryDocumentGroupAction', 'Representation Theory', '(value)', 'Return a structured explanation of a group action and related assumptions.', 'professional_function_catalog.md'), + ('representationTheoryDocumentInvariantSubspace', 'Representation Theory', '(value)', 'Return a structured explanation of a invariant subspace and related assumptions.', 'professional_function_catalog.md'), + ('representationTheoryDocumentModule', 'Representation Theory', '(value)', 'Return a structured explanation of a module and related assumptions.', 'professional_function_catalog.md'), + ('representationTheoryDocumentRepresentation', 'Representation Theory', '(value)', 'Return a structured explanation of a representation and related assumptions.', 'professional_function_catalog.md'), + ('representationTheoryEnumerateCharacter', 'Representation Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a character.', 'professional_function_catalog.md'), + ('representationTheoryEnumerateGroupAction', 'Representation Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a group action.', 'professional_function_catalog.md'), + ('representationTheoryEnumerateInvariantSubspace', 'Representation Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a invariant subspace.', 'professional_function_catalog.md'), + ('representationTheoryEnumerateModule', 'Representation Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a module.', 'professional_function_catalog.md'), + ('representationTheoryEnumerateRepresentation', 'Representation Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a representation.', 'professional_function_catalog.md'), + ('representationTheoryEstimateCharacter', 'Representation Theory', '(value, samples=None)', 'Estimate a character property from finite samples or approximations.', 'professional_function_catalog.md'), + ('representationTheoryEstimateGroupAction', 'Representation Theory', '(value, samples=None)', 'Estimate a group action property from finite samples or approximations.', 'professional_function_catalog.md'), + ('representationTheoryEstimateInvariantSubspace', 'Representation Theory', '(value, samples=None)', 'Estimate a invariant subspace property from finite samples or approximations.', 'professional_function_catalog.md'), + ('representationTheoryEstimateModule', 'Representation Theory', '(value, samples=None)', 'Estimate a module property from finite samples or approximations.', 'professional_function_catalog.md'), + ('representationTheoryEstimateRepresentation', 'Representation Theory', '(value, samples=None)', 'Estimate a representation property from finite samples or approximations.', 'professional_function_catalog.md'), + ('representationTheoryEvaluateCharacter', 'Representation Theory', '(value, point=None)', 'Evaluate a character at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('representationTheoryEvaluateGroupAction', 'Representation Theory', '(value, point=None)', 'Evaluate a group action at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('representationTheoryEvaluateInvariantSubspace', 'Representation Theory', '(value, point=None)', 'Evaluate a invariant subspace at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('representationTheoryEvaluateModule', 'Representation Theory', '(value, point=None)', 'Evaluate a module at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('representationTheoryEvaluateRepresentation', 'Representation Theory', '(value, point=None)', 'Evaluate a representation at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('representationTheoryFormatCharacter', 'Representation Theory', '(value)', 'Format a character for deterministic user-facing output.', 'professional_function_catalog.md'), + ('representationTheoryFormatGroupAction', 'Representation Theory', '(value)', 'Format a group action for deterministic user-facing output.', 'professional_function_catalog.md'), + ('representationTheoryFormatInvariantSubspace', 'Representation Theory', '(value)', 'Format a invariant subspace for deterministic user-facing output.', 'professional_function_catalog.md'), + ('representationTheoryFormatModule', 'Representation Theory', '(value)', 'Format a module for deterministic user-facing output.', 'professional_function_catalog.md'), + ('representationTheoryFormatRepresentation', 'Representation Theory', '(value)', 'Format a representation for deterministic user-facing output.', 'professional_function_catalog.md'), + ('representationTheoryGenerateExampleCharacter', 'Representation Theory', '(size=3)', 'Generate a small documented example of a character.', 'professional_function_catalog.md'), + ('representationTheoryGenerateExampleGroupAction', 'Representation Theory', '(size=3)', 'Generate a small documented example of a group action.', 'professional_function_catalog.md'), + ('representationTheoryGenerateExampleInvariantSubspace', 'Representation Theory', '(size=3)', 'Generate a small documented example of a invariant subspace.', 'professional_function_catalog.md'), + ('representationTheoryGenerateExampleModule', 'Representation Theory', '(size=3)', 'Generate a small documented example of a module.', 'professional_function_catalog.md'), + ('representationTheoryGenerateExampleRepresentation', 'Representation Theory', '(size=3)', 'Generate a small documented example of a representation.', 'professional_function_catalog.md'), + ('representationTheoryNormalizeCharacter', 'Representation Theory', '(value)', 'Normalize a character into the standard Representation Theory representation.', 'professional_function_catalog.md'), + ('representationTheoryNormalizeGroupAction', 'Representation Theory', '(value)', 'Normalize a group action into the standard Representation Theory representation.', 'professional_function_catalog.md'), + ('representationTheoryNormalizeInvariantSubspace', 'Representation Theory', '(value)', 'Normalize a invariant subspace into the standard Representation Theory representation.', 'professional_function_catalog.md'), + ('representationTheoryNormalizeModule', 'Representation Theory', '(value)', 'Normalize a module into the standard Representation Theory representation.', 'professional_function_catalog.md'), + ('representationTheoryNormalizeRepresentation', 'Representation Theory', '(value)', 'Normalize a representation into the standard Representation Theory representation.', 'professional_function_catalog.md'), + ('representationTheoryParseCharacter', 'Representation Theory', '(text)', 'Parse a text or structured value into a character.', 'professional_function_catalog.md'), + ('representationTheoryParseGroupAction', 'Representation Theory', '(text)', 'Parse a text or structured value into a group action.', 'professional_function_catalog.md'), + ('representationTheoryParseInvariantSubspace', 'Representation Theory', '(text)', 'Parse a text or structured value into a invariant subspace.', 'professional_function_catalog.md'), + ('representationTheoryParseModule', 'Representation Theory', '(text)', 'Parse a text or structured value into a module.', 'professional_function_catalog.md'), + ('representationTheoryParseRepresentation', 'Representation Theory', '(text)', 'Parse a text or structured value into a representation.', 'professional_function_catalog.md'), + ('representationTheorySimplifyCharacter', 'Representation Theory', '(value)', 'Simplify a character without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('representationTheorySimplifyGroupAction', 'Representation Theory', '(value)', 'Simplify a group action without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('representationTheorySimplifyInvariantSubspace', 'Representation Theory', '(value)', 'Simplify a invariant subspace without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('representationTheorySimplifyModule', 'Representation Theory', '(value)', 'Simplify a module without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('representationTheorySimplifyRepresentation', 'Representation Theory', '(value)', 'Simplify a representation without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('representationTheoryTestEquivalenceCharacter', 'Representation Theory', '(left, right)', 'Test whether two character values are equivalent in Representation Theory.', 'professional_function_catalog.md'), + ('representationTheoryTestEquivalenceGroupAction', 'Representation Theory', '(left, right)', 'Test whether two group action values are equivalent in Representation Theory.', 'professional_function_catalog.md'), + ('representationTheoryTestEquivalenceInvariantSubspace', 'Representation Theory', '(left, right)', 'Test whether two invariant subspace values are equivalent in Representation Theory.', 'professional_function_catalog.md'), + ('representationTheoryTestEquivalenceModule', 'Representation Theory', '(left, right)', 'Test whether two module values are equivalent in Representation Theory.', 'professional_function_catalog.md'), + ('representationTheoryTestEquivalenceRepresentation', 'Representation Theory', '(left, right)', 'Test whether two representation values are equivalent in Representation Theory.', 'professional_function_catalog.md'), + ('representationTheoryTransformCharacter', 'Representation Theory', '(value, mapping)', 'Transform a character through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('representationTheoryTransformGroupAction', 'Representation Theory', '(value, mapping)', 'Transform a group action through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('representationTheoryTransformInvariantSubspace', 'Representation Theory', '(value, mapping)', 'Transform a invariant subspace through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('representationTheoryTransformModule', 'Representation Theory', '(value, mapping)', 'Transform a module through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('representationTheoryTransformRepresentation', 'Representation Theory', '(value, mapping)', 'Transform a representation through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('representationTheoryValidateCharacter', 'Representation Theory', '(value)', 'Validate the character representation and domain rules for Representation Theory.', 'professional_function_catalog.md'), + ('representationTheoryValidateGroupAction', 'Representation Theory', '(value)', 'Validate the group action representation and domain rules for Representation Theory.', 'professional_function_catalog.md'), + ('representationTheoryValidateInvariantSubspace', 'Representation Theory', '(value)', 'Validate the invariant subspace representation and domain rules for Representation Theory.', 'professional_function_catalog.md'), + ('representationTheoryValidateModule', 'Representation Theory', '(value)', 'Validate the module representation and domain rules for Representation Theory.', 'professional_function_catalog.md'), + ('representationTheoryValidateRepresentation', 'Representation Theory', '(value)', 'Validate the representation representation and domain rules for Representation Theory.', 'professional_function_catalog.md'), + ('stabilizer', 'Representation Theory', '(group, element, action)', 'Planned roadmap function for Representation Theory from upcoming.md.', 'upcoming.md'), + ('christoffelSymbols', 'Riemannian Geometry', '(metricFunctions, point)', 'Planned roadmap function for Riemannian Geometry from upcoming.md.', 'upcoming.md'), + ('geodesicEquationStep', 'Riemannian Geometry', '(metricFunctions, state, step)', 'Planned roadmap function for Riemannian Geometry from upcoming.md.', 'upcoming.md'), + ('innerProductMetric', 'Riemannian Geometry', '(metric, v, w)', 'Planned roadmap function for Riemannian Geometry from upcoming.md.', 'upcoming.md'), + ('lowerIndex', 'Riemannian Geometry', '(metric, vector)', 'Planned roadmap function for Riemannian Geometry from upcoming.md.', 'upcoming.md'), + ('metricTensorEuclidean', 'Riemannian Geometry', '(n)', 'Planned roadmap function for Riemannian Geometry from upcoming.md.', 'upcoming.md'), + ('raiseIndex', 'Riemannian Geometry', '(metricInverse, covector)', 'Planned roadmap function for Riemannian Geometry from upcoming.md.', 'upcoming.md'), + ('riemannianGeometryApproximateConnection', 'Riemannian Geometry', '(value, tolerance=1e-9)', 'Approximate a connection with explicit tolerance controls.', 'professional_function_catalog.md'), + ('riemannianGeometryApproximateCurvatureTensor', 'Riemannian Geometry', '(value, tolerance=1e-9)', 'Approximate a curvature tensor with explicit tolerance controls.', 'professional_function_catalog.md'), + ('riemannianGeometryApproximateGeodesic', 'Riemannian Geometry', '(value, tolerance=1e-9)', 'Approximate a geodesic with explicit tolerance controls.', 'professional_function_catalog.md'), + ('riemannianGeometryApproximateManifoldChart', 'Riemannian Geometry', '(value, tolerance=1e-9)', 'Approximate a manifold chart with explicit tolerance controls.', 'professional_function_catalog.md'), + ('riemannianGeometryApproximateMetricTensor', 'Riemannian Geometry', '(value, tolerance=1e-9)', 'Approximate a metric tensor with explicit tolerance controls.', 'professional_function_catalog.md'), + ('riemannianGeometryCanonicalizeConnection', 'Riemannian Geometry', '(value)', 'Canonicalize a connection so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('riemannianGeometryCanonicalizeCurvatureTensor', 'Riemannian Geometry', '(value)', 'Canonicalize a curvature tensor so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('riemannianGeometryCanonicalizeGeodesic', 'Riemannian Geometry', '(value)', 'Canonicalize a geodesic so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('riemannianGeometryCanonicalizeManifoldChart', 'Riemannian Geometry', '(value)', 'Canonicalize a manifold chart so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('riemannianGeometryCanonicalizeMetricTensor', 'Riemannian Geometry', '(value)', 'Canonicalize a metric tensor so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('riemannianGeometryClassifyConnection', 'Riemannian Geometry', '(value)', 'Classify a connection by its standard Riemannian Geometry invariants.', 'professional_function_catalog.md'), + ('riemannianGeometryClassifyCurvatureTensor', 'Riemannian Geometry', '(value)', 'Classify a curvature tensor by its standard Riemannian Geometry invariants.', 'professional_function_catalog.md'), + ('riemannianGeometryClassifyGeodesic', 'Riemannian Geometry', '(value)', 'Classify a geodesic by its standard Riemannian Geometry invariants.', 'professional_function_catalog.md'), + ('riemannianGeometryClassifyManifoldChart', 'Riemannian Geometry', '(value)', 'Classify a manifold chart by its standard Riemannian Geometry invariants.', 'professional_function_catalog.md'), + ('riemannianGeometryClassifyMetricTensor', 'Riemannian Geometry', '(value)', 'Classify a metric tensor by its standard Riemannian Geometry invariants.', 'professional_function_catalog.md'), + ('riemannianGeometryCombineConnection', 'Riemannian Geometry', '(left, right)', 'Combine two connection values with the natural operation for Riemannian Geometry.', 'professional_function_catalog.md'), + ('riemannianGeometryCombineCurvatureTensor', 'Riemannian Geometry', '(left, right)', 'Combine two curvature tensor values with the natural operation for Riemannian Geometry.', 'professional_function_catalog.md'), + ('riemannianGeometryCombineGeodesic', 'Riemannian Geometry', '(left, right)', 'Combine two geodesic values with the natural operation for Riemannian Geometry.', 'professional_function_catalog.md'), + ('riemannianGeometryCombineManifoldChart', 'Riemannian Geometry', '(left, right)', 'Combine two manifold chart values with the natural operation for Riemannian Geometry.', 'professional_function_catalog.md'), + ('riemannianGeometryCombineMetricTensor', 'Riemannian Geometry', '(left, right)', 'Combine two metric tensor values with the natural operation for Riemannian Geometry.', 'professional_function_catalog.md'), + ('riemannianGeometryCompareConnection', 'Riemannian Geometry', '(left, right)', 'Compare two connection values under the conventions of Riemannian Geometry.', 'professional_function_catalog.md'), + ('riemannianGeometryCompareCurvatureTensor', 'Riemannian Geometry', '(left, right)', 'Compare two curvature tensor values under the conventions of Riemannian Geometry.', 'professional_function_catalog.md'), + ('riemannianGeometryCompareGeodesic', 'Riemannian Geometry', '(left, right)', 'Compare two geodesic values under the conventions of Riemannian Geometry.', 'professional_function_catalog.md'), + ('riemannianGeometryCompareManifoldChart', 'Riemannian Geometry', '(left, right)', 'Compare two manifold chart values under the conventions of Riemannian Geometry.', 'professional_function_catalog.md'), + ('riemannianGeometryCompareMetricTensor', 'Riemannian Geometry', '(left, right)', 'Compare two metric tensor values under the conventions of Riemannian Geometry.', 'professional_function_catalog.md'), + ('riemannianGeometryComputeConnection', 'Riemannian Geometry', '(value)', 'Compute the central numerical or symbolic data of a connection.', 'professional_function_catalog.md'), + ('riemannianGeometryComputeCurvatureTensor', 'Riemannian Geometry', '(value)', 'Compute the central numerical or symbolic data of a curvature tensor.', 'professional_function_catalog.md'), + ('riemannianGeometryComputeGeodesic', 'Riemannian Geometry', '(value)', 'Compute the central numerical or symbolic data of a geodesic.', 'professional_function_catalog.md'), + ('riemannianGeometryComputeManifoldChart', 'Riemannian Geometry', '(value)', 'Compute the central numerical or symbolic data of a manifold chart.', 'professional_function_catalog.md'), + ('riemannianGeometryComputeMetricTensor', 'Riemannian Geometry', '(value)', 'Compute the central numerical or symbolic data of a metric tensor.', 'professional_function_catalog.md'), + ('riemannianGeometryConstructConnection', 'Riemannian Geometry', '(*args)', 'Construct a connection from explicit inputs for Riemannian Geometry.', 'professional_function_catalog.md'), + ('riemannianGeometryConstructCurvatureTensor', 'Riemannian Geometry', '(*args)', 'Construct a curvature tensor from explicit inputs for Riemannian Geometry.', 'professional_function_catalog.md'), + ('riemannianGeometryConstructGeodesic', 'Riemannian Geometry', '(*args)', 'Construct a geodesic from explicit inputs for Riemannian Geometry.', 'professional_function_catalog.md'), + ('riemannianGeometryConstructManifoldChart', 'Riemannian Geometry', '(*args)', 'Construct a manifold chart from explicit inputs for Riemannian Geometry.', 'professional_function_catalog.md'), + ('riemannianGeometryConstructMetricTensor', 'Riemannian Geometry', '(*args)', 'Construct a metric tensor from explicit inputs for Riemannian Geometry.', 'professional_function_catalog.md'), + ('riemannianGeometryDecomposeConnection', 'Riemannian Geometry', '(value)', 'Decompose a connection into simpler or canonical components.', 'professional_function_catalog.md'), + ('riemannianGeometryDecomposeCurvatureTensor', 'Riemannian Geometry', '(value)', 'Decompose a curvature tensor into simpler or canonical components.', 'professional_function_catalog.md'), + ('riemannianGeometryDecomposeGeodesic', 'Riemannian Geometry', '(value)', 'Decompose a geodesic into simpler or canonical components.', 'professional_function_catalog.md'), + ('riemannianGeometryDecomposeManifoldChart', 'Riemannian Geometry', '(value)', 'Decompose a manifold chart into simpler or canonical components.', 'professional_function_catalog.md'), + ('riemannianGeometryDecomposeMetricTensor', 'Riemannian Geometry', '(value)', 'Decompose a metric tensor into simpler or canonical components.', 'professional_function_catalog.md'), + ('riemannianGeometryDocumentConnection', 'Riemannian Geometry', '(value)', 'Return a structured explanation of a connection and related assumptions.', 'professional_function_catalog.md'), + ('riemannianGeometryDocumentCurvatureTensor', 'Riemannian Geometry', '(value)', 'Return a structured explanation of a curvature tensor and related assumptions.', 'professional_function_catalog.md'), + ('riemannianGeometryDocumentGeodesic', 'Riemannian Geometry', '(value)', 'Return a structured explanation of a geodesic and related assumptions.', 'professional_function_catalog.md'), + ('riemannianGeometryDocumentManifoldChart', 'Riemannian Geometry', '(value)', 'Return a structured explanation of a manifold chart and related assumptions.', 'professional_function_catalog.md'), + ('riemannianGeometryDocumentMetricTensor', 'Riemannian Geometry', '(value)', 'Return a structured explanation of a metric tensor and related assumptions.', 'professional_function_catalog.md'), + ('riemannianGeometryEnumerateConnection', 'Riemannian Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a connection.', 'professional_function_catalog.md'), + ('riemannianGeometryEnumerateCurvatureTensor', 'Riemannian Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a curvature tensor.', 'professional_function_catalog.md'), + ('riemannianGeometryEnumerateGeodesic', 'Riemannian Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a geodesic.', 'professional_function_catalog.md'), + ('riemannianGeometryEnumerateManifoldChart', 'Riemannian Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a manifold chart.', 'professional_function_catalog.md'), + ('riemannianGeometryEnumerateMetricTensor', 'Riemannian Geometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a metric tensor.', 'professional_function_catalog.md'), + ('riemannianGeometryEstimateConnection', 'Riemannian Geometry', '(value, samples=None)', 'Estimate a connection property from finite samples or approximations.', 'professional_function_catalog.md'), + ('riemannianGeometryEstimateCurvatureTensor', 'Riemannian Geometry', '(value, samples=None)', 'Estimate a curvature tensor property from finite samples or approximations.', 'professional_function_catalog.md'), + ('riemannianGeometryEstimateGeodesic', 'Riemannian Geometry', '(value, samples=None)', 'Estimate a geodesic property from finite samples or approximations.', 'professional_function_catalog.md'), + ('riemannianGeometryEstimateManifoldChart', 'Riemannian Geometry', '(value, samples=None)', 'Estimate a manifold chart property from finite samples or approximations.', 'professional_function_catalog.md'), + ('riemannianGeometryEstimateMetricTensor', 'Riemannian Geometry', '(value, samples=None)', 'Estimate a metric tensor property from finite samples or approximations.', 'professional_function_catalog.md'), + ('riemannianGeometryEvaluateConnection', 'Riemannian Geometry', '(value, point=None)', 'Evaluate a connection at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('riemannianGeometryEvaluateCurvatureTensor', 'Riemannian Geometry', '(value, point=None)', 'Evaluate a curvature tensor at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('riemannianGeometryEvaluateGeodesic', 'Riemannian Geometry', '(value, point=None)', 'Evaluate a geodesic at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('riemannianGeometryEvaluateManifoldChart', 'Riemannian Geometry', '(value, point=None)', 'Evaluate a manifold chart at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('riemannianGeometryEvaluateMetricTensor', 'Riemannian Geometry', '(value, point=None)', 'Evaluate a metric tensor at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('riemannianGeometryFormatConnection', 'Riemannian Geometry', '(value)', 'Format a connection for deterministic user-facing output.', 'professional_function_catalog.md'), + ('riemannianGeometryFormatCurvatureTensor', 'Riemannian Geometry', '(value)', 'Format a curvature tensor for deterministic user-facing output.', 'professional_function_catalog.md'), + ('riemannianGeometryFormatGeodesic', 'Riemannian Geometry', '(value)', 'Format a geodesic for deterministic user-facing output.', 'professional_function_catalog.md'), + ('riemannianGeometryFormatManifoldChart', 'Riemannian Geometry', '(value)', 'Format a manifold chart for deterministic user-facing output.', 'professional_function_catalog.md'), + ('riemannianGeometryFormatMetricTensor', 'Riemannian Geometry', '(value)', 'Format a metric tensor for deterministic user-facing output.', 'professional_function_catalog.md'), + ('riemannianGeometryGenerateExampleConnection', 'Riemannian Geometry', '(size=3)', 'Generate a small documented example of a connection.', 'professional_function_catalog.md'), + ('riemannianGeometryGenerateExampleCurvatureTensor', 'Riemannian Geometry', '(size=3)', 'Generate a small documented example of a curvature tensor.', 'professional_function_catalog.md'), + ('riemannianGeometryGenerateExampleGeodesic', 'Riemannian Geometry', '(size=3)', 'Generate a small documented example of a geodesic.', 'professional_function_catalog.md'), + ('riemannianGeometryGenerateExampleManifoldChart', 'Riemannian Geometry', '(size=3)', 'Generate a small documented example of a manifold chart.', 'professional_function_catalog.md'), + ('riemannianGeometryGenerateExampleMetricTensor', 'Riemannian Geometry', '(size=3)', 'Generate a small documented example of a metric tensor.', 'professional_function_catalog.md'), + ('riemannianGeometryNormalizeConnection', 'Riemannian Geometry', '(value)', 'Normalize a connection into the standard Riemannian Geometry representation.', 'professional_function_catalog.md'), + ('riemannianGeometryNormalizeCurvatureTensor', 'Riemannian Geometry', '(value)', 'Normalize a curvature tensor into the standard Riemannian Geometry representation.', 'professional_function_catalog.md'), + ('riemannianGeometryNormalizeGeodesic', 'Riemannian Geometry', '(value)', 'Normalize a geodesic into the standard Riemannian Geometry representation.', 'professional_function_catalog.md'), + ('riemannianGeometryNormalizeManifoldChart', 'Riemannian Geometry', '(value)', 'Normalize a manifold chart into the standard Riemannian Geometry representation.', 'professional_function_catalog.md'), + ('riemannianGeometryNormalizeMetricTensor', 'Riemannian Geometry', '(value)', 'Normalize a metric tensor into the standard Riemannian Geometry representation.', 'professional_function_catalog.md'), + ('riemannianGeometryParseConnection', 'Riemannian Geometry', '(text)', 'Parse a text or structured value into a connection.', 'professional_function_catalog.md'), + ('riemannianGeometryParseCurvatureTensor', 'Riemannian Geometry', '(text)', 'Parse a text or structured value into a curvature tensor.', 'professional_function_catalog.md'), + ('riemannianGeometryParseGeodesic', 'Riemannian Geometry', '(text)', 'Parse a text or structured value into a geodesic.', 'professional_function_catalog.md'), + ('riemannianGeometryParseManifoldChart', 'Riemannian Geometry', '(text)', 'Parse a text or structured value into a manifold chart.', 'professional_function_catalog.md'), + ('riemannianGeometryParseMetricTensor', 'Riemannian Geometry', '(text)', 'Parse a text or structured value into a metric tensor.', 'professional_function_catalog.md'), + ('riemannianGeometrySimplifyConnection', 'Riemannian Geometry', '(value)', 'Simplify a connection without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('riemannianGeometrySimplifyCurvatureTensor', 'Riemannian Geometry', '(value)', 'Simplify a curvature tensor without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('riemannianGeometrySimplifyGeodesic', 'Riemannian Geometry', '(value)', 'Simplify a geodesic without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('riemannianGeometrySimplifyManifoldChart', 'Riemannian Geometry', '(value)', 'Simplify a manifold chart without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('riemannianGeometrySimplifyMetricTensor', 'Riemannian Geometry', '(value)', 'Simplify a metric tensor without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('riemannianGeometryTestEquivalenceConnection', 'Riemannian Geometry', '(left, right)', 'Test whether two connection values are equivalent in Riemannian Geometry.', 'professional_function_catalog.md'), + ('riemannianGeometryTestEquivalenceCurvatureTensor', 'Riemannian Geometry', '(left, right)', 'Test whether two curvature tensor values are equivalent in Riemannian Geometry.', 'professional_function_catalog.md'), + ('riemannianGeometryTestEquivalenceGeodesic', 'Riemannian Geometry', '(left, right)', 'Test whether two geodesic values are equivalent in Riemannian Geometry.', 'professional_function_catalog.md'), + ('riemannianGeometryTestEquivalenceManifoldChart', 'Riemannian Geometry', '(left, right)', 'Test whether two manifold chart values are equivalent in Riemannian Geometry.', 'professional_function_catalog.md'), + ('riemannianGeometryTestEquivalenceMetricTensor', 'Riemannian Geometry', '(left, right)', 'Test whether two metric tensor values are equivalent in Riemannian Geometry.', 'professional_function_catalog.md'), + ('riemannianGeometryTransformConnection', 'Riemannian Geometry', '(value, mapping)', 'Transform a connection through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('riemannianGeometryTransformCurvatureTensor', 'Riemannian Geometry', '(value, mapping)', 'Transform a curvature tensor through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('riemannianGeometryTransformGeodesic', 'Riemannian Geometry', '(value, mapping)', 'Transform a geodesic through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('riemannianGeometryTransformManifoldChart', 'Riemannian Geometry', '(value, mapping)', 'Transform a manifold chart through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('riemannianGeometryTransformMetricTensor', 'Riemannian Geometry', '(value, mapping)', 'Transform a metric tensor through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('riemannianGeometryValidateConnection', 'Riemannian Geometry', '(value)', 'Validate the connection representation and domain rules for Riemannian Geometry.', 'professional_function_catalog.md'), + ('riemannianGeometryValidateCurvatureTensor', 'Riemannian Geometry', '(value)', 'Validate the curvature tensor representation and domain rules for Riemannian Geometry.', 'professional_function_catalog.md'), + ('riemannianGeometryValidateGeodesic', 'Riemannian Geometry', '(value)', 'Validate the geodesic representation and domain rules for Riemannian Geometry.', 'professional_function_catalog.md'), + ('riemannianGeometryValidateManifoldChart', 'Riemannian Geometry', '(value)', 'Validate the manifold chart representation and domain rules for Riemannian Geometry.', 'professional_function_catalog.md'), + ('riemannianGeometryValidateMetricTensor', 'Riemannian Geometry', '(value)', 'Validate the metric tensor representation and domain rules for Riemannian Geometry.', 'professional_function_catalog.md'), + ('scalarCurvature', 'Riemannian Geometry', '(metricFunctions, point)', 'Planned roadmap function for Riemannian Geometry from upcoming.md.', 'upcoming.md'), + ('sectionalCurvature', 'Riemannian Geometry', '(metricFunctions, point, plane)', 'Planned roadmap function for Riemannian Geometry from upcoming.md.', 'upcoming.md'), + ('bernsteinBasis', 'Splines and Computer-Aided Geometric Design', '(n, i, t)', 'Planned roadmap function for Splines and Computer-Aided Geometric Design from upcoming.md.', 'upcoming.md'), + ('bezierDerivative', 'Splines and Computer-Aided Geometric Design', '(controlPoints, t)', 'Planned roadmap function for Splines and Computer-Aided Geometric Design from upcoming.md.', 'upcoming.md'), + ('bezierPoint', 'Splines and Computer-Aided Geometric Design', '(controlPoints, t)', 'Planned roadmap function for Splines and Computer-Aided Geometric Design from upcoming.md.', 'upcoming.md'), + ('bsplineBasis', 'Splines and Computer-Aided Geometric Design', '(i, degree, knots, t)', 'Planned roadmap function for Splines and Computer-Aided Geometric Design from upcoming.md.', 'upcoming.md'), + ('bsplinePoint', 'Splines and Computer-Aided Geometric Design', '(controlPoints, degree, knots, t)', 'Planned roadmap function for Splines and Computer-Aided Geometric Design from upcoming.md.', 'upcoming.md'), + ('catmullRomPoint', 'Splines and Computer-Aided Geometric Design', '(points, t)', 'Planned roadmap function for Splines and Computer-Aided Geometric Design from upcoming.md.', 'upcoming.md'), + ('curveSubdivision', 'Splines and Computer-Aided Geometric Design', '(controlPoints)', 'Planned roadmap function for Splines and Computer-Aided Geometric Design from upcoming.md.', 'upcoming.md'), + ('deCasteljau', 'Splines and Computer-Aided Geometric Design', '(controlPoints, t)', 'Planned roadmap function for Splines and Computer-Aided Geometric Design from upcoming.md.', 'upcoming.md'), + ('splinesAndComputerAidedGeometricDesignApproximateBezierCurve', 'Splines and Computer-Aided Geometric Design', '(value, tolerance=1e-9)', 'Approximate a Bezier curve with explicit tolerance controls.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignApproximateControlPoint', 'Splines and Computer-Aided Geometric Design', '(value, tolerance=1e-9)', 'Approximate a control point with explicit tolerance controls.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignApproximateKnotVector', 'Splines and Computer-Aided Geometric Design', '(value, tolerance=1e-9)', 'Approximate a knot vector with explicit tolerance controls.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignApproximateSplineBasis', 'Splines and Computer-Aided Geometric Design', '(value, tolerance=1e-9)', 'Approximate a spline basis with explicit tolerance controls.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignApproximateSubdivisionCurve', 'Splines and Computer-Aided Geometric Design', '(value, tolerance=1e-9)', 'Approximate a subdivision curve with explicit tolerance controls.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignCanonicalizeBezierCurve', 'Splines and Computer-Aided Geometric Design', '(value)', 'Canonicalize a Bezier curve so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignCanonicalizeControlPoint', 'Splines and Computer-Aided Geometric Design', '(value)', 'Canonicalize a control point so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignCanonicalizeKnotVector', 'Splines and Computer-Aided Geometric Design', '(value)', 'Canonicalize a knot vector so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignCanonicalizeSplineBasis', 'Splines and Computer-Aided Geometric Design', '(value)', 'Canonicalize a spline basis so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignCanonicalizeSubdivisionCurve', 'Splines and Computer-Aided Geometric Design', '(value)', 'Canonicalize a subdivision curve so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignClassifyBezierCurve', 'Splines and Computer-Aided Geometric Design', '(value)', 'Classify a Bezier curve by its standard Splines and Computer-Aided Geometric Design invariants.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignClassifyControlPoint', 'Splines and Computer-Aided Geometric Design', '(value)', 'Classify a control point by its standard Splines and Computer-Aided Geometric Design invariants.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignClassifyKnotVector', 'Splines and Computer-Aided Geometric Design', '(value)', 'Classify a knot vector by its standard Splines and Computer-Aided Geometric Design invariants.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignClassifySplineBasis', 'Splines and Computer-Aided Geometric Design', '(value)', 'Classify a spline basis by its standard Splines and Computer-Aided Geometric Design invariants.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignClassifySubdivisionCurve', 'Splines and Computer-Aided Geometric Design', '(value)', 'Classify a subdivision curve by its standard Splines and Computer-Aided Geometric Design invariants.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignCombineBezierCurve', 'Splines and Computer-Aided Geometric Design', '(left, right)', 'Combine two Bezier curve values with the natural operation for Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignCombineControlPoint', 'Splines and Computer-Aided Geometric Design', '(left, right)', 'Combine two control point values with the natural operation for Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignCombineKnotVector', 'Splines and Computer-Aided Geometric Design', '(left, right)', 'Combine two knot vector values with the natural operation for Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignCombineSplineBasis', 'Splines and Computer-Aided Geometric Design', '(left, right)', 'Combine two spline basis values with the natural operation for Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignCombineSubdivisionCurve', 'Splines and Computer-Aided Geometric Design', '(left, right)', 'Combine two subdivision curve values with the natural operation for Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignCompareBezierCurve', 'Splines and Computer-Aided Geometric Design', '(left, right)', 'Compare two Bezier curve values under the conventions of Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignCompareControlPoint', 'Splines and Computer-Aided Geometric Design', '(left, right)', 'Compare two control point values under the conventions of Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignCompareKnotVector', 'Splines and Computer-Aided Geometric Design', '(left, right)', 'Compare two knot vector values under the conventions of Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignCompareSplineBasis', 'Splines and Computer-Aided Geometric Design', '(left, right)', 'Compare two spline basis values under the conventions of Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignCompareSubdivisionCurve', 'Splines and Computer-Aided Geometric Design', '(left, right)', 'Compare two subdivision curve values under the conventions of Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignComputeBezierCurve', 'Splines and Computer-Aided Geometric Design', '(value)', 'Compute the central numerical or symbolic data of a Bezier curve.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignComputeControlPoint', 'Splines and Computer-Aided Geometric Design', '(value)', 'Compute the central numerical or symbolic data of a control point.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignComputeKnotVector', 'Splines and Computer-Aided Geometric Design', '(value)', 'Compute the central numerical or symbolic data of a knot vector.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignComputeSplineBasis', 'Splines and Computer-Aided Geometric Design', '(value)', 'Compute the central numerical or symbolic data of a spline basis.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignComputeSubdivisionCurve', 'Splines and Computer-Aided Geometric Design', '(value)', 'Compute the central numerical or symbolic data of a subdivision curve.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignConstructBezierCurve', 'Splines and Computer-Aided Geometric Design', '(*args)', 'Construct a Bezier curve from explicit inputs for Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignConstructControlPoint', 'Splines and Computer-Aided Geometric Design', '(*args)', 'Construct a control point from explicit inputs for Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignConstructKnotVector', 'Splines and Computer-Aided Geometric Design', '(*args)', 'Construct a knot vector from explicit inputs for Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignConstructSplineBasis', 'Splines and Computer-Aided Geometric Design', '(*args)', 'Construct a spline basis from explicit inputs for Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignConstructSubdivisionCurve', 'Splines and Computer-Aided Geometric Design', '(*args)', 'Construct a subdivision curve from explicit inputs for Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignDecomposeBezierCurve', 'Splines and Computer-Aided Geometric Design', '(value)', 'Decompose a Bezier curve into simpler or canonical components.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignDecomposeControlPoint', 'Splines and Computer-Aided Geometric Design', '(value)', 'Decompose a control point into simpler or canonical components.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignDecomposeKnotVector', 'Splines and Computer-Aided Geometric Design', '(value)', 'Decompose a knot vector into simpler or canonical components.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignDecomposeSplineBasis', 'Splines and Computer-Aided Geometric Design', '(value)', 'Decompose a spline basis into simpler or canonical components.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignDecomposeSubdivisionCurve', 'Splines and Computer-Aided Geometric Design', '(value)', 'Decompose a subdivision curve into simpler or canonical components.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignDocumentBezierCurve', 'Splines and Computer-Aided Geometric Design', '(value)', 'Return a structured explanation of a Bezier curve and related assumptions.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignDocumentControlPoint', 'Splines and Computer-Aided Geometric Design', '(value)', 'Return a structured explanation of a control point and related assumptions.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignDocumentKnotVector', 'Splines and Computer-Aided Geometric Design', '(value)', 'Return a structured explanation of a knot vector and related assumptions.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignDocumentSplineBasis', 'Splines and Computer-Aided Geometric Design', '(value)', 'Return a structured explanation of a spline basis and related assumptions.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignDocumentSubdivisionCurve', 'Splines and Computer-Aided Geometric Design', '(value)', 'Return a structured explanation of a subdivision curve and related assumptions.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignEnumerateBezierCurve', 'Splines and Computer-Aided Geometric Design', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a Bezier curve.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignEnumerateControlPoint', 'Splines and Computer-Aided Geometric Design', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a control point.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignEnumerateKnotVector', 'Splines and Computer-Aided Geometric Design', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a knot vector.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignEnumerateSplineBasis', 'Splines and Computer-Aided Geometric Design', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a spline basis.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignEnumerateSubdivisionCurve', 'Splines and Computer-Aided Geometric Design', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a subdivision curve.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignEstimateBezierCurve', 'Splines and Computer-Aided Geometric Design', '(value, samples=None)', 'Estimate a Bezier curve property from finite samples or approximations.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignEstimateControlPoint', 'Splines and Computer-Aided Geometric Design', '(value, samples=None)', 'Estimate a control point property from finite samples or approximations.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignEstimateKnotVector', 'Splines and Computer-Aided Geometric Design', '(value, samples=None)', 'Estimate a knot vector property from finite samples or approximations.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignEstimateSplineBasis', 'Splines and Computer-Aided Geometric Design', '(value, samples=None)', 'Estimate a spline basis property from finite samples or approximations.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignEstimateSubdivisionCurve', 'Splines and Computer-Aided Geometric Design', '(value, samples=None)', 'Estimate a subdivision curve property from finite samples or approximations.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignEvaluateBezierCurve', 'Splines and Computer-Aided Geometric Design', '(value, point=None)', 'Evaluate a Bezier curve at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignEvaluateControlPoint', 'Splines and Computer-Aided Geometric Design', '(value, point=None)', 'Evaluate a control point at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignEvaluateKnotVector', 'Splines and Computer-Aided Geometric Design', '(value, point=None)', 'Evaluate a knot vector at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignEvaluateSplineBasis', 'Splines and Computer-Aided Geometric Design', '(value, point=None)', 'Evaluate a spline basis at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignEvaluateSubdivisionCurve', 'Splines and Computer-Aided Geometric Design', '(value, point=None)', 'Evaluate a subdivision curve at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignFormatBezierCurve', 'Splines and Computer-Aided Geometric Design', '(value)', 'Format a Bezier curve for deterministic user-facing output.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignFormatControlPoint', 'Splines and Computer-Aided Geometric Design', '(value)', 'Format a control point for deterministic user-facing output.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignFormatKnotVector', 'Splines and Computer-Aided Geometric Design', '(value)', 'Format a knot vector for deterministic user-facing output.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignFormatSplineBasis', 'Splines and Computer-Aided Geometric Design', '(value)', 'Format a spline basis for deterministic user-facing output.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignFormatSubdivisionCurve', 'Splines and Computer-Aided Geometric Design', '(value)', 'Format a subdivision curve for deterministic user-facing output.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignGenerateExampleBezierCurve', 'Splines and Computer-Aided Geometric Design', '(size=3)', 'Generate a small documented example of a Bezier curve.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignGenerateExampleControlPoint', 'Splines and Computer-Aided Geometric Design', '(size=3)', 'Generate a small documented example of a control point.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignGenerateExampleKnotVector', 'Splines and Computer-Aided Geometric Design', '(size=3)', 'Generate a small documented example of a knot vector.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignGenerateExampleSplineBasis', 'Splines and Computer-Aided Geometric Design', '(size=3)', 'Generate a small documented example of a spline basis.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignGenerateExampleSubdivisionCurve', 'Splines and Computer-Aided Geometric Design', '(size=3)', 'Generate a small documented example of a subdivision curve.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignNormalizeBezierCurve', 'Splines and Computer-Aided Geometric Design', '(value)', 'Normalize a Bezier curve into the standard Splines and Computer-Aided Geometric Design representation.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignNormalizeControlPoint', 'Splines and Computer-Aided Geometric Design', '(value)', 'Normalize a control point into the standard Splines and Computer-Aided Geometric Design representation.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignNormalizeKnotVector', 'Splines and Computer-Aided Geometric Design', '(value)', 'Normalize a knot vector into the standard Splines and Computer-Aided Geometric Design representation.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignNormalizeSplineBasis', 'Splines and Computer-Aided Geometric Design', '(value)', 'Normalize a spline basis into the standard Splines and Computer-Aided Geometric Design representation.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignNormalizeSubdivisionCurve', 'Splines and Computer-Aided Geometric Design', '(value)', 'Normalize a subdivision curve into the standard Splines and Computer-Aided Geometric Design representation.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignParseBezierCurve', 'Splines and Computer-Aided Geometric Design', '(text)', 'Parse a text or structured value into a Bezier curve.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignParseControlPoint', 'Splines and Computer-Aided Geometric Design', '(text)', 'Parse a text or structured value into a control point.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignParseKnotVector', 'Splines and Computer-Aided Geometric Design', '(text)', 'Parse a text or structured value into a knot vector.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignParseSplineBasis', 'Splines and Computer-Aided Geometric Design', '(text)', 'Parse a text or structured value into a spline basis.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignParseSubdivisionCurve', 'Splines and Computer-Aided Geometric Design', '(text)', 'Parse a text or structured value into a subdivision curve.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignSimplifyBezierCurve', 'Splines and Computer-Aided Geometric Design', '(value)', 'Simplify a Bezier curve without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignSimplifyControlPoint', 'Splines and Computer-Aided Geometric Design', '(value)', 'Simplify a control point without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignSimplifyKnotVector', 'Splines and Computer-Aided Geometric Design', '(value)', 'Simplify a knot vector without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignSimplifySplineBasis', 'Splines and Computer-Aided Geometric Design', '(value)', 'Simplify a spline basis without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignSimplifySubdivisionCurve', 'Splines and Computer-Aided Geometric Design', '(value)', 'Simplify a subdivision curve without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignTestEquivalenceBezierCurve', 'Splines and Computer-Aided Geometric Design', '(left, right)', 'Test whether two Bezier curve values are equivalent in Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignTestEquivalenceControlPoint', 'Splines and Computer-Aided Geometric Design', '(left, right)', 'Test whether two control point values are equivalent in Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignTestEquivalenceKnotVector', 'Splines and Computer-Aided Geometric Design', '(left, right)', 'Test whether two knot vector values are equivalent in Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignTestEquivalenceSplineBasis', 'Splines and Computer-Aided Geometric Design', '(left, right)', 'Test whether two spline basis values are equivalent in Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignTestEquivalenceSubdivisionCurve', 'Splines and Computer-Aided Geometric Design', '(left, right)', 'Test whether two subdivision curve values are equivalent in Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignTransformBezierCurve', 'Splines and Computer-Aided Geometric Design', '(value, mapping)', 'Transform a Bezier curve through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignTransformControlPoint', 'Splines and Computer-Aided Geometric Design', '(value, mapping)', 'Transform a control point through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignTransformKnotVector', 'Splines and Computer-Aided Geometric Design', '(value, mapping)', 'Transform a knot vector through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignTransformSplineBasis', 'Splines and Computer-Aided Geometric Design', '(value, mapping)', 'Transform a spline basis through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignTransformSubdivisionCurve', 'Splines and Computer-Aided Geometric Design', '(value, mapping)', 'Transform a subdivision curve through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignValidateBezierCurve', 'Splines and Computer-Aided Geometric Design', '(value)', 'Validate the Bezier curve representation and domain rules for Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignValidateControlPoint', 'Splines and Computer-Aided Geometric Design', '(value)', 'Validate the control point representation and domain rules for Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignValidateKnotVector', 'Splines and Computer-Aided Geometric Design', '(value)', 'Validate the knot vector representation and domain rules for Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignValidateSplineBasis', 'Splines and Computer-Aided Geometric Design', '(value)', 'Validate the spline basis representation and domain rules for Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('splinesAndComputerAidedGeometricDesignValidateSubdivisionCurve', 'Splines and Computer-Aided Geometric Design', '(value)', 'Validate the subdivision curve representation and domain rules for Splines and Computer-Aided Geometric Design.', 'professional_function_catalog.md'), + ('bias', 'Statistical Inference', '(estimates, actual)', 'Planned roadmap function for Statistical Inference from upcoming.md.', 'upcoming.md'), + ('bootstrapMeans', 'Statistical Inference', '(values, resamples)', 'Planned roadmap function for Statistical Inference from upcoming.md.', 'upcoming.md'), + ('chiSquareStatistic', 'Statistical Inference', '(observed, expected)', 'Planned roadmap function for Statistical Inference from upcoming.md.', 'upcoming.md'), + ('confidenceIntervalMean', 'Statistical Inference', '(values, confidence=0.95)', 'Planned roadmap function for Statistical Inference from upcoming.md.', 'upcoming.md'), + ('meanSquaredError', 'Statistical Inference', '(estimates, actual)', 'Planned roadmap function for Statistical Inference from upcoming.md.', 'upcoming.md'), + ('proportionConfidenceInterval', 'Statistical Inference', '(successes, trials, confidence=0.95)', 'Planned roadmap function for Statistical Inference from upcoming.md.', 'upcoming.md'), + ('statisticalInferenceApproximateConfidenceInterval', 'Statistical Inference', '(value, tolerance=1e-9)', 'Approximate a confidence interval with explicit tolerance controls.', 'professional_function_catalog.md'), + ('statisticalInferenceApproximateEstimator', 'Statistical Inference', '(value, tolerance=1e-9)', 'Approximate a estimator with explicit tolerance controls.', 'professional_function_catalog.md'), + ('statisticalInferenceApproximateHypothesisTest', 'Statistical Inference', '(value, tolerance=1e-9)', 'Approximate a hypothesis test with explicit tolerance controls.', 'professional_function_catalog.md'), + ('statisticalInferenceApproximateSamplingDistribution', 'Statistical Inference', '(value, tolerance=1e-9)', 'Approximate a sampling distribution with explicit tolerance controls.', 'professional_function_catalog.md'), + ('statisticalInferenceApproximateTestStatistic', 'Statistical Inference', '(value, tolerance=1e-9)', 'Approximate a test statistic with explicit tolerance controls.', 'professional_function_catalog.md'), + ('statisticalInferenceCanonicalizeConfidenceInterval', 'Statistical Inference', '(value)', 'Canonicalize a confidence interval so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('statisticalInferenceCanonicalizeEstimator', 'Statistical Inference', '(value)', 'Canonicalize a estimator so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('statisticalInferenceCanonicalizeHypothesisTest', 'Statistical Inference', '(value)', 'Canonicalize a hypothesis test so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('statisticalInferenceCanonicalizeSamplingDistribution', 'Statistical Inference', '(value)', 'Canonicalize a sampling distribution so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('statisticalInferenceCanonicalizeTestStatistic', 'Statistical Inference', '(value)', 'Canonicalize a test statistic so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('statisticalInferenceClassifyConfidenceInterval', 'Statistical Inference', '(value)', 'Classify a confidence interval by its standard Statistical Inference invariants.', 'professional_function_catalog.md'), + ('statisticalInferenceClassifyEstimator', 'Statistical Inference', '(value)', 'Classify a estimator by its standard Statistical Inference invariants.', 'professional_function_catalog.md'), + ('statisticalInferenceClassifyHypothesisTest', 'Statistical Inference', '(value)', 'Classify a hypothesis test by its standard Statistical Inference invariants.', 'professional_function_catalog.md'), + ('statisticalInferenceClassifySamplingDistribution', 'Statistical Inference', '(value)', 'Classify a sampling distribution by its standard Statistical Inference invariants.', 'professional_function_catalog.md'), + ('statisticalInferenceClassifyTestStatistic', 'Statistical Inference', '(value)', 'Classify a test statistic by its standard Statistical Inference invariants.', 'professional_function_catalog.md'), + ('statisticalInferenceCombineConfidenceInterval', 'Statistical Inference', '(left, right)', 'Combine two confidence interval values with the natural operation for Statistical Inference.', 'professional_function_catalog.md'), + ('statisticalInferenceCombineEstimator', 'Statistical Inference', '(left, right)', 'Combine two estimator values with the natural operation for Statistical Inference.', 'professional_function_catalog.md'), + ('statisticalInferenceCombineHypothesisTest', 'Statistical Inference', '(left, right)', 'Combine two hypothesis test values with the natural operation for Statistical Inference.', 'professional_function_catalog.md'), + ('statisticalInferenceCombineSamplingDistribution', 'Statistical Inference', '(left, right)', 'Combine two sampling distribution values with the natural operation for Statistical Inference.', 'professional_function_catalog.md'), + ('statisticalInferenceCombineTestStatistic', 'Statistical Inference', '(left, right)', 'Combine two test statistic values with the natural operation for Statistical Inference.', 'professional_function_catalog.md'), + ('statisticalInferenceCompareConfidenceInterval', 'Statistical Inference', '(left, right)', 'Compare two confidence interval values under the conventions of Statistical Inference.', 'professional_function_catalog.md'), + ('statisticalInferenceCompareEstimator', 'Statistical Inference', '(left, right)', 'Compare two estimator values under the conventions of Statistical Inference.', 'professional_function_catalog.md'), + ('statisticalInferenceCompareHypothesisTest', 'Statistical Inference', '(left, right)', 'Compare two hypothesis test values under the conventions of Statistical Inference.', 'professional_function_catalog.md'), + ('statisticalInferenceCompareSamplingDistribution', 'Statistical Inference', '(left, right)', 'Compare two sampling distribution values under the conventions of Statistical Inference.', 'professional_function_catalog.md'), + ('statisticalInferenceCompareTestStatistic', 'Statistical Inference', '(left, right)', 'Compare two test statistic values under the conventions of Statistical Inference.', 'professional_function_catalog.md'), + ('statisticalInferenceComputeConfidenceInterval', 'Statistical Inference', '(value)', 'Compute the central numerical or symbolic data of a confidence interval.', 'professional_function_catalog.md'), + ('statisticalInferenceComputeEstimator', 'Statistical Inference', '(value)', 'Compute the central numerical or symbolic data of a estimator.', 'professional_function_catalog.md'), + ('statisticalInferenceComputeHypothesisTest', 'Statistical Inference', '(value)', 'Compute the central numerical or symbolic data of a hypothesis test.', 'professional_function_catalog.md'), + ('statisticalInferenceComputeSamplingDistribution', 'Statistical Inference', '(value)', 'Compute the central numerical or symbolic data of a sampling distribution.', 'professional_function_catalog.md'), + ('statisticalInferenceComputeTestStatistic', 'Statistical Inference', '(value)', 'Compute the central numerical or symbolic data of a test statistic.', 'professional_function_catalog.md'), + ('statisticalInferenceConstructConfidenceInterval', 'Statistical Inference', '(*args)', 'Construct a confidence interval from explicit inputs for Statistical Inference.', 'professional_function_catalog.md'), + ('statisticalInferenceConstructEstimator', 'Statistical Inference', '(*args)', 'Construct a estimator from explicit inputs for Statistical Inference.', 'professional_function_catalog.md'), + ('statisticalInferenceConstructHypothesisTest', 'Statistical Inference', '(*args)', 'Construct a hypothesis test from explicit inputs for Statistical Inference.', 'professional_function_catalog.md'), + ('statisticalInferenceConstructSamplingDistribution', 'Statistical Inference', '(*args)', 'Construct a sampling distribution from explicit inputs for Statistical Inference.', 'professional_function_catalog.md'), + ('statisticalInferenceConstructTestStatistic', 'Statistical Inference', '(*args)', 'Construct a test statistic from explicit inputs for Statistical Inference.', 'professional_function_catalog.md'), + ('statisticalInferenceDecomposeConfidenceInterval', 'Statistical Inference', '(value)', 'Decompose a confidence interval into simpler or canonical components.', 'professional_function_catalog.md'), + ('statisticalInferenceDecomposeEstimator', 'Statistical Inference', '(value)', 'Decompose a estimator into simpler or canonical components.', 'professional_function_catalog.md'), + ('statisticalInferenceDecomposeHypothesisTest', 'Statistical Inference', '(value)', 'Decompose a hypothesis test into simpler or canonical components.', 'professional_function_catalog.md'), + ('statisticalInferenceDecomposeSamplingDistribution', 'Statistical Inference', '(value)', 'Decompose a sampling distribution into simpler or canonical components.', 'professional_function_catalog.md'), + ('statisticalInferenceDecomposeTestStatistic', 'Statistical Inference', '(value)', 'Decompose a test statistic into simpler or canonical components.', 'professional_function_catalog.md'), + ('statisticalInferenceDocumentConfidenceInterval', 'Statistical Inference', '(value)', 'Return a structured explanation of a confidence interval and related assumptions.', 'professional_function_catalog.md'), + ('statisticalInferenceDocumentEstimator', 'Statistical Inference', '(value)', 'Return a structured explanation of a estimator and related assumptions.', 'professional_function_catalog.md'), + ('statisticalInferenceDocumentHypothesisTest', 'Statistical Inference', '(value)', 'Return a structured explanation of a hypothesis test and related assumptions.', 'professional_function_catalog.md'), + ('statisticalInferenceDocumentSamplingDistribution', 'Statistical Inference', '(value)', 'Return a structured explanation of a sampling distribution and related assumptions.', 'professional_function_catalog.md'), + ('statisticalInferenceDocumentTestStatistic', 'Statistical Inference', '(value)', 'Return a structured explanation of a test statistic and related assumptions.', 'professional_function_catalog.md'), + ('statisticalInferenceEnumerateConfidenceInterval', 'Statistical Inference', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a confidence interval.', 'professional_function_catalog.md'), + ('statisticalInferenceEnumerateEstimator', 'Statistical Inference', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a estimator.', 'professional_function_catalog.md'), + ('statisticalInferenceEnumerateHypothesisTest', 'Statistical Inference', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a hypothesis test.', 'professional_function_catalog.md'), + ('statisticalInferenceEnumerateSamplingDistribution', 'Statistical Inference', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a sampling distribution.', 'professional_function_catalog.md'), + ('statisticalInferenceEnumerateTestStatistic', 'Statistical Inference', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a test statistic.', 'professional_function_catalog.md'), + ('statisticalInferenceEstimateConfidenceInterval', 'Statistical Inference', '(value, samples=None)', 'Estimate a confidence interval property from finite samples or approximations.', 'professional_function_catalog.md'), + ('statisticalInferenceEstimateEstimator', 'Statistical Inference', '(value, samples=None)', 'Estimate a estimator property from finite samples or approximations.', 'professional_function_catalog.md'), + ('statisticalInferenceEstimateHypothesisTest', 'Statistical Inference', '(value, samples=None)', 'Estimate a hypothesis test property from finite samples or approximations.', 'professional_function_catalog.md'), + ('statisticalInferenceEstimateSamplingDistribution', 'Statistical Inference', '(value, samples=None)', 'Estimate a sampling distribution property from finite samples or approximations.', 'professional_function_catalog.md'), + ('statisticalInferenceEstimateTestStatistic', 'Statistical Inference', '(value, samples=None)', 'Estimate a test statistic property from finite samples or approximations.', 'professional_function_catalog.md'), + ('statisticalInferenceEvaluateConfidenceInterval', 'Statistical Inference', '(value, point=None)', 'Evaluate a confidence interval at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('statisticalInferenceEvaluateEstimator', 'Statistical Inference', '(value, point=None)', 'Evaluate a estimator at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('statisticalInferenceEvaluateHypothesisTest', 'Statistical Inference', '(value, point=None)', 'Evaluate a hypothesis test at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('statisticalInferenceEvaluateSamplingDistribution', 'Statistical Inference', '(value, point=None)', 'Evaluate a sampling distribution at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('statisticalInferenceEvaluateTestStatistic', 'Statistical Inference', '(value, point=None)', 'Evaluate a test statistic at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('statisticalInferenceFormatConfidenceInterval', 'Statistical Inference', '(value)', 'Format a confidence interval for deterministic user-facing output.', 'professional_function_catalog.md'), + ('statisticalInferenceFormatEstimator', 'Statistical Inference', '(value)', 'Format a estimator for deterministic user-facing output.', 'professional_function_catalog.md'), + ('statisticalInferenceFormatHypothesisTest', 'Statistical Inference', '(value)', 'Format a hypothesis test for deterministic user-facing output.', 'professional_function_catalog.md'), + ('statisticalInferenceFormatSamplingDistribution', 'Statistical Inference', '(value)', 'Format a sampling distribution for deterministic user-facing output.', 'professional_function_catalog.md'), + ('statisticalInferenceFormatTestStatistic', 'Statistical Inference', '(value)', 'Format a test statistic for deterministic user-facing output.', 'professional_function_catalog.md'), + ('statisticalInferenceGenerateExampleConfidenceInterval', 'Statistical Inference', '(size=3)', 'Generate a small documented example of a confidence interval.', 'professional_function_catalog.md'), + ('statisticalInferenceGenerateExampleEstimator', 'Statistical Inference', '(size=3)', 'Generate a small documented example of a estimator.', 'professional_function_catalog.md'), + ('statisticalInferenceGenerateExampleHypothesisTest', 'Statistical Inference', '(size=3)', 'Generate a small documented example of a hypothesis test.', 'professional_function_catalog.md'), + ('statisticalInferenceGenerateExampleSamplingDistribution', 'Statistical Inference', '(size=3)', 'Generate a small documented example of a sampling distribution.', 'professional_function_catalog.md'), + ('statisticalInferenceGenerateExampleTestStatistic', 'Statistical Inference', '(size=3)', 'Generate a small documented example of a test statistic.', 'professional_function_catalog.md'), + ('statisticalInferenceNormalizeConfidenceInterval', 'Statistical Inference', '(value)', 'Normalize a confidence interval into the standard Statistical Inference representation.', 'professional_function_catalog.md'), + ('statisticalInferenceNormalizeEstimator', 'Statistical Inference', '(value)', 'Normalize a estimator into the standard Statistical Inference representation.', 'professional_function_catalog.md'), + ('statisticalInferenceNormalizeHypothesisTest', 'Statistical Inference', '(value)', 'Normalize a hypothesis test into the standard Statistical Inference representation.', 'professional_function_catalog.md'), + ('statisticalInferenceNormalizeSamplingDistribution', 'Statistical Inference', '(value)', 'Normalize a sampling distribution into the standard Statistical Inference representation.', 'professional_function_catalog.md'), + ('statisticalInferenceNormalizeTestStatistic', 'Statistical Inference', '(value)', 'Normalize a test statistic into the standard Statistical Inference representation.', 'professional_function_catalog.md'), + ('statisticalInferenceParseConfidenceInterval', 'Statistical Inference', '(text)', 'Parse a text or structured value into a confidence interval.', 'professional_function_catalog.md'), + ('statisticalInferenceParseEstimator', 'Statistical Inference', '(text)', 'Parse a text or structured value into a estimator.', 'professional_function_catalog.md'), + ('statisticalInferenceParseHypothesisTest', 'Statistical Inference', '(text)', 'Parse a text or structured value into a hypothesis test.', 'professional_function_catalog.md'), + ('statisticalInferenceParseSamplingDistribution', 'Statistical Inference', '(text)', 'Parse a text or structured value into a sampling distribution.', 'professional_function_catalog.md'), + ('statisticalInferenceParseTestStatistic', 'Statistical Inference', '(text)', 'Parse a text or structured value into a test statistic.', 'professional_function_catalog.md'), + ('statisticalInferenceSimplifyConfidenceInterval', 'Statistical Inference', '(value)', 'Simplify a confidence interval without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('statisticalInferenceSimplifyEstimator', 'Statistical Inference', '(value)', 'Simplify a estimator without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('statisticalInferenceSimplifyHypothesisTest', 'Statistical Inference', '(value)', 'Simplify a hypothesis test without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('statisticalInferenceSimplifySamplingDistribution', 'Statistical Inference', '(value)', 'Simplify a sampling distribution without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('statisticalInferenceSimplifyTestStatistic', 'Statistical Inference', '(value)', 'Simplify a test statistic without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('statisticalInferenceTestEquivalenceConfidenceInterval', 'Statistical Inference', '(left, right)', 'Test whether two confidence interval values are equivalent in Statistical Inference.', 'professional_function_catalog.md'), + ('statisticalInferenceTestEquivalenceEstimator', 'Statistical Inference', '(left, right)', 'Test whether two estimator values are equivalent in Statistical Inference.', 'professional_function_catalog.md'), + ('statisticalInferenceTestEquivalenceHypothesisTest', 'Statistical Inference', '(left, right)', 'Test whether two hypothesis test values are equivalent in Statistical Inference.', 'professional_function_catalog.md'), + ('statisticalInferenceTestEquivalenceSamplingDistribution', 'Statistical Inference', '(left, right)', 'Test whether two sampling distribution values are equivalent in Statistical Inference.', 'professional_function_catalog.md'), + ('statisticalInferenceTestEquivalenceTestStatistic', 'Statistical Inference', '(left, right)', 'Test whether two test statistic values are equivalent in Statistical Inference.', 'professional_function_catalog.md'), + ('statisticalInferenceTransformConfidenceInterval', 'Statistical Inference', '(value, mapping)', 'Transform a confidence interval through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('statisticalInferenceTransformEstimator', 'Statistical Inference', '(value, mapping)', 'Transform a estimator through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('statisticalInferenceTransformHypothesisTest', 'Statistical Inference', '(value, mapping)', 'Transform a hypothesis test through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('statisticalInferenceTransformSamplingDistribution', 'Statistical Inference', '(value, mapping)', 'Transform a sampling distribution through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('statisticalInferenceTransformTestStatistic', 'Statistical Inference', '(value, mapping)', 'Transform a test statistic through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('statisticalInferenceValidateConfidenceInterval', 'Statistical Inference', '(value)', 'Validate the confidence interval representation and domain rules for Statistical Inference.', 'professional_function_catalog.md'), + ('statisticalInferenceValidateEstimator', 'Statistical Inference', '(value)', 'Validate the estimator representation and domain rules for Statistical Inference.', 'professional_function_catalog.md'), + ('statisticalInferenceValidateHypothesisTest', 'Statistical Inference', '(value)', 'Validate the hypothesis test representation and domain rules for Statistical Inference.', 'professional_function_catalog.md'), + ('statisticalInferenceValidateSamplingDistribution', 'Statistical Inference', '(value)', 'Validate the sampling distribution representation and domain rules for Statistical Inference.', 'professional_function_catalog.md'), + ('statisticalInferenceValidateTestStatistic', 'Statistical Inference', '(value)', 'Validate the test statistic representation and domain rules for Statistical Inference.', 'professional_function_catalog.md'), + ('tStatisticMean', 'Statistical Inference', '(values, hypothesizedMean)', 'Planned roadmap function for Statistical Inference from upcoming.md.', 'upcoming.md'), + ('zTestMean', 'Statistical Inference', '(sampleMean, populationMean, stdDev, n)', 'Planned roadmap function for Statistical Inference from upcoming.md.', 'upcoming.md'), + ('correlation', 'Statistics', '(xValues, yValues)', 'Planned roadmap function for Statistics from upcoming.md.', 'upcoming.md'), + ('covariance', 'Statistics', '(xValues, yValues)', 'Planned roadmap function for Statistics from upcoming.md.', 'upcoming.md'), + ('interquartileRange', 'Statistics', '(arr)', 'Planned roadmap function for Statistics from upcoming.md.', 'upcoming.md'), + ('linearRegression', 'Statistics', '(xValues, yValues)', 'Planned roadmap function for Statistics from upcoming.md.', 'upcoming.md'), + ('percentile', 'Statistics', '(arr, p)', 'Planned roadmap function for Statistics from upcoming.md.', 'upcoming.md'), + ('quartiles', 'Statistics', '(arr)', 'Planned roadmap function for Statistics from upcoming.md.', 'upcoming.md'), + ('sampleStandardDeviation', 'Statistics', '(arr)', 'Planned roadmap function for Statistics from upcoming.md.', 'upcoming.md'), + ('sampleVariance', 'Statistics', '(arr)', 'Planned roadmap function for Statistics from upcoming.md.', 'upcoming.md'), + ('standardDeviation', 'Statistics', '(arr)', 'Planned roadmap function for Statistics from upcoming.md.', 'upcoming.md'), + ('statisticsApproximateDistributionSummary', 'Statistics', '(value, tolerance=1e-9)', 'Approximate a distribution summary with explicit tolerance controls.', 'professional_function_catalog.md'), + ('statisticsApproximateEstimator', 'Statistics', '(value, tolerance=1e-9)', 'Approximate a estimator with explicit tolerance controls.', 'professional_function_catalog.md'), + ('statisticsApproximateRegressionModel', 'Statistics', '(value, tolerance=1e-9)', 'Approximate a regression model with explicit tolerance controls.', 'professional_function_catalog.md'), + ('statisticsApproximateSample', 'Statistics', '(value, tolerance=1e-9)', 'Approximate a sample with explicit tolerance controls.', 'professional_function_catalog.md'), + ('statisticsApproximateSummaryStatistic', 'Statistics', '(value, tolerance=1e-9)', 'Approximate a summary statistic with explicit tolerance controls.', 'professional_function_catalog.md'), + ('statisticsCanonicalizeDistributionSummary', 'Statistics', '(value)', 'Canonicalize a distribution summary so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('statisticsCanonicalizeEstimator', 'Statistics', '(value)', 'Canonicalize a estimator so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('statisticsCanonicalizeRegressionModel', 'Statistics', '(value)', 'Canonicalize a regression model so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('statisticsCanonicalizeSample', 'Statistics', '(value)', 'Canonicalize a sample so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('statisticsCanonicalizeSummaryStatistic', 'Statistics', '(value)', 'Canonicalize a summary statistic so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('statisticsClassifyDistributionSummary', 'Statistics', '(value)', 'Classify a distribution summary by its standard Statistics invariants.', 'professional_function_catalog.md'), + ('statisticsClassifyEstimator', 'Statistics', '(value)', 'Classify a estimator by its standard Statistics invariants.', 'professional_function_catalog.md'), + ('statisticsClassifyRegressionModel', 'Statistics', '(value)', 'Classify a regression model by its standard Statistics invariants.', 'professional_function_catalog.md'), + ('statisticsClassifySample', 'Statistics', '(value)', 'Classify a sample by its standard Statistics invariants.', 'professional_function_catalog.md'), + ('statisticsClassifySummaryStatistic', 'Statistics', '(value)', 'Classify a summary statistic by its standard Statistics invariants.', 'professional_function_catalog.md'), + ('statisticsCombineDistributionSummary', 'Statistics', '(left, right)', 'Combine two distribution summary values with the natural operation for Statistics.', 'professional_function_catalog.md'), + ('statisticsCombineEstimator', 'Statistics', '(left, right)', 'Combine two estimator values with the natural operation for Statistics.', 'professional_function_catalog.md'), + ('statisticsCombineRegressionModel', 'Statistics', '(left, right)', 'Combine two regression model values with the natural operation for Statistics.', 'professional_function_catalog.md'), + ('statisticsCombineSample', 'Statistics', '(left, right)', 'Combine two sample values with the natural operation for Statistics.', 'professional_function_catalog.md'), + ('statisticsCombineSummaryStatistic', 'Statistics', '(left, right)', 'Combine two summary statistic values with the natural operation for Statistics.', 'professional_function_catalog.md'), + ('statisticsCompareDistributionSummary', 'Statistics', '(left, right)', 'Compare two distribution summary values under the conventions of Statistics.', 'professional_function_catalog.md'), + ('statisticsCompareEstimator', 'Statistics', '(left, right)', 'Compare two estimator values under the conventions of Statistics.', 'professional_function_catalog.md'), + ('statisticsCompareRegressionModel', 'Statistics', '(left, right)', 'Compare two regression model values under the conventions of Statistics.', 'professional_function_catalog.md'), + ('statisticsCompareSample', 'Statistics', '(left, right)', 'Compare two sample values under the conventions of Statistics.', 'professional_function_catalog.md'), + ('statisticsCompareSummaryStatistic', 'Statistics', '(left, right)', 'Compare two summary statistic values under the conventions of Statistics.', 'professional_function_catalog.md'), + ('statisticsComputeDistributionSummary', 'Statistics', '(value)', 'Compute the central numerical or symbolic data of a distribution summary.', 'professional_function_catalog.md'), + ('statisticsComputeEstimator', 'Statistics', '(value)', 'Compute the central numerical or symbolic data of a estimator.', 'professional_function_catalog.md'), + ('statisticsComputeRegressionModel', 'Statistics', '(value)', 'Compute the central numerical or symbolic data of a regression model.', 'professional_function_catalog.md'), + ('statisticsComputeSample', 'Statistics', '(value)', 'Compute the central numerical or symbolic data of a sample.', 'professional_function_catalog.md'), + ('statisticsComputeSummaryStatistic', 'Statistics', '(value)', 'Compute the central numerical or symbolic data of a summary statistic.', 'professional_function_catalog.md'), + ('statisticsConstructDistributionSummary', 'Statistics', '(*args)', 'Construct a distribution summary from explicit inputs for Statistics.', 'professional_function_catalog.md'), + ('statisticsConstructEstimator', 'Statistics', '(*args)', 'Construct a estimator from explicit inputs for Statistics.', 'professional_function_catalog.md'), + ('statisticsConstructRegressionModel', 'Statistics', '(*args)', 'Construct a regression model from explicit inputs for Statistics.', 'professional_function_catalog.md'), + ('statisticsConstructSample', 'Statistics', '(*args)', 'Construct a sample from explicit inputs for Statistics.', 'professional_function_catalog.md'), + ('statisticsConstructSummaryStatistic', 'Statistics', '(*args)', 'Construct a summary statistic from explicit inputs for Statistics.', 'professional_function_catalog.md'), + ('statisticsDecomposeDistributionSummary', 'Statistics', '(value)', 'Decompose a distribution summary into simpler or canonical components.', 'professional_function_catalog.md'), + ('statisticsDecomposeEstimator', 'Statistics', '(value)', 'Decompose a estimator into simpler or canonical components.', 'professional_function_catalog.md'), + ('statisticsDecomposeRegressionModel', 'Statistics', '(value)', 'Decompose a regression model into simpler or canonical components.', 'professional_function_catalog.md'), + ('statisticsDecomposeSample', 'Statistics', '(value)', 'Decompose a sample into simpler or canonical components.', 'professional_function_catalog.md'), + ('statisticsDecomposeSummaryStatistic', 'Statistics', '(value)', 'Decompose a summary statistic into simpler or canonical components.', 'professional_function_catalog.md'), + ('statisticsDocumentDistributionSummary', 'Statistics', '(value)', 'Return a structured explanation of a distribution summary and related assumptions.', 'professional_function_catalog.md'), + ('statisticsDocumentEstimator', 'Statistics', '(value)', 'Return a structured explanation of a estimator and related assumptions.', 'professional_function_catalog.md'), + ('statisticsDocumentRegressionModel', 'Statistics', '(value)', 'Return a structured explanation of a regression model and related assumptions.', 'professional_function_catalog.md'), + ('statisticsDocumentSample', 'Statistics', '(value)', 'Return a structured explanation of a sample and related assumptions.', 'professional_function_catalog.md'), + ('statisticsDocumentSummaryStatistic', 'Statistics', '(value)', 'Return a structured explanation of a summary statistic and related assumptions.', 'professional_function_catalog.md'), + ('statisticsEnumerateDistributionSummary', 'Statistics', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a distribution summary.', 'professional_function_catalog.md'), + ('statisticsEnumerateEstimator', 'Statistics', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a estimator.', 'professional_function_catalog.md'), + ('statisticsEnumerateRegressionModel', 'Statistics', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a regression model.', 'professional_function_catalog.md'), + ('statisticsEnumerateSample', 'Statistics', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a sample.', 'professional_function_catalog.md'), + ('statisticsEnumerateSummaryStatistic', 'Statistics', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a summary statistic.', 'professional_function_catalog.md'), + ('statisticsEstimateDistributionSummary', 'Statistics', '(value, samples=None)', 'Estimate a distribution summary property from finite samples or approximations.', 'professional_function_catalog.md'), + ('statisticsEstimateEstimator', 'Statistics', '(value, samples=None)', 'Estimate a estimator property from finite samples or approximations.', 'professional_function_catalog.md'), + ('statisticsEstimateRegressionModel', 'Statistics', '(value, samples=None)', 'Estimate a regression model property from finite samples or approximations.', 'professional_function_catalog.md'), + ('statisticsEstimateSample', 'Statistics', '(value, samples=None)', 'Estimate a sample property from finite samples or approximations.', 'professional_function_catalog.md'), + ('statisticsEstimateSummaryStatistic', 'Statistics', '(value, samples=None)', 'Estimate a summary statistic property from finite samples or approximations.', 'professional_function_catalog.md'), + ('statisticsEvaluateDistributionSummary', 'Statistics', '(value, point=None)', 'Evaluate a distribution summary at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('statisticsEvaluateEstimator', 'Statistics', '(value, point=None)', 'Evaluate a estimator at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('statisticsEvaluateRegressionModel', 'Statistics', '(value, point=None)', 'Evaluate a regression model at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('statisticsEvaluateSample', 'Statistics', '(value, point=None)', 'Evaluate a sample at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('statisticsEvaluateSummaryStatistic', 'Statistics', '(value, point=None)', 'Evaluate a summary statistic at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('statisticsFormatDistributionSummary', 'Statistics', '(value)', 'Format a distribution summary for deterministic user-facing output.', 'professional_function_catalog.md'), + ('statisticsFormatEstimator', 'Statistics', '(value)', 'Format a estimator for deterministic user-facing output.', 'professional_function_catalog.md'), + ('statisticsFormatRegressionModel', 'Statistics', '(value)', 'Format a regression model for deterministic user-facing output.', 'professional_function_catalog.md'), + ('statisticsFormatSample', 'Statistics', '(value)', 'Format a sample for deterministic user-facing output.', 'professional_function_catalog.md'), + ('statisticsFormatSummaryStatistic', 'Statistics', '(value)', 'Format a summary statistic for deterministic user-facing output.', 'professional_function_catalog.md'), + ('statisticsGenerateExampleDistributionSummary', 'Statistics', '(size=3)', 'Generate a small documented example of a distribution summary.', 'professional_function_catalog.md'), + ('statisticsGenerateExampleEstimator', 'Statistics', '(size=3)', 'Generate a small documented example of a estimator.', 'professional_function_catalog.md'), + ('statisticsGenerateExampleRegressionModel', 'Statistics', '(size=3)', 'Generate a small documented example of a regression model.', 'professional_function_catalog.md'), + ('statisticsGenerateExampleSample', 'Statistics', '(size=3)', 'Generate a small documented example of a sample.', 'professional_function_catalog.md'), + ('statisticsGenerateExampleSummaryStatistic', 'Statistics', '(size=3)', 'Generate a small documented example of a summary statistic.', 'professional_function_catalog.md'), + ('statisticsNormalizeDistributionSummary', 'Statistics', '(value)', 'Normalize a distribution summary into the standard Statistics representation.', 'professional_function_catalog.md'), + ('statisticsNormalizeEstimator', 'Statistics', '(value)', 'Normalize a estimator into the standard Statistics representation.', 'professional_function_catalog.md'), + ('statisticsNormalizeRegressionModel', 'Statistics', '(value)', 'Normalize a regression model into the standard Statistics representation.', 'professional_function_catalog.md'), + ('statisticsNormalizeSample', 'Statistics', '(value)', 'Normalize a sample into the standard Statistics representation.', 'professional_function_catalog.md'), + ('statisticsNormalizeSummaryStatistic', 'Statistics', '(value)', 'Normalize a summary statistic into the standard Statistics representation.', 'professional_function_catalog.md'), + ('statisticsParseDistributionSummary', 'Statistics', '(text)', 'Parse a text or structured value into a distribution summary.', 'professional_function_catalog.md'), + ('statisticsParseEstimator', 'Statistics', '(text)', 'Parse a text or structured value into a estimator.', 'professional_function_catalog.md'), + ('statisticsParseRegressionModel', 'Statistics', '(text)', 'Parse a text or structured value into a regression model.', 'professional_function_catalog.md'), + ('statisticsParseSample', 'Statistics', '(text)', 'Parse a text or structured value into a sample.', 'professional_function_catalog.md'), + ('statisticsParseSummaryStatistic', 'Statistics', '(text)', 'Parse a text or structured value into a summary statistic.', 'professional_function_catalog.md'), + ('statisticsSimplifyDistributionSummary', 'Statistics', '(value)', 'Simplify a distribution summary without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('statisticsSimplifyEstimator', 'Statistics', '(value)', 'Simplify a estimator without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('statisticsSimplifyRegressionModel', 'Statistics', '(value)', 'Simplify a regression model without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('statisticsSimplifySample', 'Statistics', '(value)', 'Simplify a sample without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('statisticsSimplifySummaryStatistic', 'Statistics', '(value)', 'Simplify a summary statistic without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('statisticsTestEquivalenceDistributionSummary', 'Statistics', '(left, right)', 'Test whether two distribution summary values are equivalent in Statistics.', 'professional_function_catalog.md'), + ('statisticsTestEquivalenceEstimator', 'Statistics', '(left, right)', 'Test whether two estimator values are equivalent in Statistics.', 'professional_function_catalog.md'), + ('statisticsTestEquivalenceRegressionModel', 'Statistics', '(left, right)', 'Test whether two regression model values are equivalent in Statistics.', 'professional_function_catalog.md'), + ('statisticsTestEquivalenceSample', 'Statistics', '(left, right)', 'Test whether two sample values are equivalent in Statistics.', 'professional_function_catalog.md'), + ('statisticsTestEquivalenceSummaryStatistic', 'Statistics', '(left, right)', 'Test whether two summary statistic values are equivalent in Statistics.', 'professional_function_catalog.md'), + ('statisticsTransformDistributionSummary', 'Statistics', '(value, mapping)', 'Transform a distribution summary through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('statisticsTransformEstimator', 'Statistics', '(value, mapping)', 'Transform a estimator through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('statisticsTransformRegressionModel', 'Statistics', '(value, mapping)', 'Transform a regression model through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('statisticsTransformSample', 'Statistics', '(value, mapping)', 'Transform a sample through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('statisticsTransformSummaryStatistic', 'Statistics', '(value, mapping)', 'Transform a summary statistic through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('statisticsValidateDistributionSummary', 'Statistics', '(value)', 'Validate the distribution summary representation and domain rules for Statistics.', 'professional_function_catalog.md'), + ('statisticsValidateEstimator', 'Statistics', '(value)', 'Validate the estimator representation and domain rules for Statistics.', 'professional_function_catalog.md'), + ('statisticsValidateRegressionModel', 'Statistics', '(value)', 'Validate the regression model representation and domain rules for Statistics.', 'professional_function_catalog.md'), + ('statisticsValidateSample', 'Statistics', '(value)', 'Validate the sample representation and domain rules for Statistics.', 'professional_function_catalog.md'), + ('statisticsValidateSummaryStatistic', 'Statistics', '(value)', 'Validate the summary statistic representation and domain rules for Statistics.', 'professional_function_catalog.md'), + ('zScore', 'Statistics', '(x, mean, stdDev)', 'Planned roadmap function for Statistics from upcoming.md.', 'upcoming.md'), + ('blackScholesCallPrice', 'Stochastic Calculus', '(S, K, r, sigma, T)', 'Planned roadmap function for Stochastic Calculus from upcoming.md.', 'upcoming.md'), + ('blackScholesPutPrice', 'Stochastic Calculus', '(S, K, r, sigma, T)', 'Planned roadmap function for Stochastic Calculus from upcoming.md.', 'upcoming.md'), + ('brownianPath', 'Stochastic Calculus', '(increments, start=0)', 'Planned roadmap function for Stochastic Calculus from upcoming.md.', 'upcoming.md'), + ('eulerMaruyamaStep', 'Stochastic Calculus', '(x, drift, diffusion, dt, dW)', 'Planned roadmap function for Stochastic Calculus from upcoming.md.', 'upcoming.md'), + ('geometricBrownianMotionPath', 'Stochastic Calculus', '(mu, sigma, increments, start)', 'Planned roadmap function for Stochastic Calculus from upcoming.md.', 'upcoming.md'), + ('itoIntegralApprox', 'Stochastic Calculus', '(integrandValues, brownianIncrements)', 'Planned roadmap function for Stochastic Calculus from upcoming.md.', 'upcoming.md'), + ('quadraticVariation', 'Stochastic Calculus', '(path)', 'Planned roadmap function for Stochastic Calculus from upcoming.md.', 'upcoming.md'), + ('stochasticCalculusApproximateBrownianPath', 'Stochastic Calculus', '(value, tolerance=1e-9)', 'Approximate a brownian path with explicit tolerance controls.', 'professional_function_catalog.md'), + ('stochasticCalculusApproximateDiffusionProcess', 'Stochastic Calculus', '(value, tolerance=1e-9)', 'Approximate a diffusion process with explicit tolerance controls.', 'professional_function_catalog.md'), + ('stochasticCalculusApproximateQuadraticVariation', 'Stochastic Calculus', '(value, tolerance=1e-9)', 'Approximate a quadratic variation with explicit tolerance controls.', 'professional_function_catalog.md'), + ('stochasticCalculusApproximateSdeModel', 'Stochastic Calculus', '(value, tolerance=1e-9)', 'Approximate a sde model with explicit tolerance controls.', 'professional_function_catalog.md'), + ('stochasticCalculusApproximateStochasticIntegral', 'Stochastic Calculus', '(value, tolerance=1e-9)', 'Approximate a stochastic integral with explicit tolerance controls.', 'professional_function_catalog.md'), + ('stochasticCalculusCanonicalizeBrownianPath', 'Stochastic Calculus', '(value)', 'Canonicalize a brownian path so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('stochasticCalculusCanonicalizeDiffusionProcess', 'Stochastic Calculus', '(value)', 'Canonicalize a diffusion process so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('stochasticCalculusCanonicalizeQuadraticVariation', 'Stochastic Calculus', '(value)', 'Canonicalize a quadratic variation so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('stochasticCalculusCanonicalizeSdeModel', 'Stochastic Calculus', '(value)', 'Canonicalize a sde model so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('stochasticCalculusCanonicalizeStochasticIntegral', 'Stochastic Calculus', '(value)', 'Canonicalize a stochastic integral so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('stochasticCalculusClassifyBrownianPath', 'Stochastic Calculus', '(value)', 'Classify a brownian path by its standard Stochastic Calculus invariants.', 'professional_function_catalog.md'), + ('stochasticCalculusClassifyDiffusionProcess', 'Stochastic Calculus', '(value)', 'Classify a diffusion process by its standard Stochastic Calculus invariants.', 'professional_function_catalog.md'), + ('stochasticCalculusClassifyQuadraticVariation', 'Stochastic Calculus', '(value)', 'Classify a quadratic variation by its standard Stochastic Calculus invariants.', 'professional_function_catalog.md'), + ('stochasticCalculusClassifySdeModel', 'Stochastic Calculus', '(value)', 'Classify a sde model by its standard Stochastic Calculus invariants.', 'professional_function_catalog.md'), + ('stochasticCalculusClassifyStochasticIntegral', 'Stochastic Calculus', '(value)', 'Classify a stochastic integral by its standard Stochastic Calculus invariants.', 'professional_function_catalog.md'), + ('stochasticCalculusCombineBrownianPath', 'Stochastic Calculus', '(left, right)', 'Combine two brownian path values with the natural operation for Stochastic Calculus.', 'professional_function_catalog.md'), + ('stochasticCalculusCombineDiffusionProcess', 'Stochastic Calculus', '(left, right)', 'Combine two diffusion process values with the natural operation for Stochastic Calculus.', 'professional_function_catalog.md'), + ('stochasticCalculusCombineQuadraticVariation', 'Stochastic Calculus', '(left, right)', 'Combine two quadratic variation values with the natural operation for Stochastic Calculus.', 'professional_function_catalog.md'), + ('stochasticCalculusCombineSdeModel', 'Stochastic Calculus', '(left, right)', 'Combine two sde model values with the natural operation for Stochastic Calculus.', 'professional_function_catalog.md'), + ('stochasticCalculusCombineStochasticIntegral', 'Stochastic Calculus', '(left, right)', 'Combine two stochastic integral values with the natural operation for Stochastic Calculus.', 'professional_function_catalog.md'), + ('stochasticCalculusCompareBrownianPath', 'Stochastic Calculus', '(left, right)', 'Compare two brownian path values under the conventions of Stochastic Calculus.', 'professional_function_catalog.md'), + ('stochasticCalculusCompareDiffusionProcess', 'Stochastic Calculus', '(left, right)', 'Compare two diffusion process values under the conventions of Stochastic Calculus.', 'professional_function_catalog.md'), + ('stochasticCalculusCompareQuadraticVariation', 'Stochastic Calculus', '(left, right)', 'Compare two quadratic variation values under the conventions of Stochastic Calculus.', 'professional_function_catalog.md'), + ('stochasticCalculusCompareSdeModel', 'Stochastic Calculus', '(left, right)', 'Compare two sde model values under the conventions of Stochastic Calculus.', 'professional_function_catalog.md'), + ('stochasticCalculusCompareStochasticIntegral', 'Stochastic Calculus', '(left, right)', 'Compare two stochastic integral values under the conventions of Stochastic Calculus.', 'professional_function_catalog.md'), + ('stochasticCalculusComputeBrownianPath', 'Stochastic Calculus', '(value)', 'Compute the central numerical or symbolic data of a brownian path.', 'professional_function_catalog.md'), + ('stochasticCalculusComputeDiffusionProcess', 'Stochastic Calculus', '(value)', 'Compute the central numerical or symbolic data of a diffusion process.', 'professional_function_catalog.md'), + ('stochasticCalculusComputeQuadraticVariation', 'Stochastic Calculus', '(value)', 'Compute the central numerical or symbolic data of a quadratic variation.', 'professional_function_catalog.md'), + ('stochasticCalculusComputeSdeModel', 'Stochastic Calculus', '(value)', 'Compute the central numerical or symbolic data of a sde model.', 'professional_function_catalog.md'), + ('stochasticCalculusComputeStochasticIntegral', 'Stochastic Calculus', '(value)', 'Compute the central numerical or symbolic data of a stochastic integral.', 'professional_function_catalog.md'), + ('stochasticCalculusConstructBrownianPath', 'Stochastic Calculus', '(*args)', 'Construct a brownian path from explicit inputs for Stochastic Calculus.', 'professional_function_catalog.md'), + ('stochasticCalculusConstructDiffusionProcess', 'Stochastic Calculus', '(*args)', 'Construct a diffusion process from explicit inputs for Stochastic Calculus.', 'professional_function_catalog.md'), + ('stochasticCalculusConstructQuadraticVariation', 'Stochastic Calculus', '(*args)', 'Construct a quadratic variation from explicit inputs for Stochastic Calculus.', 'professional_function_catalog.md'), + ('stochasticCalculusConstructSdeModel', 'Stochastic Calculus', '(*args)', 'Construct a sde model from explicit inputs for Stochastic Calculus.', 'professional_function_catalog.md'), + ('stochasticCalculusConstructStochasticIntegral', 'Stochastic Calculus', '(*args)', 'Construct a stochastic integral from explicit inputs for Stochastic Calculus.', 'professional_function_catalog.md'), + ('stochasticCalculusDecomposeBrownianPath', 'Stochastic Calculus', '(value)', 'Decompose a brownian path into simpler or canonical components.', 'professional_function_catalog.md'), + ('stochasticCalculusDecomposeDiffusionProcess', 'Stochastic Calculus', '(value)', 'Decompose a diffusion process into simpler or canonical components.', 'professional_function_catalog.md'), + ('stochasticCalculusDecomposeQuadraticVariation', 'Stochastic Calculus', '(value)', 'Decompose a quadratic variation into simpler or canonical components.', 'professional_function_catalog.md'), + ('stochasticCalculusDecomposeSdeModel', 'Stochastic Calculus', '(value)', 'Decompose a sde model into simpler or canonical components.', 'professional_function_catalog.md'), + ('stochasticCalculusDecomposeStochasticIntegral', 'Stochastic Calculus', '(value)', 'Decompose a stochastic integral into simpler or canonical components.', 'professional_function_catalog.md'), + ('stochasticCalculusDocumentBrownianPath', 'Stochastic Calculus', '(value)', 'Return a structured explanation of a brownian path and related assumptions.', 'professional_function_catalog.md'), + ('stochasticCalculusDocumentDiffusionProcess', 'Stochastic Calculus', '(value)', 'Return a structured explanation of a diffusion process and related assumptions.', 'professional_function_catalog.md'), + ('stochasticCalculusDocumentQuadraticVariation', 'Stochastic Calculus', '(value)', 'Return a structured explanation of a quadratic variation and related assumptions.', 'professional_function_catalog.md'), + ('stochasticCalculusDocumentSdeModel', 'Stochastic Calculus', '(value)', 'Return a structured explanation of a sde model and related assumptions.', 'professional_function_catalog.md'), + ('stochasticCalculusDocumentStochasticIntegral', 'Stochastic Calculus', '(value)', 'Return a structured explanation of a stochastic integral and related assumptions.', 'professional_function_catalog.md'), + ('stochasticCalculusEnumerateBrownianPath', 'Stochastic Calculus', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a brownian path.', 'professional_function_catalog.md'), + ('stochasticCalculusEnumerateDiffusionProcess', 'Stochastic Calculus', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a diffusion process.', 'professional_function_catalog.md'), + ('stochasticCalculusEnumerateQuadraticVariation', 'Stochastic Calculus', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a quadratic variation.', 'professional_function_catalog.md'), + ('stochasticCalculusEnumerateSdeModel', 'Stochastic Calculus', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a sde model.', 'professional_function_catalog.md'), + ('stochasticCalculusEnumerateStochasticIntegral', 'Stochastic Calculus', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a stochastic integral.', 'professional_function_catalog.md'), + ('stochasticCalculusEstimateBrownianPath', 'Stochastic Calculus', '(value, samples=None)', 'Estimate a brownian path property from finite samples or approximations.', 'professional_function_catalog.md'), + ('stochasticCalculusEstimateDiffusionProcess', 'Stochastic Calculus', '(value, samples=None)', 'Estimate a diffusion process property from finite samples or approximations.', 'professional_function_catalog.md'), + ('stochasticCalculusEstimateQuadraticVariation', 'Stochastic Calculus', '(value, samples=None)', 'Estimate a quadratic variation property from finite samples or approximations.', 'professional_function_catalog.md'), + ('stochasticCalculusEstimateSdeModel', 'Stochastic Calculus', '(value, samples=None)', 'Estimate a sde model property from finite samples or approximations.', 'professional_function_catalog.md'), + ('stochasticCalculusEstimateStochasticIntegral', 'Stochastic Calculus', '(value, samples=None)', 'Estimate a stochastic integral property from finite samples or approximations.', 'professional_function_catalog.md'), + ('stochasticCalculusEvaluateBrownianPath', 'Stochastic Calculus', '(value, point=None)', 'Evaluate a brownian path at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('stochasticCalculusEvaluateDiffusionProcess', 'Stochastic Calculus', '(value, point=None)', 'Evaluate a diffusion process at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('stochasticCalculusEvaluateQuadraticVariation', 'Stochastic Calculus', '(value, point=None)', 'Evaluate a quadratic variation at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('stochasticCalculusEvaluateSdeModel', 'Stochastic Calculus', '(value, point=None)', 'Evaluate a sde model at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('stochasticCalculusEvaluateStochasticIntegral', 'Stochastic Calculus', '(value, point=None)', 'Evaluate a stochastic integral at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('stochasticCalculusFormatBrownianPath', 'Stochastic Calculus', '(value)', 'Format a brownian path for deterministic user-facing output.', 'professional_function_catalog.md'), + ('stochasticCalculusFormatDiffusionProcess', 'Stochastic Calculus', '(value)', 'Format a diffusion process for deterministic user-facing output.', 'professional_function_catalog.md'), + ('stochasticCalculusFormatQuadraticVariation', 'Stochastic Calculus', '(value)', 'Format a quadratic variation for deterministic user-facing output.', 'professional_function_catalog.md'), + ('stochasticCalculusFormatSdeModel', 'Stochastic Calculus', '(value)', 'Format a sde model for deterministic user-facing output.', 'professional_function_catalog.md'), + ('stochasticCalculusFormatStochasticIntegral', 'Stochastic Calculus', '(value)', 'Format a stochastic integral for deterministic user-facing output.', 'professional_function_catalog.md'), + ('stochasticCalculusGenerateExampleBrownianPath', 'Stochastic Calculus', '(size=3)', 'Generate a small documented example of a brownian path.', 'professional_function_catalog.md'), + ('stochasticCalculusGenerateExampleDiffusionProcess', 'Stochastic Calculus', '(size=3)', 'Generate a small documented example of a diffusion process.', 'professional_function_catalog.md'), + ('stochasticCalculusGenerateExampleQuadraticVariation', 'Stochastic Calculus', '(size=3)', 'Generate a small documented example of a quadratic variation.', 'professional_function_catalog.md'), + ('stochasticCalculusGenerateExampleSdeModel', 'Stochastic Calculus', '(size=3)', 'Generate a small documented example of a sde model.', 'professional_function_catalog.md'), + ('stochasticCalculusGenerateExampleStochasticIntegral', 'Stochastic Calculus', '(size=3)', 'Generate a small documented example of a stochastic integral.', 'professional_function_catalog.md'), + ('stochasticCalculusNormalizeBrownianPath', 'Stochastic Calculus', '(value)', 'Normalize a brownian path into the standard Stochastic Calculus representation.', 'professional_function_catalog.md'), + ('stochasticCalculusNormalizeDiffusionProcess', 'Stochastic Calculus', '(value)', 'Normalize a diffusion process into the standard Stochastic Calculus representation.', 'professional_function_catalog.md'), + ('stochasticCalculusNormalizeQuadraticVariation', 'Stochastic Calculus', '(value)', 'Normalize a quadratic variation into the standard Stochastic Calculus representation.', 'professional_function_catalog.md'), + ('stochasticCalculusNormalizeSdeModel', 'Stochastic Calculus', '(value)', 'Normalize a sde model into the standard Stochastic Calculus representation.', 'professional_function_catalog.md'), + ('stochasticCalculusNormalizeStochasticIntegral', 'Stochastic Calculus', '(value)', 'Normalize a stochastic integral into the standard Stochastic Calculus representation.', 'professional_function_catalog.md'), + ('stochasticCalculusParseBrownianPath', 'Stochastic Calculus', '(text)', 'Parse a text or structured value into a brownian path.', 'professional_function_catalog.md'), + ('stochasticCalculusParseDiffusionProcess', 'Stochastic Calculus', '(text)', 'Parse a text or structured value into a diffusion process.', 'professional_function_catalog.md'), + ('stochasticCalculusParseQuadraticVariation', 'Stochastic Calculus', '(text)', 'Parse a text or structured value into a quadratic variation.', 'professional_function_catalog.md'), + ('stochasticCalculusParseSdeModel', 'Stochastic Calculus', '(text)', 'Parse a text or structured value into a sde model.', 'professional_function_catalog.md'), + ('stochasticCalculusParseStochasticIntegral', 'Stochastic Calculus', '(text)', 'Parse a text or structured value into a stochastic integral.', 'professional_function_catalog.md'), + ('stochasticCalculusSimplifyBrownianPath', 'Stochastic Calculus', '(value)', 'Simplify a brownian path without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('stochasticCalculusSimplifyDiffusionProcess', 'Stochastic Calculus', '(value)', 'Simplify a diffusion process without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('stochasticCalculusSimplifyQuadraticVariation', 'Stochastic Calculus', '(value)', 'Simplify a quadratic variation without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('stochasticCalculusSimplifySdeModel', 'Stochastic Calculus', '(value)', 'Simplify a sde model without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('stochasticCalculusSimplifyStochasticIntegral', 'Stochastic Calculus', '(value)', 'Simplify a stochastic integral without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('stochasticCalculusTestEquivalenceBrownianPath', 'Stochastic Calculus', '(left, right)', 'Test whether two brownian path values are equivalent in Stochastic Calculus.', 'professional_function_catalog.md'), + ('stochasticCalculusTestEquivalenceDiffusionProcess', 'Stochastic Calculus', '(left, right)', 'Test whether two diffusion process values are equivalent in Stochastic Calculus.', 'professional_function_catalog.md'), + ('stochasticCalculusTestEquivalenceQuadraticVariation', 'Stochastic Calculus', '(left, right)', 'Test whether two quadratic variation values are equivalent in Stochastic Calculus.', 'professional_function_catalog.md'), + ('stochasticCalculusTestEquivalenceSdeModel', 'Stochastic Calculus', '(left, right)', 'Test whether two sde model values are equivalent in Stochastic Calculus.', 'professional_function_catalog.md'), + ('stochasticCalculusTestEquivalenceStochasticIntegral', 'Stochastic Calculus', '(left, right)', 'Test whether two stochastic integral values are equivalent in Stochastic Calculus.', 'professional_function_catalog.md'), + ('stochasticCalculusTransformBrownianPath', 'Stochastic Calculus', '(value, mapping)', 'Transform a brownian path through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('stochasticCalculusTransformDiffusionProcess', 'Stochastic Calculus', '(value, mapping)', 'Transform a diffusion process through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('stochasticCalculusTransformQuadraticVariation', 'Stochastic Calculus', '(value, mapping)', 'Transform a quadratic variation through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('stochasticCalculusTransformSdeModel', 'Stochastic Calculus', '(value, mapping)', 'Transform a sde model through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('stochasticCalculusTransformStochasticIntegral', 'Stochastic Calculus', '(value, mapping)', 'Transform a stochastic integral through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('stochasticCalculusValidateBrownianPath', 'Stochastic Calculus', '(value)', 'Validate the brownian path representation and domain rules for Stochastic Calculus.', 'professional_function_catalog.md'), + ('stochasticCalculusValidateDiffusionProcess', 'Stochastic Calculus', '(value)', 'Validate the diffusion process representation and domain rules for Stochastic Calculus.', 'professional_function_catalog.md'), + ('stochasticCalculusValidateQuadraticVariation', 'Stochastic Calculus', '(value)', 'Validate the quadratic variation representation and domain rules for Stochastic Calculus.', 'professional_function_catalog.md'), + ('stochasticCalculusValidateSdeModel', 'Stochastic Calculus', '(value)', 'Validate the sde model representation and domain rules for Stochastic Calculus.', 'professional_function_catalog.md'), + ('stochasticCalculusValidateStochasticIntegral', 'Stochastic Calculus', '(value)', 'Validate the stochastic integral representation and domain rules for Stochastic Calculus.', 'professional_function_catalog.md'), + ('stratonovichIntegralApprox', 'Stochastic Calculus', '(integrandValues, brownianIncrements)', 'Planned roadmap function for Stochastic Calculus from upcoming.md.', 'upcoming.md'), + ('absorbingStates', 'Stochastic Processes', '(transitionMatrix)', 'Planned roadmap function for Stochastic Processes from upcoming.md.', 'upcoming.md'), + ('expectedReturnTime', 'Stochastic Processes', '(transitionMatrix, state)', 'Planned roadmap function for Stochastic Processes from upcoming.md.', 'upcoming.md'), + ('hittingProbability', 'Stochastic Processes', '(transitionMatrix, start, target)', 'Planned roadmap function for Stochastic Processes from upcoming.md.', 'upcoming.md'), + ('isTransitionMatrix', 'Stochastic Processes', '(matrix)', 'Planned roadmap function for Stochastic Processes from upcoming.md.', 'upcoming.md'), + ('markovChainDistribution', 'Stochastic Processes', '(initial, transitionMatrix, steps)', 'Planned roadmap function for Stochastic Processes from upcoming.md.', 'upcoming.md'), + ('markovStep', 'Stochastic Processes', '(distribution, transitionMatrix)', 'Planned roadmap function for Stochastic Processes from upcoming.md.', 'upcoming.md'), + ('randomWalkPath', 'Stochastic Processes', '(start, steps, increments)', 'Planned roadmap function for Stochastic Processes from upcoming.md.', 'upcoming.md'), + ('stationaryDistribution', 'Stochastic Processes', '(transitionMatrix)', 'Planned roadmap function for Stochastic Processes from upcoming.md.', 'upcoming.md'), + ('stochasticProcessesApproximateHittingEvent', 'Stochastic Processes', '(value, tolerance=1e-9)', 'Approximate a hitting event with explicit tolerance controls.', 'professional_function_catalog.md'), + ('stochasticProcessesApproximateMartingaleCandidate', 'Stochastic Processes', '(value, tolerance=1e-9)', 'Approximate a martingale candidate with explicit tolerance controls.', 'professional_function_catalog.md'), + ('stochasticProcessesApproximateRandomProcess', 'Stochastic Processes', '(value, tolerance=1e-9)', 'Approximate a random process with explicit tolerance controls.', 'professional_function_catalog.md'), + ('stochasticProcessesApproximateStateDistribution', 'Stochastic Processes', '(value, tolerance=1e-9)', 'Approximate a state distribution with explicit tolerance controls.', 'professional_function_catalog.md'), + ('stochasticProcessesApproximateTransitionMatrix', 'Stochastic Processes', '(value, tolerance=1e-9)', 'Approximate a transition matrix with explicit tolerance controls.', 'professional_function_catalog.md'), + ('stochasticProcessesCanonicalizeHittingEvent', 'Stochastic Processes', '(value)', 'Canonicalize a hitting event so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('stochasticProcessesCanonicalizeMartingaleCandidate', 'Stochastic Processes', '(value)', 'Canonicalize a martingale candidate so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('stochasticProcessesCanonicalizeRandomProcess', 'Stochastic Processes', '(value)', 'Canonicalize a random process so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('stochasticProcessesCanonicalizeStateDistribution', 'Stochastic Processes', '(value)', 'Canonicalize a state distribution so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('stochasticProcessesCanonicalizeTransitionMatrix', 'Stochastic Processes', '(value)', 'Canonicalize a transition matrix so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('stochasticProcessesClassifyHittingEvent', 'Stochastic Processes', '(value)', 'Classify a hitting event by its standard Stochastic Processes invariants.', 'professional_function_catalog.md'), + ('stochasticProcessesClassifyMartingaleCandidate', 'Stochastic Processes', '(value)', 'Classify a martingale candidate by its standard Stochastic Processes invariants.', 'professional_function_catalog.md'), + ('stochasticProcessesClassifyRandomProcess', 'Stochastic Processes', '(value)', 'Classify a random process by its standard Stochastic Processes invariants.', 'professional_function_catalog.md'), + ('stochasticProcessesClassifyStateDistribution', 'Stochastic Processes', '(value)', 'Classify a state distribution by its standard Stochastic Processes invariants.', 'professional_function_catalog.md'), + ('stochasticProcessesClassifyTransitionMatrix', 'Stochastic Processes', '(value)', 'Classify a transition matrix by its standard Stochastic Processes invariants.', 'professional_function_catalog.md'), + ('stochasticProcessesCombineHittingEvent', 'Stochastic Processes', '(left, right)', 'Combine two hitting event values with the natural operation for Stochastic Processes.', 'professional_function_catalog.md'), + ('stochasticProcessesCombineMartingaleCandidate', 'Stochastic Processes', '(left, right)', 'Combine two martingale candidate values with the natural operation for Stochastic Processes.', 'professional_function_catalog.md'), + ('stochasticProcessesCombineRandomProcess', 'Stochastic Processes', '(left, right)', 'Combine two random process values with the natural operation for Stochastic Processes.', 'professional_function_catalog.md'), + ('stochasticProcessesCombineStateDistribution', 'Stochastic Processes', '(left, right)', 'Combine two state distribution values with the natural operation for Stochastic Processes.', 'professional_function_catalog.md'), + ('stochasticProcessesCombineTransitionMatrix', 'Stochastic Processes', '(left, right)', 'Combine two transition matrix values with the natural operation for Stochastic Processes.', 'professional_function_catalog.md'), + ('stochasticProcessesCompareHittingEvent', 'Stochastic Processes', '(left, right)', 'Compare two hitting event values under the conventions of Stochastic Processes.', 'professional_function_catalog.md'), + ('stochasticProcessesCompareMartingaleCandidate', 'Stochastic Processes', '(left, right)', 'Compare two martingale candidate values under the conventions of Stochastic Processes.', 'professional_function_catalog.md'), + ('stochasticProcessesCompareRandomProcess', 'Stochastic Processes', '(left, right)', 'Compare two random process values under the conventions of Stochastic Processes.', 'professional_function_catalog.md'), + ('stochasticProcessesCompareStateDistribution', 'Stochastic Processes', '(left, right)', 'Compare two state distribution values under the conventions of Stochastic Processes.', 'professional_function_catalog.md'), + ('stochasticProcessesCompareTransitionMatrix', 'Stochastic Processes', '(left, right)', 'Compare two transition matrix values under the conventions of Stochastic Processes.', 'professional_function_catalog.md'), + ('stochasticProcessesComputeHittingEvent', 'Stochastic Processes', '(value)', 'Compute the central numerical or symbolic data of a hitting event.', 'professional_function_catalog.md'), + ('stochasticProcessesComputeMartingaleCandidate', 'Stochastic Processes', '(value)', 'Compute the central numerical or symbolic data of a martingale candidate.', 'professional_function_catalog.md'), + ('stochasticProcessesComputeRandomProcess', 'Stochastic Processes', '(value)', 'Compute the central numerical or symbolic data of a random process.', 'professional_function_catalog.md'), + ('stochasticProcessesComputeStateDistribution', 'Stochastic Processes', '(value)', 'Compute the central numerical or symbolic data of a state distribution.', 'professional_function_catalog.md'), + ('stochasticProcessesComputeTransitionMatrix', 'Stochastic Processes', '(value)', 'Compute the central numerical or symbolic data of a transition matrix.', 'professional_function_catalog.md'), + ('stochasticProcessesConstructHittingEvent', 'Stochastic Processes', '(*args)', 'Construct a hitting event from explicit inputs for Stochastic Processes.', 'professional_function_catalog.md'), + ('stochasticProcessesConstructMartingaleCandidate', 'Stochastic Processes', '(*args)', 'Construct a martingale candidate from explicit inputs for Stochastic Processes.', 'professional_function_catalog.md'), + ('stochasticProcessesConstructRandomProcess', 'Stochastic Processes', '(*args)', 'Construct a random process from explicit inputs for Stochastic Processes.', 'professional_function_catalog.md'), + ('stochasticProcessesConstructStateDistribution', 'Stochastic Processes', '(*args)', 'Construct a state distribution from explicit inputs for Stochastic Processes.', 'professional_function_catalog.md'), + ('stochasticProcessesConstructTransitionMatrix', 'Stochastic Processes', '(*args)', 'Construct a transition matrix from explicit inputs for Stochastic Processes.', 'professional_function_catalog.md'), + ('stochasticProcessesDecomposeHittingEvent', 'Stochastic Processes', '(value)', 'Decompose a hitting event into simpler or canonical components.', 'professional_function_catalog.md'), + ('stochasticProcessesDecomposeMartingaleCandidate', 'Stochastic Processes', '(value)', 'Decompose a martingale candidate into simpler or canonical components.', 'professional_function_catalog.md'), + ('stochasticProcessesDecomposeRandomProcess', 'Stochastic Processes', '(value)', 'Decompose a random process into simpler or canonical components.', 'professional_function_catalog.md'), + ('stochasticProcessesDecomposeStateDistribution', 'Stochastic Processes', '(value)', 'Decompose a state distribution into simpler or canonical components.', 'professional_function_catalog.md'), + ('stochasticProcessesDecomposeTransitionMatrix', 'Stochastic Processes', '(value)', 'Decompose a transition matrix into simpler or canonical components.', 'professional_function_catalog.md'), + ('stochasticProcessesDocumentHittingEvent', 'Stochastic Processes', '(value)', 'Return a structured explanation of a hitting event and related assumptions.', 'professional_function_catalog.md'), + ('stochasticProcessesDocumentMartingaleCandidate', 'Stochastic Processes', '(value)', 'Return a structured explanation of a martingale candidate and related assumptions.', 'professional_function_catalog.md'), + ('stochasticProcessesDocumentRandomProcess', 'Stochastic Processes', '(value)', 'Return a structured explanation of a random process and related assumptions.', 'professional_function_catalog.md'), + ('stochasticProcessesDocumentStateDistribution', 'Stochastic Processes', '(value)', 'Return a structured explanation of a state distribution and related assumptions.', 'professional_function_catalog.md'), + ('stochasticProcessesDocumentTransitionMatrix', 'Stochastic Processes', '(value)', 'Return a structured explanation of a transition matrix and related assumptions.', 'professional_function_catalog.md'), + ('stochasticProcessesEnumerateHittingEvent', 'Stochastic Processes', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a hitting event.', 'professional_function_catalog.md'), + ('stochasticProcessesEnumerateMartingaleCandidate', 'Stochastic Processes', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a martingale candidate.', 'professional_function_catalog.md'), + ('stochasticProcessesEnumerateRandomProcess', 'Stochastic Processes', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a random process.', 'professional_function_catalog.md'), + ('stochasticProcessesEnumerateStateDistribution', 'Stochastic Processes', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a state distribution.', 'professional_function_catalog.md'), + ('stochasticProcessesEnumerateTransitionMatrix', 'Stochastic Processes', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a transition matrix.', 'professional_function_catalog.md'), + ('stochasticProcessesEstimateHittingEvent', 'Stochastic Processes', '(value, samples=None)', 'Estimate a hitting event property from finite samples or approximations.', 'professional_function_catalog.md'), + ('stochasticProcessesEstimateMartingaleCandidate', 'Stochastic Processes', '(value, samples=None)', 'Estimate a martingale candidate property from finite samples or approximations.', 'professional_function_catalog.md'), + ('stochasticProcessesEstimateRandomProcess', 'Stochastic Processes', '(value, samples=None)', 'Estimate a random process property from finite samples or approximations.', 'professional_function_catalog.md'), + ('stochasticProcessesEstimateStateDistribution', 'Stochastic Processes', '(value, samples=None)', 'Estimate a state distribution property from finite samples or approximations.', 'professional_function_catalog.md'), + ('stochasticProcessesEstimateTransitionMatrix', 'Stochastic Processes', '(value, samples=None)', 'Estimate a transition matrix property from finite samples or approximations.', 'professional_function_catalog.md'), + ('stochasticProcessesEvaluateHittingEvent', 'Stochastic Processes', '(value, point=None)', 'Evaluate a hitting event at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('stochasticProcessesEvaluateMartingaleCandidate', 'Stochastic Processes', '(value, point=None)', 'Evaluate a martingale candidate at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('stochasticProcessesEvaluateRandomProcess', 'Stochastic Processes', '(value, point=None)', 'Evaluate a random process at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('stochasticProcessesEvaluateStateDistribution', 'Stochastic Processes', '(value, point=None)', 'Evaluate a state distribution at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('stochasticProcessesEvaluateTransitionMatrix', 'Stochastic Processes', '(value, point=None)', 'Evaluate a transition matrix at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('stochasticProcessesFormatHittingEvent', 'Stochastic Processes', '(value)', 'Format a hitting event for deterministic user-facing output.', 'professional_function_catalog.md'), + ('stochasticProcessesFormatMartingaleCandidate', 'Stochastic Processes', '(value)', 'Format a martingale candidate for deterministic user-facing output.', 'professional_function_catalog.md'), + ('stochasticProcessesFormatRandomProcess', 'Stochastic Processes', '(value)', 'Format a random process for deterministic user-facing output.', 'professional_function_catalog.md'), + ('stochasticProcessesFormatStateDistribution', 'Stochastic Processes', '(value)', 'Format a state distribution for deterministic user-facing output.', 'professional_function_catalog.md'), + ('stochasticProcessesFormatTransitionMatrix', 'Stochastic Processes', '(value)', 'Format a transition matrix for deterministic user-facing output.', 'professional_function_catalog.md'), + ('stochasticProcessesGenerateExampleHittingEvent', 'Stochastic Processes', '(size=3)', 'Generate a small documented example of a hitting event.', 'professional_function_catalog.md'), + ('stochasticProcessesGenerateExampleMartingaleCandidate', 'Stochastic Processes', '(size=3)', 'Generate a small documented example of a martingale candidate.', 'professional_function_catalog.md'), + ('stochasticProcessesGenerateExampleRandomProcess', 'Stochastic Processes', '(size=3)', 'Generate a small documented example of a random process.', 'professional_function_catalog.md'), + ('stochasticProcessesGenerateExampleStateDistribution', 'Stochastic Processes', '(size=3)', 'Generate a small documented example of a state distribution.', 'professional_function_catalog.md'), + ('stochasticProcessesGenerateExampleTransitionMatrix', 'Stochastic Processes', '(size=3)', 'Generate a small documented example of a transition matrix.', 'professional_function_catalog.md'), + ('stochasticProcessesNormalizeHittingEvent', 'Stochastic Processes', '(value)', 'Normalize a hitting event into the standard Stochastic Processes representation.', 'professional_function_catalog.md'), + ('stochasticProcessesNormalizeMartingaleCandidate', 'Stochastic Processes', '(value)', 'Normalize a martingale candidate into the standard Stochastic Processes representation.', 'professional_function_catalog.md'), + ('stochasticProcessesNormalizeRandomProcess', 'Stochastic Processes', '(value)', 'Normalize a random process into the standard Stochastic Processes representation.', 'professional_function_catalog.md'), + ('stochasticProcessesNormalizeStateDistribution', 'Stochastic Processes', '(value)', 'Normalize a state distribution into the standard Stochastic Processes representation.', 'professional_function_catalog.md'), + ('stochasticProcessesNormalizeTransitionMatrix', 'Stochastic Processes', '(value)', 'Normalize a transition matrix into the standard Stochastic Processes representation.', 'professional_function_catalog.md'), + ('stochasticProcessesParseHittingEvent', 'Stochastic Processes', '(text)', 'Parse a text or structured value into a hitting event.', 'professional_function_catalog.md'), + ('stochasticProcessesParseMartingaleCandidate', 'Stochastic Processes', '(text)', 'Parse a text or structured value into a martingale candidate.', 'professional_function_catalog.md'), + ('stochasticProcessesParseRandomProcess', 'Stochastic Processes', '(text)', 'Parse a text or structured value into a random process.', 'professional_function_catalog.md'), + ('stochasticProcessesParseStateDistribution', 'Stochastic Processes', '(text)', 'Parse a text or structured value into a state distribution.', 'professional_function_catalog.md'), + ('stochasticProcessesParseTransitionMatrix', 'Stochastic Processes', '(text)', 'Parse a text or structured value into a transition matrix.', 'professional_function_catalog.md'), + ('stochasticProcessesSimplifyHittingEvent', 'Stochastic Processes', '(value)', 'Simplify a hitting event without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('stochasticProcessesSimplifyMartingaleCandidate', 'Stochastic Processes', '(value)', 'Simplify a martingale candidate without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('stochasticProcessesSimplifyRandomProcess', 'Stochastic Processes', '(value)', 'Simplify a random process without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('stochasticProcessesSimplifyStateDistribution', 'Stochastic Processes', '(value)', 'Simplify a state distribution without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('stochasticProcessesSimplifyTransitionMatrix', 'Stochastic Processes', '(value)', 'Simplify a transition matrix without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('stochasticProcessesTestEquivalenceHittingEvent', 'Stochastic Processes', '(left, right)', 'Test whether two hitting event values are equivalent in Stochastic Processes.', 'professional_function_catalog.md'), + ('stochasticProcessesTestEquivalenceMartingaleCandidate', 'Stochastic Processes', '(left, right)', 'Test whether two martingale candidate values are equivalent in Stochastic Processes.', 'professional_function_catalog.md'), + ('stochasticProcessesTestEquivalenceRandomProcess', 'Stochastic Processes', '(left, right)', 'Test whether two random process values are equivalent in Stochastic Processes.', 'professional_function_catalog.md'), + ('stochasticProcessesTestEquivalenceStateDistribution', 'Stochastic Processes', '(left, right)', 'Test whether two state distribution values are equivalent in Stochastic Processes.', 'professional_function_catalog.md'), + ('stochasticProcessesTestEquivalenceTransitionMatrix', 'Stochastic Processes', '(left, right)', 'Test whether two transition matrix values are equivalent in Stochastic Processes.', 'professional_function_catalog.md'), + ('stochasticProcessesTransformHittingEvent', 'Stochastic Processes', '(value, mapping)', 'Transform a hitting event through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('stochasticProcessesTransformMartingaleCandidate', 'Stochastic Processes', '(value, mapping)', 'Transform a martingale candidate through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('stochasticProcessesTransformRandomProcess', 'Stochastic Processes', '(value, mapping)', 'Transform a random process through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('stochasticProcessesTransformStateDistribution', 'Stochastic Processes', '(value, mapping)', 'Transform a state distribution through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('stochasticProcessesTransformTransitionMatrix', 'Stochastic Processes', '(value, mapping)', 'Transform a transition matrix through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('stochasticProcessesValidateHittingEvent', 'Stochastic Processes', '(value)', 'Validate the hitting event representation and domain rules for Stochastic Processes.', 'professional_function_catalog.md'), + ('stochasticProcessesValidateMartingaleCandidate', 'Stochastic Processes', '(value)', 'Validate the martingale candidate representation and domain rules for Stochastic Processes.', 'professional_function_catalog.md'), + ('stochasticProcessesValidateRandomProcess', 'Stochastic Processes', '(value)', 'Validate the random process representation and domain rules for Stochastic Processes.', 'professional_function_catalog.md'), + ('stochasticProcessesValidateStateDistribution', 'Stochastic Processes', '(value)', 'Validate the state distribution representation and domain rules for Stochastic Processes.', 'professional_function_catalog.md'), + ('stochasticProcessesValidateTransitionMatrix', 'Stochastic Processes', '(value)', 'Validate the transition matrix representation and domain rules for Stochastic Processes.', 'professional_function_catalog.md'), + ('autocorrelation', 'Time Series Analysis', '(values, lag)', 'Planned roadmap function for Time Series Analysis from upcoming.md.', 'upcoming.md'), + ('autocovariance', 'Time Series Analysis', '(values, lag)', 'Planned roadmap function for Time Series Analysis from upcoming.md.', 'upcoming.md'), + ('detectTrend', 'Time Series Analysis', '(values)', 'Planned roadmap function for Time Series Analysis from upcoming.md.', 'upcoming.md'), + ('differenceSeries', 'Time Series Analysis', '(values, order=1)', 'Planned roadmap function for Time Series Analysis from upcoming.md.', 'upcoming.md'), + ('exponentialSmoothing', 'Time Series Analysis', '(values, alpha)', 'Planned roadmap function for Time Series Analysis from upcoming.md.', 'upcoming.md'), + ('lag', 'Time Series Analysis', '(values, k)', 'Planned roadmap function for Time Series Analysis from upcoming.md.', 'upcoming.md'), + ('movingAverage', 'Time Series Analysis', '(values, window)', 'Planned roadmap function for Time Series Analysis from upcoming.md.', 'upcoming.md'), + ('seasonalIndices', 'Time Series Analysis', '(values, period)', 'Planned roadmap function for Time Series Analysis from upcoming.md.', 'upcoming.md'), + ('timeSeriesAnalysisApproximateForecastModel', 'Time Series Analysis', '(value, tolerance=1e-9)', 'Approximate a forecast model with explicit tolerance controls.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisApproximateLagStructure', 'Time Series Analysis', '(value, tolerance=1e-9)', 'Approximate a lag structure with explicit tolerance controls.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisApproximateSeasonalProfile', 'Time Series Analysis', '(value, tolerance=1e-9)', 'Approximate a seasonal profile with explicit tolerance controls.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisApproximateTimeSeries', 'Time Series Analysis', '(value, tolerance=1e-9)', 'Approximate a time series with explicit tolerance controls.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisApproximateTrendModel', 'Time Series Analysis', '(value, tolerance=1e-9)', 'Approximate a trend model with explicit tolerance controls.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisCanonicalizeForecastModel', 'Time Series Analysis', '(value)', 'Canonicalize a forecast model so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisCanonicalizeLagStructure', 'Time Series Analysis', '(value)', 'Canonicalize a lag structure so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisCanonicalizeSeasonalProfile', 'Time Series Analysis', '(value)', 'Canonicalize a seasonal profile so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisCanonicalizeTimeSeries', 'Time Series Analysis', '(value)', 'Canonicalize a time series so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisCanonicalizeTrendModel', 'Time Series Analysis', '(value)', 'Canonicalize a trend model so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisClassifyForecastModel', 'Time Series Analysis', '(value)', 'Classify a forecast model by its standard Time Series Analysis invariants.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisClassifyLagStructure', 'Time Series Analysis', '(value)', 'Classify a lag structure by its standard Time Series Analysis invariants.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisClassifySeasonalProfile', 'Time Series Analysis', '(value)', 'Classify a seasonal profile by its standard Time Series Analysis invariants.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisClassifyTimeSeries', 'Time Series Analysis', '(value)', 'Classify a time series by its standard Time Series Analysis invariants.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisClassifyTrendModel', 'Time Series Analysis', '(value)', 'Classify a trend model by its standard Time Series Analysis invariants.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisCombineForecastModel', 'Time Series Analysis', '(left, right)', 'Combine two forecast model values with the natural operation for Time Series Analysis.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisCombineLagStructure', 'Time Series Analysis', '(left, right)', 'Combine two lag structure values with the natural operation for Time Series Analysis.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisCombineSeasonalProfile', 'Time Series Analysis', '(left, right)', 'Combine two seasonal profile values with the natural operation for Time Series Analysis.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisCombineTimeSeries', 'Time Series Analysis', '(left, right)', 'Combine two time series values with the natural operation for Time Series Analysis.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisCombineTrendModel', 'Time Series Analysis', '(left, right)', 'Combine two trend model values with the natural operation for Time Series Analysis.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisCompareForecastModel', 'Time Series Analysis', '(left, right)', 'Compare two forecast model values under the conventions of Time Series Analysis.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisCompareLagStructure', 'Time Series Analysis', '(left, right)', 'Compare two lag structure values under the conventions of Time Series Analysis.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisCompareSeasonalProfile', 'Time Series Analysis', '(left, right)', 'Compare two seasonal profile values under the conventions of Time Series Analysis.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisCompareTimeSeries', 'Time Series Analysis', '(left, right)', 'Compare two time series values under the conventions of Time Series Analysis.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisCompareTrendModel', 'Time Series Analysis', '(left, right)', 'Compare two trend model values under the conventions of Time Series Analysis.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisComputeForecastModel', 'Time Series Analysis', '(value)', 'Compute the central numerical or symbolic data of a forecast model.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisComputeLagStructure', 'Time Series Analysis', '(value)', 'Compute the central numerical or symbolic data of a lag structure.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisComputeSeasonalProfile', 'Time Series Analysis', '(value)', 'Compute the central numerical or symbolic data of a seasonal profile.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisComputeTimeSeries', 'Time Series Analysis', '(value)', 'Compute the central numerical or symbolic data of a time series.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisComputeTrendModel', 'Time Series Analysis', '(value)', 'Compute the central numerical or symbolic data of a trend model.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisConstructForecastModel', 'Time Series Analysis', '(*args)', 'Construct a forecast model from explicit inputs for Time Series Analysis.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisConstructLagStructure', 'Time Series Analysis', '(*args)', 'Construct a lag structure from explicit inputs for Time Series Analysis.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisConstructSeasonalProfile', 'Time Series Analysis', '(*args)', 'Construct a seasonal profile from explicit inputs for Time Series Analysis.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisConstructTimeSeries', 'Time Series Analysis', '(*args)', 'Construct a time series from explicit inputs for Time Series Analysis.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisConstructTrendModel', 'Time Series Analysis', '(*args)', 'Construct a trend model from explicit inputs for Time Series Analysis.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisDecomposeForecastModel', 'Time Series Analysis', '(value)', 'Decompose a forecast model into simpler or canonical components.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisDecomposeLagStructure', 'Time Series Analysis', '(value)', 'Decompose a lag structure into simpler or canonical components.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisDecomposeSeasonalProfile', 'Time Series Analysis', '(value)', 'Decompose a seasonal profile into simpler or canonical components.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisDecomposeTimeSeries', 'Time Series Analysis', '(value)', 'Decompose a time series into simpler or canonical components.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisDecomposeTrendModel', 'Time Series Analysis', '(value)', 'Decompose a trend model into simpler or canonical components.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisDocumentForecastModel', 'Time Series Analysis', '(value)', 'Return a structured explanation of a forecast model and related assumptions.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisDocumentLagStructure', 'Time Series Analysis', '(value)', 'Return a structured explanation of a lag structure and related assumptions.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisDocumentSeasonalProfile', 'Time Series Analysis', '(value)', 'Return a structured explanation of a seasonal profile and related assumptions.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisDocumentTimeSeries', 'Time Series Analysis', '(value)', 'Return a structured explanation of a time series and related assumptions.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisDocumentTrendModel', 'Time Series Analysis', '(value)', 'Return a structured explanation of a trend model and related assumptions.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisEnumerateForecastModel', 'Time Series Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a forecast model.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisEnumerateLagStructure', 'Time Series Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a lag structure.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisEnumerateSeasonalProfile', 'Time Series Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a seasonal profile.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisEnumerateTimeSeries', 'Time Series Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a time series.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisEnumerateTrendModel', 'Time Series Analysis', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a trend model.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisEstimateForecastModel', 'Time Series Analysis', '(value, samples=None)', 'Estimate a forecast model property from finite samples or approximations.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisEstimateLagStructure', 'Time Series Analysis', '(value, samples=None)', 'Estimate a lag structure property from finite samples or approximations.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisEstimateSeasonalProfile', 'Time Series Analysis', '(value, samples=None)', 'Estimate a seasonal profile property from finite samples or approximations.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisEstimateTimeSeries', 'Time Series Analysis', '(value, samples=None)', 'Estimate a time series property from finite samples or approximations.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisEstimateTrendModel', 'Time Series Analysis', '(value, samples=None)', 'Estimate a trend model property from finite samples or approximations.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisEvaluateForecastModel', 'Time Series Analysis', '(value, point=None)', 'Evaluate a forecast model at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisEvaluateLagStructure', 'Time Series Analysis', '(value, point=None)', 'Evaluate a lag structure at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisEvaluateSeasonalProfile', 'Time Series Analysis', '(value, point=None)', 'Evaluate a seasonal profile at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisEvaluateTimeSeries', 'Time Series Analysis', '(value, point=None)', 'Evaluate a time series at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisEvaluateTrendModel', 'Time Series Analysis', '(value, point=None)', 'Evaluate a trend model at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisFormatForecastModel', 'Time Series Analysis', '(value)', 'Format a forecast model for deterministic user-facing output.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisFormatLagStructure', 'Time Series Analysis', '(value)', 'Format a lag structure for deterministic user-facing output.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisFormatSeasonalProfile', 'Time Series Analysis', '(value)', 'Format a seasonal profile for deterministic user-facing output.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisFormatTimeSeries', 'Time Series Analysis', '(value)', 'Format a time series for deterministic user-facing output.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisFormatTrendModel', 'Time Series Analysis', '(value)', 'Format a trend model for deterministic user-facing output.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisGenerateExampleForecastModel', 'Time Series Analysis', '(size=3)', 'Generate a small documented example of a forecast model.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisGenerateExampleLagStructure', 'Time Series Analysis', '(size=3)', 'Generate a small documented example of a lag structure.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisGenerateExampleSeasonalProfile', 'Time Series Analysis', '(size=3)', 'Generate a small documented example of a seasonal profile.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisGenerateExampleTimeSeries', 'Time Series Analysis', '(size=3)', 'Generate a small documented example of a time series.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisGenerateExampleTrendModel', 'Time Series Analysis', '(size=3)', 'Generate a small documented example of a trend model.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisNormalizeForecastModel', 'Time Series Analysis', '(value)', 'Normalize a forecast model into the standard Time Series Analysis representation.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisNormalizeLagStructure', 'Time Series Analysis', '(value)', 'Normalize a lag structure into the standard Time Series Analysis representation.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisNormalizeSeasonalProfile', 'Time Series Analysis', '(value)', 'Normalize a seasonal profile into the standard Time Series Analysis representation.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisNormalizeTimeSeries', 'Time Series Analysis', '(value)', 'Normalize a time series into the standard Time Series Analysis representation.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisNormalizeTrendModel', 'Time Series Analysis', '(value)', 'Normalize a trend model into the standard Time Series Analysis representation.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisParseForecastModel', 'Time Series Analysis', '(text)', 'Parse a text or structured value into a forecast model.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisParseLagStructure', 'Time Series Analysis', '(text)', 'Parse a text or structured value into a lag structure.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisParseSeasonalProfile', 'Time Series Analysis', '(text)', 'Parse a text or structured value into a seasonal profile.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisParseTimeSeries', 'Time Series Analysis', '(text)', 'Parse a text or structured value into a time series.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisParseTrendModel', 'Time Series Analysis', '(text)', 'Parse a text or structured value into a trend model.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisSimplifyForecastModel', 'Time Series Analysis', '(value)', 'Simplify a forecast model without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisSimplifyLagStructure', 'Time Series Analysis', '(value)', 'Simplify a lag structure without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisSimplifySeasonalProfile', 'Time Series Analysis', '(value)', 'Simplify a seasonal profile without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisSimplifyTimeSeries', 'Time Series Analysis', '(value)', 'Simplify a time series without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisSimplifyTrendModel', 'Time Series Analysis', '(value)', 'Simplify a trend model without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisTestEquivalenceForecastModel', 'Time Series Analysis', '(left, right)', 'Test whether two forecast model values are equivalent in Time Series Analysis.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisTestEquivalenceLagStructure', 'Time Series Analysis', '(left, right)', 'Test whether two lag structure values are equivalent in Time Series Analysis.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisTestEquivalenceSeasonalProfile', 'Time Series Analysis', '(left, right)', 'Test whether two seasonal profile values are equivalent in Time Series Analysis.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisTestEquivalenceTimeSeries', 'Time Series Analysis', '(left, right)', 'Test whether two time series values are equivalent in Time Series Analysis.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisTestEquivalenceTrendModel', 'Time Series Analysis', '(left, right)', 'Test whether two trend model values are equivalent in Time Series Analysis.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisTransformForecastModel', 'Time Series Analysis', '(value, mapping)', 'Transform a forecast model through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisTransformLagStructure', 'Time Series Analysis', '(value, mapping)', 'Transform a lag structure through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisTransformSeasonalProfile', 'Time Series Analysis', '(value, mapping)', 'Transform a seasonal profile through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisTransformTimeSeries', 'Time Series Analysis', '(value, mapping)', 'Transform a time series through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisTransformTrendModel', 'Time Series Analysis', '(value, mapping)', 'Transform a trend model through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisValidateForecastModel', 'Time Series Analysis', '(value)', 'Validate the forecast model representation and domain rules for Time Series Analysis.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisValidateLagStructure', 'Time Series Analysis', '(value)', 'Validate the lag structure representation and domain rules for Time Series Analysis.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisValidateSeasonalProfile', 'Time Series Analysis', '(value)', 'Validate the seasonal profile representation and domain rules for Time Series Analysis.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisValidateTimeSeries', 'Time Series Analysis', '(value)', 'Validate the time series representation and domain rules for Time Series Analysis.', 'professional_function_catalog.md'), + ('timeSeriesAnalysisValidateTrendModel', 'Time Series Analysis', '(value)', 'Validate the trend model representation and domain rules for Time Series Analysis.', 'professional_function_catalog.md'), + ('boundary', 'Topology', '(set, topology, universalSet)', 'Planned roadmap function for Topology from upcoming.md.', 'upcoming.md'), + ('closure', 'Topology', '(set, topology, universalSet)', 'Planned roadmap function for Topology from upcoming.md.', 'upcoming.md'), + ('connectedComponents', 'Topology', '(points, adjacency)', 'Planned roadmap function for Topology from upcoming.md.', 'upcoming.md'), + ('interior', 'Topology', '(set, topology)', 'Planned roadmap function for Topology from upcoming.md.', 'upcoming.md'), + ('isClosedSet', 'Topology', '(set, topology, universalSet)', 'Planned roadmap function for Topology from upcoming.md.', 'upcoming.md'), + ('isCompactFinite', 'Topology', '(set, topology)', 'Planned roadmap function for Topology from upcoming.md.', 'upcoming.md'), + ('isConnected', 'Topology', '(points, adjacency)', 'Planned roadmap function for Topology from upcoming.md.', 'upcoming.md'), + ('isContinuousMap', 'Topology', '(f, domainTopology, codomainTopology)', 'Planned roadmap function for Topology from upcoming.md.', 'upcoming.md'), + ('isHomeomorphism', 'Topology', '(f, inverse, domainTopology, codomainTopology)', 'Planned roadmap function for Topology from upcoming.md.', 'upcoming.md'), + ('isTopology', 'Topology', '(collection, universalSet)', 'Planned roadmap function for Topology from upcoming.md.', 'upcoming.md'), + ('topologyApproximateClosedSet', 'Topology', '(value, tolerance=1e-9)', 'Approximate a closed set with explicit tolerance controls.', 'professional_function_catalog.md'), + ('topologyApproximateContinuousMap', 'Topology', '(value, tolerance=1e-9)', 'Approximate a continuous map with explicit tolerance controls.', 'professional_function_catalog.md'), + ('topologyApproximateFiniteCover', 'Topology', '(value, tolerance=1e-9)', 'Approximate a finite cover with explicit tolerance controls.', 'professional_function_catalog.md'), + ('topologyApproximateOpenSet', 'Topology', '(value, tolerance=1e-9)', 'Approximate a open set with explicit tolerance controls.', 'professional_function_catalog.md'), + ('topologyApproximateTopologicalSpace', 'Topology', '(value, tolerance=1e-9)', 'Approximate a topological space with explicit tolerance controls.', 'professional_function_catalog.md'), + ('topologyCanonicalizeClosedSet', 'Topology', '(value)', 'Canonicalize a closed set so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('topologyCanonicalizeContinuousMap', 'Topology', '(value)', 'Canonicalize a continuous map so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('topologyCanonicalizeFiniteCover', 'Topology', '(value)', 'Canonicalize a finite cover so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('topologyCanonicalizeOpenSet', 'Topology', '(value)', 'Canonicalize a open set so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('topologyCanonicalizeTopologicalSpace', 'Topology', '(value)', 'Canonicalize a topological space so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('topologyClassifyClosedSet', 'Topology', '(value)', 'Classify a closed set by its standard Topology invariants.', 'professional_function_catalog.md'), + ('topologyClassifyContinuousMap', 'Topology', '(value)', 'Classify a continuous map by its standard Topology invariants.', 'professional_function_catalog.md'), + ('topologyClassifyFiniteCover', 'Topology', '(value)', 'Classify a finite cover by its standard Topology invariants.', 'professional_function_catalog.md'), + ('topologyClassifyOpenSet', 'Topology', '(value)', 'Classify a open set by its standard Topology invariants.', 'professional_function_catalog.md'), + ('topologyClassifyTopologicalSpace', 'Topology', '(value)', 'Classify a topological space by its standard Topology invariants.', 'professional_function_catalog.md'), + ('topologyCombineClosedSet', 'Topology', '(left, right)', 'Combine two closed set values with the natural operation for Topology.', 'professional_function_catalog.md'), + ('topologyCombineContinuousMap', 'Topology', '(left, right)', 'Combine two continuous map values with the natural operation for Topology.', 'professional_function_catalog.md'), + ('topologyCombineFiniteCover', 'Topology', '(left, right)', 'Combine two finite cover values with the natural operation for Topology.', 'professional_function_catalog.md'), + ('topologyCombineOpenSet', 'Topology', '(left, right)', 'Combine two open set values with the natural operation for Topology.', 'professional_function_catalog.md'), + ('topologyCombineTopologicalSpace', 'Topology', '(left, right)', 'Combine two topological space values with the natural operation for Topology.', 'professional_function_catalog.md'), + ('topologyCompareClosedSet', 'Topology', '(left, right)', 'Compare two closed set values under the conventions of Topology.', 'professional_function_catalog.md'), + ('topologyCompareContinuousMap', 'Topology', '(left, right)', 'Compare two continuous map values under the conventions of Topology.', 'professional_function_catalog.md'), + ('topologyCompareFiniteCover', 'Topology', '(left, right)', 'Compare two finite cover values under the conventions of Topology.', 'professional_function_catalog.md'), + ('topologyCompareOpenSet', 'Topology', '(left, right)', 'Compare two open set values under the conventions of Topology.', 'professional_function_catalog.md'), + ('topologyCompareTopologicalSpace', 'Topology', '(left, right)', 'Compare two topological space values under the conventions of Topology.', 'professional_function_catalog.md'), + ('topologyComputeClosedSet', 'Topology', '(value)', 'Compute the central numerical or symbolic data of a closed set.', 'professional_function_catalog.md'), + ('topologyComputeContinuousMap', 'Topology', '(value)', 'Compute the central numerical or symbolic data of a continuous map.', 'professional_function_catalog.md'), + ('topologyComputeFiniteCover', 'Topology', '(value)', 'Compute the central numerical or symbolic data of a finite cover.', 'professional_function_catalog.md'), + ('topologyComputeOpenSet', 'Topology', '(value)', 'Compute the central numerical or symbolic data of a open set.', 'professional_function_catalog.md'), + ('topologyComputeTopologicalSpace', 'Topology', '(value)', 'Compute the central numerical or symbolic data of a topological space.', 'professional_function_catalog.md'), + ('topologyConstructClosedSet', 'Topology', '(*args)', 'Construct a closed set from explicit inputs for Topology.', 'professional_function_catalog.md'), + ('topologyConstructContinuousMap', 'Topology', '(*args)', 'Construct a continuous map from explicit inputs for Topology.', 'professional_function_catalog.md'), + ('topologyConstructFiniteCover', 'Topology', '(*args)', 'Construct a finite cover from explicit inputs for Topology.', 'professional_function_catalog.md'), + ('topologyConstructOpenSet', 'Topology', '(*args)', 'Construct a open set from explicit inputs for Topology.', 'professional_function_catalog.md'), + ('topologyConstructTopologicalSpace', 'Topology', '(*args)', 'Construct a topological space from explicit inputs for Topology.', 'professional_function_catalog.md'), + ('topologyDecomposeClosedSet', 'Topology', '(value)', 'Decompose a closed set into simpler or canonical components.', 'professional_function_catalog.md'), + ('topologyDecomposeContinuousMap', 'Topology', '(value)', 'Decompose a continuous map into simpler or canonical components.', 'professional_function_catalog.md'), + ('topologyDecomposeFiniteCover', 'Topology', '(value)', 'Decompose a finite cover into simpler or canonical components.', 'professional_function_catalog.md'), + ('topologyDecomposeOpenSet', 'Topology', '(value)', 'Decompose a open set into simpler or canonical components.', 'professional_function_catalog.md'), + ('topologyDecomposeTopologicalSpace', 'Topology', '(value)', 'Decompose a topological space into simpler or canonical components.', 'professional_function_catalog.md'), + ('topologyDocumentClosedSet', 'Topology', '(value)', 'Return a structured explanation of a closed set and related assumptions.', 'professional_function_catalog.md'), + ('topologyDocumentContinuousMap', 'Topology', '(value)', 'Return a structured explanation of a continuous map and related assumptions.', 'professional_function_catalog.md'), + ('topologyDocumentFiniteCover', 'Topology', '(value)', 'Return a structured explanation of a finite cover and related assumptions.', 'professional_function_catalog.md'), + ('topologyDocumentOpenSet', 'Topology', '(value)', 'Return a structured explanation of a open set and related assumptions.', 'professional_function_catalog.md'), + ('topologyDocumentTopologicalSpace', 'Topology', '(value)', 'Return a structured explanation of a topological space and related assumptions.', 'professional_function_catalog.md'), + ('topologyEnumerateClosedSet', 'Topology', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a closed set.', 'professional_function_catalog.md'), + ('topologyEnumerateContinuousMap', 'Topology', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a continuous map.', 'professional_function_catalog.md'), + ('topologyEnumerateFiniteCover', 'Topology', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a finite cover.', 'professional_function_catalog.md'), + ('topologyEnumerateOpenSet', 'Topology', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a open set.', 'professional_function_catalog.md'), + ('topologyEnumerateTopologicalSpace', 'Topology', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a topological space.', 'professional_function_catalog.md'), + ('topologyEstimateClosedSet', 'Topology', '(value, samples=None)', 'Estimate a closed set property from finite samples or approximations.', 'professional_function_catalog.md'), + ('topologyEstimateContinuousMap', 'Topology', '(value, samples=None)', 'Estimate a continuous map property from finite samples or approximations.', 'professional_function_catalog.md'), + ('topologyEstimateFiniteCover', 'Topology', '(value, samples=None)', 'Estimate a finite cover property from finite samples or approximations.', 'professional_function_catalog.md'), + ('topologyEstimateOpenSet', 'Topology', '(value, samples=None)', 'Estimate a open set property from finite samples or approximations.', 'professional_function_catalog.md'), + ('topologyEstimateTopologicalSpace', 'Topology', '(value, samples=None)', 'Estimate a topological space property from finite samples or approximations.', 'professional_function_catalog.md'), + ('topologyEvaluateClosedSet', 'Topology', '(value, point=None)', 'Evaluate a closed set at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('topologyEvaluateContinuousMap', 'Topology', '(value, point=None)', 'Evaluate a continuous map at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('topologyEvaluateFiniteCover', 'Topology', '(value, point=None)', 'Evaluate a finite cover at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('topologyEvaluateOpenSet', 'Topology', '(value, point=None)', 'Evaluate a open set at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('topologyEvaluateTopologicalSpace', 'Topology', '(value, point=None)', 'Evaluate a topological space at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('topologyFormatClosedSet', 'Topology', '(value)', 'Format a closed set for deterministic user-facing output.', 'professional_function_catalog.md'), + ('topologyFormatContinuousMap', 'Topology', '(value)', 'Format a continuous map for deterministic user-facing output.', 'professional_function_catalog.md'), + ('topologyFormatFiniteCover', 'Topology', '(value)', 'Format a finite cover for deterministic user-facing output.', 'professional_function_catalog.md'), + ('topologyFormatOpenSet', 'Topology', '(value)', 'Format a open set for deterministic user-facing output.', 'professional_function_catalog.md'), + ('topologyFormatTopologicalSpace', 'Topology', '(value)', 'Format a topological space for deterministic user-facing output.', 'professional_function_catalog.md'), + ('topologyGenerateExampleClosedSet', 'Topology', '(size=3)', 'Generate a small documented example of a closed set.', 'professional_function_catalog.md'), + ('topologyGenerateExampleContinuousMap', 'Topology', '(size=3)', 'Generate a small documented example of a continuous map.', 'professional_function_catalog.md'), + ('topologyGenerateExampleFiniteCover', 'Topology', '(size=3)', 'Generate a small documented example of a finite cover.', 'professional_function_catalog.md'), + ('topologyGenerateExampleOpenSet', 'Topology', '(size=3)', 'Generate a small documented example of a open set.', 'professional_function_catalog.md'), + ('topologyGenerateExampleTopologicalSpace', 'Topology', '(size=3)', 'Generate a small documented example of a topological space.', 'professional_function_catalog.md'), + ('topologyNormalizeClosedSet', 'Topology', '(value)', 'Normalize a closed set into the standard Topology representation.', 'professional_function_catalog.md'), + ('topologyNormalizeContinuousMap', 'Topology', '(value)', 'Normalize a continuous map into the standard Topology representation.', 'professional_function_catalog.md'), + ('topologyNormalizeFiniteCover', 'Topology', '(value)', 'Normalize a finite cover into the standard Topology representation.', 'professional_function_catalog.md'), + ('topologyNormalizeOpenSet', 'Topology', '(value)', 'Normalize a open set into the standard Topology representation.', 'professional_function_catalog.md'), + ('topologyNormalizeTopologicalSpace', 'Topology', '(value)', 'Normalize a topological space into the standard Topology representation.', 'professional_function_catalog.md'), + ('topologyParseClosedSet', 'Topology', '(text)', 'Parse a text or structured value into a closed set.', 'professional_function_catalog.md'), + ('topologyParseContinuousMap', 'Topology', '(text)', 'Parse a text or structured value into a continuous map.', 'professional_function_catalog.md'), + ('topologyParseFiniteCover', 'Topology', '(text)', 'Parse a text or structured value into a finite cover.', 'professional_function_catalog.md'), + ('topologyParseOpenSet', 'Topology', '(text)', 'Parse a text or structured value into a open set.', 'professional_function_catalog.md'), + ('topologyParseTopologicalSpace', 'Topology', '(text)', 'Parse a text or structured value into a topological space.', 'professional_function_catalog.md'), + ('topologySimplifyClosedSet', 'Topology', '(value)', 'Simplify a closed set without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('topologySimplifyContinuousMap', 'Topology', '(value)', 'Simplify a continuous map without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('topologySimplifyFiniteCover', 'Topology', '(value)', 'Simplify a finite cover without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('topologySimplifyOpenSet', 'Topology', '(value)', 'Simplify a open set without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('topologySimplifyTopologicalSpace', 'Topology', '(value)', 'Simplify a topological space without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('topologyTestEquivalenceClosedSet', 'Topology', '(left, right)', 'Test whether two closed set values are equivalent in Topology.', 'professional_function_catalog.md'), + ('topologyTestEquivalenceContinuousMap', 'Topology', '(left, right)', 'Test whether two continuous map values are equivalent in Topology.', 'professional_function_catalog.md'), + ('topologyTestEquivalenceFiniteCover', 'Topology', '(left, right)', 'Test whether two finite cover values are equivalent in Topology.', 'professional_function_catalog.md'), + ('topologyTestEquivalenceOpenSet', 'Topology', '(left, right)', 'Test whether two open set values are equivalent in Topology.', 'professional_function_catalog.md'), + ('topologyTestEquivalenceTopologicalSpace', 'Topology', '(left, right)', 'Test whether two topological space values are equivalent in Topology.', 'professional_function_catalog.md'), + ('topologyTransformClosedSet', 'Topology', '(value, mapping)', 'Transform a closed set through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('topologyTransformContinuousMap', 'Topology', '(value, mapping)', 'Transform a continuous map through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('topologyTransformFiniteCover', 'Topology', '(value, mapping)', 'Transform a finite cover through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('topologyTransformOpenSet', 'Topology', '(value, mapping)', 'Transform a open set through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('topologyTransformTopologicalSpace', 'Topology', '(value, mapping)', 'Transform a topological space through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('topologyValidateClosedSet', 'Topology', '(value)', 'Validate the closed set representation and domain rules for Topology.', 'professional_function_catalog.md'), + ('topologyValidateContinuousMap', 'Topology', '(value)', 'Validate the continuous map representation and domain rules for Topology.', 'professional_function_catalog.md'), + ('topologyValidateFiniteCover', 'Topology', '(value)', 'Validate the finite cover representation and domain rules for Topology.', 'professional_function_catalog.md'), + ('topologyValidateOpenSet', 'Topology', '(value)', 'Validate the open set representation and domain rules for Topology.', 'professional_function_catalog.md'), + ('topologyValidateTopologicalSpace', 'Topology', '(value)', 'Validate the topological space representation and domain rules for Topology.', 'professional_function_catalog.md'), + ('arcosh', 'Trigonometry', '(x)', 'Planned roadmap function for Trigonometry from upcoming.md.', 'upcoming.md'), + ('arsinh', 'Trigonometry', '(x)', 'Planned roadmap function for Trigonometry from upcoming.md.', 'upcoming.md'), + ('artanh', 'Trigonometry', '(x)', 'Planned roadmap function for Trigonometry from upcoming.md.', 'upcoming.md'), + ('cosh', 'Trigonometry', '(x)', 'Planned roadmap function for Trigonometry from upcoming.md.', 'upcoming.md'), + ('degreesMinutesSeconds', 'Trigonometry', '(degree)', 'Planned roadmap function for Trigonometry from upcoming.md.', 'upcoming.md'), + ('lawOfCosines', 'Trigonometry', '(a=None, b=None, c=None, C=None)', 'Planned roadmap function for Trigonometry from upcoming.md.', 'upcoming.md'), + ('lawOfSines', 'Trigonometry', '(a=None, A=None, b=None, B=None)', 'Planned roadmap function for Trigonometry from upcoming.md.', 'upcoming.md'), + ('normalizeDegrees', 'Trigonometry', '(x)', 'Planned roadmap function for Trigonometry from upcoming.md.', 'upcoming.md'), + ('normalizeRadians', 'Trigonometry', '(x)', 'Planned roadmap function for Trigonometry from upcoming.md.', 'upcoming.md'), + ('sinh', 'Trigonometry', '(x)', 'Planned roadmap function for Trigonometry from upcoming.md.', 'upcoming.md'), + ('tanh', 'Trigonometry', '(x)', 'Planned roadmap function for Trigonometry from upcoming.md.', 'upcoming.md'), + ('trigonometryApproximateAngle', 'Trigonometry', '(value, tolerance=1e-9)', 'Approximate a angle with explicit tolerance controls.', 'professional_function_catalog.md'), + ('trigonometryApproximateHyperbolicFunction', 'Trigonometry', '(value, tolerance=1e-9)', 'Approximate a hyperbolic function with explicit tolerance controls.', 'professional_function_catalog.md'), + ('trigonometryApproximatePeriodicFunction', 'Trigonometry', '(value, tolerance=1e-9)', 'Approximate a periodic function with explicit tolerance controls.', 'professional_function_catalog.md'), + ('trigonometryApproximateTriangleModel', 'Trigonometry', '(value, tolerance=1e-9)', 'Approximate a triangle model with explicit tolerance controls.', 'professional_function_catalog.md'), + ('trigonometryApproximateTrigIdentity', 'Trigonometry', '(value, tolerance=1e-9)', 'Approximate a trig identity with explicit tolerance controls.', 'professional_function_catalog.md'), + ('trigonometryCanonicalizeAngle', 'Trigonometry', '(value)', 'Canonicalize a angle so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('trigonometryCanonicalizeHyperbolicFunction', 'Trigonometry', '(value)', 'Canonicalize a hyperbolic function so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('trigonometryCanonicalizePeriodicFunction', 'Trigonometry', '(value)', 'Canonicalize a periodic function so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('trigonometryCanonicalizeTriangleModel', 'Trigonometry', '(value)', 'Canonicalize a triangle model so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('trigonometryCanonicalizeTrigIdentity', 'Trigonometry', '(value)', 'Canonicalize a trig identity so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('trigonometryClassifyAngle', 'Trigonometry', '(value)', 'Classify a angle by its standard Trigonometry invariants.', 'professional_function_catalog.md'), + ('trigonometryClassifyHyperbolicFunction', 'Trigonometry', '(value)', 'Classify a hyperbolic function by its standard Trigonometry invariants.', 'professional_function_catalog.md'), + ('trigonometryClassifyPeriodicFunction', 'Trigonometry', '(value)', 'Classify a periodic function by its standard Trigonometry invariants.', 'professional_function_catalog.md'), + ('trigonometryClassifyTriangleModel', 'Trigonometry', '(value)', 'Classify a triangle model by its standard Trigonometry invariants.', 'professional_function_catalog.md'), + ('trigonometryClassifyTrigIdentity', 'Trigonometry', '(value)', 'Classify a trig identity by its standard Trigonometry invariants.', 'professional_function_catalog.md'), + ('trigonometryCombineAngle', 'Trigonometry', '(left, right)', 'Combine two angle values with the natural operation for Trigonometry.', 'professional_function_catalog.md'), + ('trigonometryCombineHyperbolicFunction', 'Trigonometry', '(left, right)', 'Combine two hyperbolic function values with the natural operation for Trigonometry.', 'professional_function_catalog.md'), + ('trigonometryCombinePeriodicFunction', 'Trigonometry', '(left, right)', 'Combine two periodic function values with the natural operation for Trigonometry.', 'professional_function_catalog.md'), + ('trigonometryCombineTriangleModel', 'Trigonometry', '(left, right)', 'Combine two triangle model values with the natural operation for Trigonometry.', 'professional_function_catalog.md'), + ('trigonometryCombineTrigIdentity', 'Trigonometry', '(left, right)', 'Combine two trig identity values with the natural operation for Trigonometry.', 'professional_function_catalog.md'), + ('trigonometryCompareAngle', 'Trigonometry', '(left, right)', 'Compare two angle values under the conventions of Trigonometry.', 'professional_function_catalog.md'), + ('trigonometryCompareHyperbolicFunction', 'Trigonometry', '(left, right)', 'Compare two hyperbolic function values under the conventions of Trigonometry.', 'professional_function_catalog.md'), + ('trigonometryComparePeriodicFunction', 'Trigonometry', '(left, right)', 'Compare two periodic function values under the conventions of Trigonometry.', 'professional_function_catalog.md'), + ('trigonometryCompareTriangleModel', 'Trigonometry', '(left, right)', 'Compare two triangle model values under the conventions of Trigonometry.', 'professional_function_catalog.md'), + ('trigonometryCompareTrigIdentity', 'Trigonometry', '(left, right)', 'Compare two trig identity values under the conventions of Trigonometry.', 'professional_function_catalog.md'), + ('trigonometryComputeAngle', 'Trigonometry', '(value)', 'Compute the central numerical or symbolic data of a angle.', 'professional_function_catalog.md'), + ('trigonometryComputeHyperbolicFunction', 'Trigonometry', '(value)', 'Compute the central numerical or symbolic data of a hyperbolic function.', 'professional_function_catalog.md'), + ('trigonometryComputePeriodicFunction', 'Trigonometry', '(value)', 'Compute the central numerical or symbolic data of a periodic function.', 'professional_function_catalog.md'), + ('trigonometryComputeTriangleModel', 'Trigonometry', '(value)', 'Compute the central numerical or symbolic data of a triangle model.', 'professional_function_catalog.md'), + ('trigonometryComputeTrigIdentity', 'Trigonometry', '(value)', 'Compute the central numerical or symbolic data of a trig identity.', 'professional_function_catalog.md'), + ('trigonometryConstructAngle', 'Trigonometry', '(*args)', 'Construct a angle from explicit inputs for Trigonometry.', 'professional_function_catalog.md'), + ('trigonometryConstructHyperbolicFunction', 'Trigonometry', '(*args)', 'Construct a hyperbolic function from explicit inputs for Trigonometry.', 'professional_function_catalog.md'), + ('trigonometryConstructPeriodicFunction', 'Trigonometry', '(*args)', 'Construct a periodic function from explicit inputs for Trigonometry.', 'professional_function_catalog.md'), + ('trigonometryConstructTriangleModel', 'Trigonometry', '(*args)', 'Construct a triangle model from explicit inputs for Trigonometry.', 'professional_function_catalog.md'), + ('trigonometryConstructTrigIdentity', 'Trigonometry', '(*args)', 'Construct a trig identity from explicit inputs for Trigonometry.', 'professional_function_catalog.md'), + ('trigonometryDecomposeAngle', 'Trigonometry', '(value)', 'Decompose a angle into simpler or canonical components.', 'professional_function_catalog.md'), + ('trigonometryDecomposeHyperbolicFunction', 'Trigonometry', '(value)', 'Decompose a hyperbolic function into simpler or canonical components.', 'professional_function_catalog.md'), + ('trigonometryDecomposePeriodicFunction', 'Trigonometry', '(value)', 'Decompose a periodic function into simpler or canonical components.', 'professional_function_catalog.md'), + ('trigonometryDecomposeTriangleModel', 'Trigonometry', '(value)', 'Decompose a triangle model into simpler or canonical components.', 'professional_function_catalog.md'), + ('trigonometryDecomposeTrigIdentity', 'Trigonometry', '(value)', 'Decompose a trig identity into simpler or canonical components.', 'professional_function_catalog.md'), + ('trigonometryDocumentAngle', 'Trigonometry', '(value)', 'Return a structured explanation of a angle and related assumptions.', 'professional_function_catalog.md'), + ('trigonometryDocumentHyperbolicFunction', 'Trigonometry', '(value)', 'Return a structured explanation of a hyperbolic function and related assumptions.', 'professional_function_catalog.md'), + ('trigonometryDocumentPeriodicFunction', 'Trigonometry', '(value)', 'Return a structured explanation of a periodic function and related assumptions.', 'professional_function_catalog.md'), + ('trigonometryDocumentTriangleModel', 'Trigonometry', '(value)', 'Return a structured explanation of a triangle model and related assumptions.', 'professional_function_catalog.md'), + ('trigonometryDocumentTrigIdentity', 'Trigonometry', '(value)', 'Return a structured explanation of a trig identity and related assumptions.', 'professional_function_catalog.md'), + ('trigonometryEnumerateAngle', 'Trigonometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a angle.', 'professional_function_catalog.md'), + ('trigonometryEnumerateHyperbolicFunction', 'Trigonometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a hyperbolic function.', 'professional_function_catalog.md'), + ('trigonometryEnumeratePeriodicFunction', 'Trigonometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a periodic function.', 'professional_function_catalog.md'), + ('trigonometryEnumerateTriangleModel', 'Trigonometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a triangle model.', 'professional_function_catalog.md'), + ('trigonometryEnumerateTrigIdentity', 'Trigonometry', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a trig identity.', 'professional_function_catalog.md'), + ('trigonometryEstimateAngle', 'Trigonometry', '(value, samples=None)', 'Estimate a angle property from finite samples or approximations.', 'professional_function_catalog.md'), + ('trigonometryEstimateHyperbolicFunction', 'Trigonometry', '(value, samples=None)', 'Estimate a hyperbolic function property from finite samples or approximations.', 'professional_function_catalog.md'), + ('trigonometryEstimatePeriodicFunction', 'Trigonometry', '(value, samples=None)', 'Estimate a periodic function property from finite samples or approximations.', 'professional_function_catalog.md'), + ('trigonometryEstimateTriangleModel', 'Trigonometry', '(value, samples=None)', 'Estimate a triangle model property from finite samples or approximations.', 'professional_function_catalog.md'), + ('trigonometryEstimateTrigIdentity', 'Trigonometry', '(value, samples=None)', 'Estimate a trig identity property from finite samples or approximations.', 'professional_function_catalog.md'), + ('trigonometryEvaluateAngle', 'Trigonometry', '(value, point=None)', 'Evaluate a angle at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('trigonometryEvaluateHyperbolicFunction', 'Trigonometry', '(value, point=None)', 'Evaluate a hyperbolic function at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('trigonometryEvaluatePeriodicFunction', 'Trigonometry', '(value, point=None)', 'Evaluate a periodic function at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('trigonometryEvaluateTriangleModel', 'Trigonometry', '(value, point=None)', 'Evaluate a triangle model at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('trigonometryEvaluateTrigIdentity', 'Trigonometry', '(value, point=None)', 'Evaluate a trig identity at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('trigonometryFormatAngle', 'Trigonometry', '(value)', 'Format a angle for deterministic user-facing output.', 'professional_function_catalog.md'), + ('trigonometryFormatHyperbolicFunction', 'Trigonometry', '(value)', 'Format a hyperbolic function for deterministic user-facing output.', 'professional_function_catalog.md'), + ('trigonometryFormatPeriodicFunction', 'Trigonometry', '(value)', 'Format a periodic function for deterministic user-facing output.', 'professional_function_catalog.md'), + ('trigonometryFormatTriangleModel', 'Trigonometry', '(value)', 'Format a triangle model for deterministic user-facing output.', 'professional_function_catalog.md'), + ('trigonometryFormatTrigIdentity', 'Trigonometry', '(value)', 'Format a trig identity for deterministic user-facing output.', 'professional_function_catalog.md'), + ('trigonometryGenerateExampleAngle', 'Trigonometry', '(size=3)', 'Generate a small documented example of a angle.', 'professional_function_catalog.md'), + ('trigonometryGenerateExampleHyperbolicFunction', 'Trigonometry', '(size=3)', 'Generate a small documented example of a hyperbolic function.', 'professional_function_catalog.md'), + ('trigonometryGenerateExamplePeriodicFunction', 'Trigonometry', '(size=3)', 'Generate a small documented example of a periodic function.', 'professional_function_catalog.md'), + ('trigonometryGenerateExampleTriangleModel', 'Trigonometry', '(size=3)', 'Generate a small documented example of a triangle model.', 'professional_function_catalog.md'), + ('trigonometryGenerateExampleTrigIdentity', 'Trigonometry', '(size=3)', 'Generate a small documented example of a trig identity.', 'professional_function_catalog.md'), + ('trigonometryNormalizeAngle', 'Trigonometry', '(value)', 'Normalize a angle into the standard Trigonometry representation.', 'professional_function_catalog.md'), + ('trigonometryNormalizeHyperbolicFunction', 'Trigonometry', '(value)', 'Normalize a hyperbolic function into the standard Trigonometry representation.', 'professional_function_catalog.md'), + ('trigonometryNormalizePeriodicFunction', 'Trigonometry', '(value)', 'Normalize a periodic function into the standard Trigonometry representation.', 'professional_function_catalog.md'), + ('trigonometryNormalizeTriangleModel', 'Trigonometry', '(value)', 'Normalize a triangle model into the standard Trigonometry representation.', 'professional_function_catalog.md'), + ('trigonometryNormalizeTrigIdentity', 'Trigonometry', '(value)', 'Normalize a trig identity into the standard Trigonometry representation.', 'professional_function_catalog.md'), + ('trigonometryParseAngle', 'Trigonometry', '(text)', 'Parse a text or structured value into a angle.', 'professional_function_catalog.md'), + ('trigonometryParseHyperbolicFunction', 'Trigonometry', '(text)', 'Parse a text or structured value into a hyperbolic function.', 'professional_function_catalog.md'), + ('trigonometryParsePeriodicFunction', 'Trigonometry', '(text)', 'Parse a text or structured value into a periodic function.', 'professional_function_catalog.md'), + ('trigonometryParseTriangleModel', 'Trigonometry', '(text)', 'Parse a text or structured value into a triangle model.', 'professional_function_catalog.md'), + ('trigonometryParseTrigIdentity', 'Trigonometry', '(text)', 'Parse a text or structured value into a trig identity.', 'professional_function_catalog.md'), + ('trigonometrySimplifyAngle', 'Trigonometry', '(value)', 'Simplify a angle without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('trigonometrySimplifyHyperbolicFunction', 'Trigonometry', '(value)', 'Simplify a hyperbolic function without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('trigonometrySimplifyPeriodicFunction', 'Trigonometry', '(value)', 'Simplify a periodic function without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('trigonometrySimplifyTriangleModel', 'Trigonometry', '(value)', 'Simplify a triangle model without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('trigonometrySimplifyTrigIdentity', 'Trigonometry', '(value)', 'Simplify a trig identity without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('trigonometryTestEquivalenceAngle', 'Trigonometry', '(left, right)', 'Test whether two angle values are equivalent in Trigonometry.', 'professional_function_catalog.md'), + ('trigonometryTestEquivalenceHyperbolicFunction', 'Trigonometry', '(left, right)', 'Test whether two hyperbolic function values are equivalent in Trigonometry.', 'professional_function_catalog.md'), + ('trigonometryTestEquivalencePeriodicFunction', 'Trigonometry', '(left, right)', 'Test whether two periodic function values are equivalent in Trigonometry.', 'professional_function_catalog.md'), + ('trigonometryTestEquivalenceTriangleModel', 'Trigonometry', '(left, right)', 'Test whether two triangle model values are equivalent in Trigonometry.', 'professional_function_catalog.md'), + ('trigonometryTestEquivalenceTrigIdentity', 'Trigonometry', '(left, right)', 'Test whether two trig identity values are equivalent in Trigonometry.', 'professional_function_catalog.md'), + ('trigonometryTransformAngle', 'Trigonometry', '(value, mapping)', 'Transform a angle through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('trigonometryTransformHyperbolicFunction', 'Trigonometry', '(value, mapping)', 'Transform a hyperbolic function through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('trigonometryTransformPeriodicFunction', 'Trigonometry', '(value, mapping)', 'Transform a periodic function through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('trigonometryTransformTriangleModel', 'Trigonometry', '(value, mapping)', 'Transform a triangle model through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('trigonometryTransformTrigIdentity', 'Trigonometry', '(value, mapping)', 'Transform a trig identity through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('trigonometryValidateAngle', 'Trigonometry', '(value)', 'Validate the angle representation and domain rules for Trigonometry.', 'professional_function_catalog.md'), + ('trigonometryValidateHyperbolicFunction', 'Trigonometry', '(value)', 'Validate the hyperbolic function representation and domain rules for Trigonometry.', 'professional_function_catalog.md'), + ('trigonometryValidatePeriodicFunction', 'Trigonometry', '(value)', 'Validate the periodic function representation and domain rules for Trigonometry.', 'professional_function_catalog.md'), + ('trigonometryValidateTriangleModel', 'Trigonometry', '(value)', 'Validate the triangle model representation and domain rules for Trigonometry.', 'professional_function_catalog.md'), + ('trigonometryValidateTrigIdentity', 'Trigonometry', '(value)', 'Validate the trig identity representation and domain rules for Trigonometry.', 'professional_function_catalog.md'), + ('betaReduce', 'Type Theory', '(expression)', 'Planned roadmap function for Type Theory from upcoming.md.', 'upcoming.md'), + ('churchNumeral', 'Type Theory', '(n)', 'Planned roadmap function for Type Theory from upcoming.md.', 'upcoming.md'), + ('freeVariables', 'Type Theory', '(expression)', 'Planned roadmap function for Type Theory from upcoming.md.', 'upcoming.md'), + ('functionType', 'Type Theory', '(inputType, outputType)', 'Planned roadmap function for Type Theory from upcoming.md.', 'upcoming.md'), + ('inferSimpleType', 'Type Theory', '(expression, context)', 'Planned roadmap function for Type Theory from upcoming.md.', 'upcoming.md'), + ('isType', 'Type Theory', '(expression)', 'Planned roadmap function for Type Theory from upcoming.md.', 'upcoming.md'), + ('lambdaExpression', 'Type Theory', '(variable, body)', 'Planned roadmap function for Type Theory from upcoming.md.', 'upcoming.md'), + ('substitute', 'Type Theory', '(expression, variable, replacement)', 'Planned roadmap function for Type Theory from upcoming.md.', 'upcoming.md'), + ('typeCheck', 'Type Theory', '(expression, expectedType, context)', 'Planned roadmap function for Type Theory from upcoming.md.', 'upcoming.md'), + ('typeTheoryApproximateContext', 'Type Theory', '(value, tolerance=1e-9)', 'Approximate a context with explicit tolerance controls.', 'professional_function_catalog.md'), + ('typeTheoryApproximateLambdaExpression', 'Type Theory', '(value, tolerance=1e-9)', 'Approximate a lambda expression with explicit tolerance controls.', 'professional_function_catalog.md'), + ('typeTheoryApproximateTerm', 'Type Theory', '(value, tolerance=1e-9)', 'Approximate a term with explicit tolerance controls.', 'professional_function_catalog.md'), + ('typeTheoryApproximateTypeExpression', 'Type Theory', '(value, tolerance=1e-9)', 'Approximate a type expression with explicit tolerance controls.', 'professional_function_catalog.md'), + ('typeTheoryApproximateTypingJudgment', 'Type Theory', '(value, tolerance=1e-9)', 'Approximate a typing judgment with explicit tolerance controls.', 'professional_function_catalog.md'), + ('typeTheoryCanonicalizeContext', 'Type Theory', '(value)', 'Canonicalize a context so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('typeTheoryCanonicalizeLambdaExpression', 'Type Theory', '(value)', 'Canonicalize a lambda expression so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('typeTheoryCanonicalizeTerm', 'Type Theory', '(value)', 'Canonicalize a term so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('typeTheoryCanonicalizeTypeExpression', 'Type Theory', '(value)', 'Canonicalize a type expression so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('typeTheoryCanonicalizeTypingJudgment', 'Type Theory', '(value)', 'Canonicalize a typing judgment so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('typeTheoryClassifyContext', 'Type Theory', '(value)', 'Classify a context by its standard Type Theory invariants.', 'professional_function_catalog.md'), + ('typeTheoryClassifyLambdaExpression', 'Type Theory', '(value)', 'Classify a lambda expression by its standard Type Theory invariants.', 'professional_function_catalog.md'), + ('typeTheoryClassifyTerm', 'Type Theory', '(value)', 'Classify a term by its standard Type Theory invariants.', 'professional_function_catalog.md'), + ('typeTheoryClassifyTypeExpression', 'Type Theory', '(value)', 'Classify a type expression by its standard Type Theory invariants.', 'professional_function_catalog.md'), + ('typeTheoryClassifyTypingJudgment', 'Type Theory', '(value)', 'Classify a typing judgment by its standard Type Theory invariants.', 'professional_function_catalog.md'), + ('typeTheoryCombineContext', 'Type Theory', '(left, right)', 'Combine two context values with the natural operation for Type Theory.', 'professional_function_catalog.md'), + ('typeTheoryCombineLambdaExpression', 'Type Theory', '(left, right)', 'Combine two lambda expression values with the natural operation for Type Theory.', 'professional_function_catalog.md'), + ('typeTheoryCombineTerm', 'Type Theory', '(left, right)', 'Combine two term values with the natural operation for Type Theory.', 'professional_function_catalog.md'), + ('typeTheoryCombineTypeExpression', 'Type Theory', '(left, right)', 'Combine two type expression values with the natural operation for Type Theory.', 'professional_function_catalog.md'), + ('typeTheoryCombineTypingJudgment', 'Type Theory', '(left, right)', 'Combine two typing judgment values with the natural operation for Type Theory.', 'professional_function_catalog.md'), + ('typeTheoryCompareContext', 'Type Theory', '(left, right)', 'Compare two context values under the conventions of Type Theory.', 'professional_function_catalog.md'), + ('typeTheoryCompareLambdaExpression', 'Type Theory', '(left, right)', 'Compare two lambda expression values under the conventions of Type Theory.', 'professional_function_catalog.md'), + ('typeTheoryCompareTerm', 'Type Theory', '(left, right)', 'Compare two term values under the conventions of Type Theory.', 'professional_function_catalog.md'), + ('typeTheoryCompareTypeExpression', 'Type Theory', '(left, right)', 'Compare two type expression values under the conventions of Type Theory.', 'professional_function_catalog.md'), + ('typeTheoryCompareTypingJudgment', 'Type Theory', '(left, right)', 'Compare two typing judgment values under the conventions of Type Theory.', 'professional_function_catalog.md'), + ('typeTheoryComputeContext', 'Type Theory', '(value)', 'Compute the central numerical or symbolic data of a context.', 'professional_function_catalog.md'), + ('typeTheoryComputeLambdaExpression', 'Type Theory', '(value)', 'Compute the central numerical or symbolic data of a lambda expression.', 'professional_function_catalog.md'), + ('typeTheoryComputeTerm', 'Type Theory', '(value)', 'Compute the central numerical or symbolic data of a term.', 'professional_function_catalog.md'), + ('typeTheoryComputeTypeExpression', 'Type Theory', '(value)', 'Compute the central numerical or symbolic data of a type expression.', 'professional_function_catalog.md'), + ('typeTheoryComputeTypingJudgment', 'Type Theory', '(value)', 'Compute the central numerical or symbolic data of a typing judgment.', 'professional_function_catalog.md'), + ('typeTheoryConstructContext', 'Type Theory', '(*args)', 'Construct a context from explicit inputs for Type Theory.', 'professional_function_catalog.md'), + ('typeTheoryConstructLambdaExpression', 'Type Theory', '(*args)', 'Construct a lambda expression from explicit inputs for Type Theory.', 'professional_function_catalog.md'), + ('typeTheoryConstructTerm', 'Type Theory', '(*args)', 'Construct a term from explicit inputs for Type Theory.', 'professional_function_catalog.md'), + ('typeTheoryConstructTypeExpression', 'Type Theory', '(*args)', 'Construct a type expression from explicit inputs for Type Theory.', 'professional_function_catalog.md'), + ('typeTheoryConstructTypingJudgment', 'Type Theory', '(*args)', 'Construct a typing judgment from explicit inputs for Type Theory.', 'professional_function_catalog.md'), + ('typeTheoryDecomposeContext', 'Type Theory', '(value)', 'Decompose a context into simpler or canonical components.', 'professional_function_catalog.md'), + ('typeTheoryDecomposeLambdaExpression', 'Type Theory', '(value)', 'Decompose a lambda expression into simpler or canonical components.', 'professional_function_catalog.md'), + ('typeTheoryDecomposeTerm', 'Type Theory', '(value)', 'Decompose a term into simpler or canonical components.', 'professional_function_catalog.md'), + ('typeTheoryDecomposeTypeExpression', 'Type Theory', '(value)', 'Decompose a type expression into simpler or canonical components.', 'professional_function_catalog.md'), + ('typeTheoryDecomposeTypingJudgment', 'Type Theory', '(value)', 'Decompose a typing judgment into simpler or canonical components.', 'professional_function_catalog.md'), + ('typeTheoryDocumentContext', 'Type Theory', '(value)', 'Return a structured explanation of a context and related assumptions.', 'professional_function_catalog.md'), + ('typeTheoryDocumentLambdaExpression', 'Type Theory', '(value)', 'Return a structured explanation of a lambda expression and related assumptions.', 'professional_function_catalog.md'), + ('typeTheoryDocumentTerm', 'Type Theory', '(value)', 'Return a structured explanation of a term and related assumptions.', 'professional_function_catalog.md'), + ('typeTheoryDocumentTypeExpression', 'Type Theory', '(value)', 'Return a structured explanation of a type expression and related assumptions.', 'professional_function_catalog.md'), + ('typeTheoryDocumentTypingJudgment', 'Type Theory', '(value)', 'Return a structured explanation of a typing judgment and related assumptions.', 'professional_function_catalog.md'), + ('typeTheoryEnumerateContext', 'Type Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a context.', 'professional_function_catalog.md'), + ('typeTheoryEnumerateLambdaExpression', 'Type Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a lambda expression.', 'professional_function_catalog.md'), + ('typeTheoryEnumerateTerm', 'Type Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a term.', 'professional_function_catalog.md'), + ('typeTheoryEnumerateTypeExpression', 'Type Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a type expression.', 'professional_function_catalog.md'), + ('typeTheoryEnumerateTypingJudgment', 'Type Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a typing judgment.', 'professional_function_catalog.md'), + ('typeTheoryEstimateContext', 'Type Theory', '(value, samples=None)', 'Estimate a context property from finite samples or approximations.', 'professional_function_catalog.md'), + ('typeTheoryEstimateLambdaExpression', 'Type Theory', '(value, samples=None)', 'Estimate a lambda expression property from finite samples or approximations.', 'professional_function_catalog.md'), + ('typeTheoryEstimateTerm', 'Type Theory', '(value, samples=None)', 'Estimate a term property from finite samples or approximations.', 'professional_function_catalog.md'), + ('typeTheoryEstimateTypeExpression', 'Type Theory', '(value, samples=None)', 'Estimate a type expression property from finite samples or approximations.', 'professional_function_catalog.md'), + ('typeTheoryEstimateTypingJudgment', 'Type Theory', '(value, samples=None)', 'Estimate a typing judgment property from finite samples or approximations.', 'professional_function_catalog.md'), + ('typeTheoryEvaluateContext', 'Type Theory', '(value, point=None)', 'Evaluate a context at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('typeTheoryEvaluateLambdaExpression', 'Type Theory', '(value, point=None)', 'Evaluate a lambda expression at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('typeTheoryEvaluateTerm', 'Type Theory', '(value, point=None)', 'Evaluate a term at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('typeTheoryEvaluateTypeExpression', 'Type Theory', '(value, point=None)', 'Evaluate a type expression at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('typeTheoryEvaluateTypingJudgment', 'Type Theory', '(value, point=None)', 'Evaluate a typing judgment at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('typeTheoryFormatContext', 'Type Theory', '(value)', 'Format a context for deterministic user-facing output.', 'professional_function_catalog.md'), + ('typeTheoryFormatLambdaExpression', 'Type Theory', '(value)', 'Format a lambda expression for deterministic user-facing output.', 'professional_function_catalog.md'), + ('typeTheoryFormatTerm', 'Type Theory', '(value)', 'Format a term for deterministic user-facing output.', 'professional_function_catalog.md'), + ('typeTheoryFormatTypeExpression', 'Type Theory', '(value)', 'Format a type expression for deterministic user-facing output.', 'professional_function_catalog.md'), + ('typeTheoryFormatTypingJudgment', 'Type Theory', '(value)', 'Format a typing judgment for deterministic user-facing output.', 'professional_function_catalog.md'), + ('typeTheoryGenerateExampleContext', 'Type Theory', '(size=3)', 'Generate a small documented example of a context.', 'professional_function_catalog.md'), + ('typeTheoryGenerateExampleLambdaExpression', 'Type Theory', '(size=3)', 'Generate a small documented example of a lambda expression.', 'professional_function_catalog.md'), + ('typeTheoryGenerateExampleTerm', 'Type Theory', '(size=3)', 'Generate a small documented example of a term.', 'professional_function_catalog.md'), + ('typeTheoryGenerateExampleTypeExpression', 'Type Theory', '(size=3)', 'Generate a small documented example of a type expression.', 'professional_function_catalog.md'), + ('typeTheoryGenerateExampleTypingJudgment', 'Type Theory', '(size=3)', 'Generate a small documented example of a typing judgment.', 'professional_function_catalog.md'), + ('typeTheoryNormalizeContext', 'Type Theory', '(value)', 'Normalize a context into the standard Type Theory representation.', 'professional_function_catalog.md'), + ('typeTheoryNormalizeLambdaExpression', 'Type Theory', '(value)', 'Normalize a lambda expression into the standard Type Theory representation.', 'professional_function_catalog.md'), + ('typeTheoryNormalizeTerm', 'Type Theory', '(value)', 'Normalize a term into the standard Type Theory representation.', 'professional_function_catalog.md'), + ('typeTheoryNormalizeTypeExpression', 'Type Theory', '(value)', 'Normalize a type expression into the standard Type Theory representation.', 'professional_function_catalog.md'), + ('typeTheoryNormalizeTypingJudgment', 'Type Theory', '(value)', 'Normalize a typing judgment into the standard Type Theory representation.', 'professional_function_catalog.md'), + ('typeTheoryParseContext', 'Type Theory', '(text)', 'Parse a text or structured value into a context.', 'professional_function_catalog.md'), + ('typeTheoryParseLambdaExpression', 'Type Theory', '(text)', 'Parse a text or structured value into a lambda expression.', 'professional_function_catalog.md'), + ('typeTheoryParseTerm', 'Type Theory', '(text)', 'Parse a text or structured value into a term.', 'professional_function_catalog.md'), + ('typeTheoryParseTypeExpression', 'Type Theory', '(text)', 'Parse a text or structured value into a type expression.', 'professional_function_catalog.md'), + ('typeTheoryParseTypingJudgment', 'Type Theory', '(text)', 'Parse a text or structured value into a typing judgment.', 'professional_function_catalog.md'), + ('typeTheorySimplifyContext', 'Type Theory', '(value)', 'Simplify a context without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('typeTheorySimplifyLambdaExpression', 'Type Theory', '(value)', 'Simplify a lambda expression without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('typeTheorySimplifyTerm', 'Type Theory', '(value)', 'Simplify a term without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('typeTheorySimplifyTypeExpression', 'Type Theory', '(value)', 'Simplify a type expression without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('typeTheorySimplifyTypingJudgment', 'Type Theory', '(value)', 'Simplify a typing judgment without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('typeTheoryTestEquivalenceContext', 'Type Theory', '(left, right)', 'Test whether two context values are equivalent in Type Theory.', 'professional_function_catalog.md'), + ('typeTheoryTestEquivalenceLambdaExpression', 'Type Theory', '(left, right)', 'Test whether two lambda expression values are equivalent in Type Theory.', 'professional_function_catalog.md'), + ('typeTheoryTestEquivalenceTerm', 'Type Theory', '(left, right)', 'Test whether two term values are equivalent in Type Theory.', 'professional_function_catalog.md'), + ('typeTheoryTestEquivalenceTypeExpression', 'Type Theory', '(left, right)', 'Test whether two type expression values are equivalent in Type Theory.', 'professional_function_catalog.md'), + ('typeTheoryTestEquivalenceTypingJudgment', 'Type Theory', '(left, right)', 'Test whether two typing judgment values are equivalent in Type Theory.', 'professional_function_catalog.md'), + ('typeTheoryTransformContext', 'Type Theory', '(value, mapping)', 'Transform a context through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('typeTheoryTransformLambdaExpression', 'Type Theory', '(value, mapping)', 'Transform a lambda expression through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('typeTheoryTransformTerm', 'Type Theory', '(value, mapping)', 'Transform a term through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('typeTheoryTransformTypeExpression', 'Type Theory', '(value, mapping)', 'Transform a type expression through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('typeTheoryTransformTypingJudgment', 'Type Theory', '(value, mapping)', 'Transform a typing judgment through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('typeTheoryValidateContext', 'Type Theory', '(value)', 'Validate the context representation and domain rules for Type Theory.', 'professional_function_catalog.md'), + ('typeTheoryValidateLambdaExpression', 'Type Theory', '(value)', 'Validate the lambda expression representation and domain rules for Type Theory.', 'professional_function_catalog.md'), + ('typeTheoryValidateTerm', 'Type Theory', '(value)', 'Validate the term representation and domain rules for Type Theory.', 'professional_function_catalog.md'), + ('typeTheoryValidateTypeExpression', 'Type Theory', '(value)', 'Validate the type expression representation and domain rules for Type Theory.', 'professional_function_catalog.md'), + ('typeTheoryValidateTypingJudgment', 'Type Theory', '(value)', 'Validate the typing judgment representation and domain rules for Type Theory.', 'professional_function_catalog.md'), + ('variable', 'Type Theory', '(name, typeName)', 'Planned roadmap function for Type Theory from upcoming.md.', 'upcoming.md'), + ('congruenceRelation', 'Universal Algebra', '(elements, relation, operations)', 'Planned roadmap function for Universal Algebra from upcoming.md.', 'upcoming.md'), + ('isAlgebraForSignature', 'Universal Algebra', '(elements, operations, signature)', 'Planned roadmap function for Universal Algebra from upcoming.md.', 'upcoming.md'), + ('isHomomorphism', 'Universal Algebra', '(domain, codomain, mapping, operations)', 'Planned roadmap function for Universal Algebra from upcoming.md.', 'upcoming.md'), + ('productAlgebra', 'Universal Algebra', '(algebraA, algebraB)', 'Planned roadmap function for Universal Algebra from upcoming.md.', 'upcoming.md'), + ('quotientAlgebra', 'Universal Algebra', '(elements, congruence, operations)', 'Planned roadmap function for Universal Algebra from upcoming.md.', 'upcoming.md'), + ('satisfiesIdentity', 'Universal Algebra', '(elements, operations, lhs, rhs)', 'Planned roadmap function for Universal Algebra from upcoming.md.', 'upcoming.md'), + ('signature', 'Universal Algebra', '(operations)', 'Planned roadmap function for Universal Algebra from upcoming.md.', 'upcoming.md'), + ('subalgebraGeneratedBy', 'Universal Algebra', '(generators, elements, operations)', 'Planned roadmap function for Universal Algebra from upcoming.md.', 'upcoming.md'), + ('universalAlgebraApproximateAlgebra', 'Universal Algebra', '(value, tolerance=1e-9)', 'Approximate a algebra with explicit tolerance controls.', 'professional_function_catalog.md'), + ('universalAlgebraApproximateCongruence', 'Universal Algebra', '(value, tolerance=1e-9)', 'Approximate a congruence with explicit tolerance controls.', 'professional_function_catalog.md'), + ('universalAlgebraApproximateHomomorphism', 'Universal Algebra', '(value, tolerance=1e-9)', 'Approximate a homomorphism with explicit tolerance controls.', 'professional_function_catalog.md'), + ('universalAlgebraApproximateIdentityLaw', 'Universal Algebra', '(value, tolerance=1e-9)', 'Approximate a identity law with explicit tolerance controls.', 'professional_function_catalog.md'), + ('universalAlgebraApproximateSignature', 'Universal Algebra', '(value, tolerance=1e-9)', 'Approximate a signature with explicit tolerance controls.', 'professional_function_catalog.md'), + ('universalAlgebraCanonicalizeAlgebra', 'Universal Algebra', '(value)', 'Canonicalize a algebra so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('universalAlgebraCanonicalizeCongruence', 'Universal Algebra', '(value)', 'Canonicalize a congruence so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('universalAlgebraCanonicalizeHomomorphism', 'Universal Algebra', '(value)', 'Canonicalize a homomorphism so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('universalAlgebraCanonicalizeIdentityLaw', 'Universal Algebra', '(value)', 'Canonicalize a identity law so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('universalAlgebraCanonicalizeSignature', 'Universal Algebra', '(value)', 'Canonicalize a signature so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('universalAlgebraClassifyAlgebra', 'Universal Algebra', '(value)', 'Classify a algebra by its standard Universal Algebra invariants.', 'professional_function_catalog.md'), + ('universalAlgebraClassifyCongruence', 'Universal Algebra', '(value)', 'Classify a congruence by its standard Universal Algebra invariants.', 'professional_function_catalog.md'), + ('universalAlgebraClassifyHomomorphism', 'Universal Algebra', '(value)', 'Classify a homomorphism by its standard Universal Algebra invariants.', 'professional_function_catalog.md'), + ('universalAlgebraClassifyIdentityLaw', 'Universal Algebra', '(value)', 'Classify a identity law by its standard Universal Algebra invariants.', 'professional_function_catalog.md'), + ('universalAlgebraClassifySignature', 'Universal Algebra', '(value)', 'Classify a signature by its standard Universal Algebra invariants.', 'professional_function_catalog.md'), + ('universalAlgebraCombineAlgebra', 'Universal Algebra', '(left, right)', 'Combine two algebra values with the natural operation for Universal Algebra.', 'professional_function_catalog.md'), + ('universalAlgebraCombineCongruence', 'Universal Algebra', '(left, right)', 'Combine two congruence values with the natural operation for Universal Algebra.', 'professional_function_catalog.md'), + ('universalAlgebraCombineHomomorphism', 'Universal Algebra', '(left, right)', 'Combine two homomorphism values with the natural operation for Universal Algebra.', 'professional_function_catalog.md'), + ('universalAlgebraCombineIdentityLaw', 'Universal Algebra', '(left, right)', 'Combine two identity law values with the natural operation for Universal Algebra.', 'professional_function_catalog.md'), + ('universalAlgebraCombineSignature', 'Universal Algebra', '(left, right)', 'Combine two signature values with the natural operation for Universal Algebra.', 'professional_function_catalog.md'), + ('universalAlgebraCompareAlgebra', 'Universal Algebra', '(left, right)', 'Compare two algebra values under the conventions of Universal Algebra.', 'professional_function_catalog.md'), + ('universalAlgebraCompareCongruence', 'Universal Algebra', '(left, right)', 'Compare two congruence values under the conventions of Universal Algebra.', 'professional_function_catalog.md'), + ('universalAlgebraCompareHomomorphism', 'Universal Algebra', '(left, right)', 'Compare two homomorphism values under the conventions of Universal Algebra.', 'professional_function_catalog.md'), + ('universalAlgebraCompareIdentityLaw', 'Universal Algebra', '(left, right)', 'Compare two identity law values under the conventions of Universal Algebra.', 'professional_function_catalog.md'), + ('universalAlgebraCompareSignature', 'Universal Algebra', '(left, right)', 'Compare two signature values under the conventions of Universal Algebra.', 'professional_function_catalog.md'), + ('universalAlgebraComputeAlgebra', 'Universal Algebra', '(value)', 'Compute the central numerical or symbolic data of a algebra.', 'professional_function_catalog.md'), + ('universalAlgebraComputeCongruence', 'Universal Algebra', '(value)', 'Compute the central numerical or symbolic data of a congruence.', 'professional_function_catalog.md'), + ('universalAlgebraComputeHomomorphism', 'Universal Algebra', '(value)', 'Compute the central numerical or symbolic data of a homomorphism.', 'professional_function_catalog.md'), + ('universalAlgebraComputeIdentityLaw', 'Universal Algebra', '(value)', 'Compute the central numerical or symbolic data of a identity law.', 'professional_function_catalog.md'), + ('universalAlgebraComputeSignature', 'Universal Algebra', '(value)', 'Compute the central numerical or symbolic data of a signature.', 'professional_function_catalog.md'), + ('universalAlgebraConstructAlgebra', 'Universal Algebra', '(*args)', 'Construct a algebra from explicit inputs for Universal Algebra.', 'professional_function_catalog.md'), + ('universalAlgebraConstructCongruence', 'Universal Algebra', '(*args)', 'Construct a congruence from explicit inputs for Universal Algebra.', 'professional_function_catalog.md'), + ('universalAlgebraConstructHomomorphism', 'Universal Algebra', '(*args)', 'Construct a homomorphism from explicit inputs for Universal Algebra.', 'professional_function_catalog.md'), + ('universalAlgebraConstructIdentityLaw', 'Universal Algebra', '(*args)', 'Construct a identity law from explicit inputs for Universal Algebra.', 'professional_function_catalog.md'), + ('universalAlgebraConstructSignature', 'Universal Algebra', '(*args)', 'Construct a signature from explicit inputs for Universal Algebra.', 'professional_function_catalog.md'), + ('universalAlgebraDecomposeAlgebra', 'Universal Algebra', '(value)', 'Decompose a algebra into simpler or canonical components.', 'professional_function_catalog.md'), + ('universalAlgebraDecomposeCongruence', 'Universal Algebra', '(value)', 'Decompose a congruence into simpler or canonical components.', 'professional_function_catalog.md'), + ('universalAlgebraDecomposeHomomorphism', 'Universal Algebra', '(value)', 'Decompose a homomorphism into simpler or canonical components.', 'professional_function_catalog.md'), + ('universalAlgebraDecomposeIdentityLaw', 'Universal Algebra', '(value)', 'Decompose a identity law into simpler or canonical components.', 'professional_function_catalog.md'), + ('universalAlgebraDecomposeSignature', 'Universal Algebra', '(value)', 'Decompose a signature into simpler or canonical components.', 'professional_function_catalog.md'), + ('universalAlgebraDocumentAlgebra', 'Universal Algebra', '(value)', 'Return a structured explanation of a algebra and related assumptions.', 'professional_function_catalog.md'), + ('universalAlgebraDocumentCongruence', 'Universal Algebra', '(value)', 'Return a structured explanation of a congruence and related assumptions.', 'professional_function_catalog.md'), + ('universalAlgebraDocumentHomomorphism', 'Universal Algebra', '(value)', 'Return a structured explanation of a homomorphism and related assumptions.', 'professional_function_catalog.md'), + ('universalAlgebraDocumentIdentityLaw', 'Universal Algebra', '(value)', 'Return a structured explanation of a identity law and related assumptions.', 'professional_function_catalog.md'), + ('universalAlgebraDocumentSignature', 'Universal Algebra', '(value)', 'Return a structured explanation of a signature and related assumptions.', 'professional_function_catalog.md'), + ('universalAlgebraEnumerateAlgebra', 'Universal Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a algebra.', 'professional_function_catalog.md'), + ('universalAlgebraEnumerateCongruence', 'Universal Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a congruence.', 'professional_function_catalog.md'), + ('universalAlgebraEnumerateHomomorphism', 'Universal Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a homomorphism.', 'professional_function_catalog.md'), + ('universalAlgebraEnumerateIdentityLaw', 'Universal Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a identity law.', 'professional_function_catalog.md'), + ('universalAlgebraEnumerateSignature', 'Universal Algebra', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a signature.', 'professional_function_catalog.md'), + ('universalAlgebraEstimateAlgebra', 'Universal Algebra', '(value, samples=None)', 'Estimate a algebra property from finite samples or approximations.', 'professional_function_catalog.md'), + ('universalAlgebraEstimateCongruence', 'Universal Algebra', '(value, samples=None)', 'Estimate a congruence property from finite samples or approximations.', 'professional_function_catalog.md'), + ('universalAlgebraEstimateHomomorphism', 'Universal Algebra', '(value, samples=None)', 'Estimate a homomorphism property from finite samples or approximations.', 'professional_function_catalog.md'), + ('universalAlgebraEstimateIdentityLaw', 'Universal Algebra', '(value, samples=None)', 'Estimate a identity law property from finite samples or approximations.', 'professional_function_catalog.md'), + ('universalAlgebraEstimateSignature', 'Universal Algebra', '(value, samples=None)', 'Estimate a signature property from finite samples or approximations.', 'professional_function_catalog.md'), + ('universalAlgebraEvaluateAlgebra', 'Universal Algebra', '(value, point=None)', 'Evaluate a algebra at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('universalAlgebraEvaluateCongruence', 'Universal Algebra', '(value, point=None)', 'Evaluate a congruence at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('universalAlgebraEvaluateHomomorphism', 'Universal Algebra', '(value, point=None)', 'Evaluate a homomorphism at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('universalAlgebraEvaluateIdentityLaw', 'Universal Algebra', '(value, point=None)', 'Evaluate a identity law at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('universalAlgebraEvaluateSignature', 'Universal Algebra', '(value, point=None)', 'Evaluate a signature at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('universalAlgebraFormatAlgebra', 'Universal Algebra', '(value)', 'Format a algebra for deterministic user-facing output.', 'professional_function_catalog.md'), + ('universalAlgebraFormatCongruence', 'Universal Algebra', '(value)', 'Format a congruence for deterministic user-facing output.', 'professional_function_catalog.md'), + ('universalAlgebraFormatHomomorphism', 'Universal Algebra', '(value)', 'Format a homomorphism for deterministic user-facing output.', 'professional_function_catalog.md'), + ('universalAlgebraFormatIdentityLaw', 'Universal Algebra', '(value)', 'Format a identity law for deterministic user-facing output.', 'professional_function_catalog.md'), + ('universalAlgebraFormatSignature', 'Universal Algebra', '(value)', 'Format a signature for deterministic user-facing output.', 'professional_function_catalog.md'), + ('universalAlgebraGenerateExampleAlgebra', 'Universal Algebra', '(size=3)', 'Generate a small documented example of a algebra.', 'professional_function_catalog.md'), + ('universalAlgebraGenerateExampleCongruence', 'Universal Algebra', '(size=3)', 'Generate a small documented example of a congruence.', 'professional_function_catalog.md'), + ('universalAlgebraGenerateExampleHomomorphism', 'Universal Algebra', '(size=3)', 'Generate a small documented example of a homomorphism.', 'professional_function_catalog.md'), + ('universalAlgebraGenerateExampleIdentityLaw', 'Universal Algebra', '(size=3)', 'Generate a small documented example of a identity law.', 'professional_function_catalog.md'), + ('universalAlgebraGenerateExampleSignature', 'Universal Algebra', '(size=3)', 'Generate a small documented example of a signature.', 'professional_function_catalog.md'), + ('universalAlgebraNormalizeAlgebra', 'Universal Algebra', '(value)', 'Normalize a algebra into the standard Universal Algebra representation.', 'professional_function_catalog.md'), + ('universalAlgebraNormalizeCongruence', 'Universal Algebra', '(value)', 'Normalize a congruence into the standard Universal Algebra representation.', 'professional_function_catalog.md'), + ('universalAlgebraNormalizeHomomorphism', 'Universal Algebra', '(value)', 'Normalize a homomorphism into the standard Universal Algebra representation.', 'professional_function_catalog.md'), + ('universalAlgebraNormalizeIdentityLaw', 'Universal Algebra', '(value)', 'Normalize a identity law into the standard Universal Algebra representation.', 'professional_function_catalog.md'), + ('universalAlgebraNormalizeSignature', 'Universal Algebra', '(value)', 'Normalize a signature into the standard Universal Algebra representation.', 'professional_function_catalog.md'), + ('universalAlgebraParseAlgebra', 'Universal Algebra', '(text)', 'Parse a text or structured value into a algebra.', 'professional_function_catalog.md'), + ('universalAlgebraParseCongruence', 'Universal Algebra', '(text)', 'Parse a text or structured value into a congruence.', 'professional_function_catalog.md'), + ('universalAlgebraParseHomomorphism', 'Universal Algebra', '(text)', 'Parse a text or structured value into a homomorphism.', 'professional_function_catalog.md'), + ('universalAlgebraParseIdentityLaw', 'Universal Algebra', '(text)', 'Parse a text or structured value into a identity law.', 'professional_function_catalog.md'), + ('universalAlgebraParseSignature', 'Universal Algebra', '(text)', 'Parse a text or structured value into a signature.', 'professional_function_catalog.md'), + ('universalAlgebraSimplifyAlgebra', 'Universal Algebra', '(value)', 'Simplify a algebra without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('universalAlgebraSimplifyCongruence', 'Universal Algebra', '(value)', 'Simplify a congruence without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('universalAlgebraSimplifyHomomorphism', 'Universal Algebra', '(value)', 'Simplify a homomorphism without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('universalAlgebraSimplifyIdentityLaw', 'Universal Algebra', '(value)', 'Simplify a identity law without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('universalAlgebraSimplifySignature', 'Universal Algebra', '(value)', 'Simplify a signature without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('universalAlgebraTestEquivalenceAlgebra', 'Universal Algebra', '(left, right)', 'Test whether two algebra values are equivalent in Universal Algebra.', 'professional_function_catalog.md'), + ('universalAlgebraTestEquivalenceCongruence', 'Universal Algebra', '(left, right)', 'Test whether two congruence values are equivalent in Universal Algebra.', 'professional_function_catalog.md'), + ('universalAlgebraTestEquivalenceHomomorphism', 'Universal Algebra', '(left, right)', 'Test whether two homomorphism values are equivalent in Universal Algebra.', 'professional_function_catalog.md'), + ('universalAlgebraTestEquivalenceIdentityLaw', 'Universal Algebra', '(left, right)', 'Test whether two identity law values are equivalent in Universal Algebra.', 'professional_function_catalog.md'), + ('universalAlgebraTestEquivalenceSignature', 'Universal Algebra', '(left, right)', 'Test whether two signature values are equivalent in Universal Algebra.', 'professional_function_catalog.md'), + ('universalAlgebraTransformAlgebra', 'Universal Algebra', '(value, mapping)', 'Transform a algebra through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('universalAlgebraTransformCongruence', 'Universal Algebra', '(value, mapping)', 'Transform a congruence through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('universalAlgebraTransformHomomorphism', 'Universal Algebra', '(value, mapping)', 'Transform a homomorphism through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('universalAlgebraTransformIdentityLaw', 'Universal Algebra', '(value, mapping)', 'Transform a identity law through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('universalAlgebraTransformSignature', 'Universal Algebra', '(value, mapping)', 'Transform a signature through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('universalAlgebraValidateAlgebra', 'Universal Algebra', '(value)', 'Validate the algebra representation and domain rules for Universal Algebra.', 'professional_function_catalog.md'), + ('universalAlgebraValidateCongruence', 'Universal Algebra', '(value)', 'Validate the congruence representation and domain rules for Universal Algebra.', 'professional_function_catalog.md'), + ('universalAlgebraValidateHomomorphism', 'Universal Algebra', '(value)', 'Validate the homomorphism representation and domain rules for Universal Algebra.', 'professional_function_catalog.md'), + ('universalAlgebraValidateIdentityLaw', 'Universal Algebra', '(value)', 'Validate the identity law representation and domain rules for Universal Algebra.', 'professional_function_catalog.md'), + ('universalAlgebraValidateSignature', 'Universal Algebra', '(value)', 'Validate the signature representation and domain rules for Universal Algebra.', 'professional_function_catalog.md'), + ('detailCoefficients', 'Wavelet Theory', '(values)', 'Planned roadmap function for Wavelet Theory from upcoming.md.', 'upcoming.md'), + ('haarApproximation', 'Wavelet Theory', '(values, level)', 'Planned roadmap function for Wavelet Theory from upcoming.md.', 'upcoming.md'), + ('haarTransform', 'Wavelet Theory', '(values)', 'Planned roadmap function for Wavelet Theory from upcoming.md.', 'upcoming.md'), + ('inverseHaarTransform', 'Wavelet Theory', '(coefficients)', 'Planned roadmap function for Wavelet Theory from upcoming.md.', 'upcoming.md'), + ('multiLevelHaar', 'Wavelet Theory', '(values, levels)', 'Planned roadmap function for Wavelet Theory from upcoming.md.', 'upcoming.md'), + ('reconstructMultiLevelHaar', 'Wavelet Theory', '(data)', 'Planned roadmap function for Wavelet Theory from upcoming.md.', 'upcoming.md'), + ('thresholdCoefficients', 'Wavelet Theory', '(coefficients, threshold)', 'Planned roadmap function for Wavelet Theory from upcoming.md.', 'upcoming.md'), + ('waveletEnergy', 'Wavelet Theory', '(coefficients)', 'Planned roadmap function for Wavelet Theory from upcoming.md.', 'upcoming.md'), + ('waveletTheoryApproximateFilterBank', 'Wavelet Theory', '(value, tolerance=1e-9)', 'Approximate a filter bank with explicit tolerance controls.', 'professional_function_catalog.md'), + ('waveletTheoryApproximateMultiresolutionLevel', 'Wavelet Theory', '(value, tolerance=1e-9)', 'Approximate a multiresolution level with explicit tolerance controls.', 'professional_function_catalog.md'), + ('waveletTheoryApproximateScalingCoefficient', 'Wavelet Theory', '(value, tolerance=1e-9)', 'Approximate a scaling coefficient with explicit tolerance controls.', 'professional_function_catalog.md'), + ('waveletTheoryApproximateSignalDetail', 'Wavelet Theory', '(value, tolerance=1e-9)', 'Approximate a signal detail with explicit tolerance controls.', 'professional_function_catalog.md'), + ('waveletTheoryApproximateWaveletCoefficient', 'Wavelet Theory', '(value, tolerance=1e-9)', 'Approximate a wavelet coefficient with explicit tolerance controls.', 'professional_function_catalog.md'), + ('waveletTheoryCanonicalizeFilterBank', 'Wavelet Theory', '(value)', 'Canonicalize a filter bank so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('waveletTheoryCanonicalizeMultiresolutionLevel', 'Wavelet Theory', '(value)', 'Canonicalize a multiresolution level so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('waveletTheoryCanonicalizeScalingCoefficient', 'Wavelet Theory', '(value)', 'Canonicalize a scaling coefficient so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('waveletTheoryCanonicalizeSignalDetail', 'Wavelet Theory', '(value)', 'Canonicalize a signal detail so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('waveletTheoryCanonicalizeWaveletCoefficient', 'Wavelet Theory', '(value)', 'Canonicalize a wavelet coefficient so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('waveletTheoryClassifyFilterBank', 'Wavelet Theory', '(value)', 'Classify a filter bank by its standard Wavelet Theory invariants.', 'professional_function_catalog.md'), + ('waveletTheoryClassifyMultiresolutionLevel', 'Wavelet Theory', '(value)', 'Classify a multiresolution level by its standard Wavelet Theory invariants.', 'professional_function_catalog.md'), + ('waveletTheoryClassifyScalingCoefficient', 'Wavelet Theory', '(value)', 'Classify a scaling coefficient by its standard Wavelet Theory invariants.', 'professional_function_catalog.md'), + ('waveletTheoryClassifySignalDetail', 'Wavelet Theory', '(value)', 'Classify a signal detail by its standard Wavelet Theory invariants.', 'professional_function_catalog.md'), + ('waveletTheoryClassifyWaveletCoefficient', 'Wavelet Theory', '(value)', 'Classify a wavelet coefficient by its standard Wavelet Theory invariants.', 'professional_function_catalog.md'), + ('waveletTheoryCombineFilterBank', 'Wavelet Theory', '(left, right)', 'Combine two filter bank values with the natural operation for Wavelet Theory.', 'professional_function_catalog.md'), + ('waveletTheoryCombineMultiresolutionLevel', 'Wavelet Theory', '(left, right)', 'Combine two multiresolution level values with the natural operation for Wavelet Theory.', 'professional_function_catalog.md'), + ('waveletTheoryCombineScalingCoefficient', 'Wavelet Theory', '(left, right)', 'Combine two scaling coefficient values with the natural operation for Wavelet Theory.', 'professional_function_catalog.md'), + ('waveletTheoryCombineSignalDetail', 'Wavelet Theory', '(left, right)', 'Combine two signal detail values with the natural operation for Wavelet Theory.', 'professional_function_catalog.md'), + ('waveletTheoryCombineWaveletCoefficient', 'Wavelet Theory', '(left, right)', 'Combine two wavelet coefficient values with the natural operation for Wavelet Theory.', 'professional_function_catalog.md'), + ('waveletTheoryCompareFilterBank', 'Wavelet Theory', '(left, right)', 'Compare two filter bank values under the conventions of Wavelet Theory.', 'professional_function_catalog.md'), + ('waveletTheoryCompareMultiresolutionLevel', 'Wavelet Theory', '(left, right)', 'Compare two multiresolution level values under the conventions of Wavelet Theory.', 'professional_function_catalog.md'), + ('waveletTheoryCompareScalingCoefficient', 'Wavelet Theory', '(left, right)', 'Compare two scaling coefficient values under the conventions of Wavelet Theory.', 'professional_function_catalog.md'), + ('waveletTheoryCompareSignalDetail', 'Wavelet Theory', '(left, right)', 'Compare two signal detail values under the conventions of Wavelet Theory.', 'professional_function_catalog.md'), + ('waveletTheoryCompareWaveletCoefficient', 'Wavelet Theory', '(left, right)', 'Compare two wavelet coefficient values under the conventions of Wavelet Theory.', 'professional_function_catalog.md'), + ('waveletTheoryComputeFilterBank', 'Wavelet Theory', '(value)', 'Compute the central numerical or symbolic data of a filter bank.', 'professional_function_catalog.md'), + ('waveletTheoryComputeMultiresolutionLevel', 'Wavelet Theory', '(value)', 'Compute the central numerical or symbolic data of a multiresolution level.', 'professional_function_catalog.md'), + ('waveletTheoryComputeScalingCoefficient', 'Wavelet Theory', '(value)', 'Compute the central numerical or symbolic data of a scaling coefficient.', 'professional_function_catalog.md'), + ('waveletTheoryComputeSignalDetail', 'Wavelet Theory', '(value)', 'Compute the central numerical or symbolic data of a signal detail.', 'professional_function_catalog.md'), + ('waveletTheoryComputeWaveletCoefficient', 'Wavelet Theory', '(value)', 'Compute the central numerical or symbolic data of a wavelet coefficient.', 'professional_function_catalog.md'), + ('waveletTheoryConstructFilterBank', 'Wavelet Theory', '(*args)', 'Construct a filter bank from explicit inputs for Wavelet Theory.', 'professional_function_catalog.md'), + ('waveletTheoryConstructMultiresolutionLevel', 'Wavelet Theory', '(*args)', 'Construct a multiresolution level from explicit inputs for Wavelet Theory.', 'professional_function_catalog.md'), + ('waveletTheoryConstructScalingCoefficient', 'Wavelet Theory', '(*args)', 'Construct a scaling coefficient from explicit inputs for Wavelet Theory.', 'professional_function_catalog.md'), + ('waveletTheoryConstructSignalDetail', 'Wavelet Theory', '(*args)', 'Construct a signal detail from explicit inputs for Wavelet Theory.', 'professional_function_catalog.md'), + ('waveletTheoryConstructWaveletCoefficient', 'Wavelet Theory', '(*args)', 'Construct a wavelet coefficient from explicit inputs for Wavelet Theory.', 'professional_function_catalog.md'), + ('waveletTheoryDecomposeFilterBank', 'Wavelet Theory', '(value)', 'Decompose a filter bank into simpler or canonical components.', 'professional_function_catalog.md'), + ('waveletTheoryDecomposeMultiresolutionLevel', 'Wavelet Theory', '(value)', 'Decompose a multiresolution level into simpler or canonical components.', 'professional_function_catalog.md'), + ('waveletTheoryDecomposeScalingCoefficient', 'Wavelet Theory', '(value)', 'Decompose a scaling coefficient into simpler or canonical components.', 'professional_function_catalog.md'), + ('waveletTheoryDecomposeSignalDetail', 'Wavelet Theory', '(value)', 'Decompose a signal detail into simpler or canonical components.', 'professional_function_catalog.md'), + ('waveletTheoryDecomposeWaveletCoefficient', 'Wavelet Theory', '(value)', 'Decompose a wavelet coefficient into simpler or canonical components.', 'professional_function_catalog.md'), + ('waveletTheoryDocumentFilterBank', 'Wavelet Theory', '(value)', 'Return a structured explanation of a filter bank and related assumptions.', 'professional_function_catalog.md'), + ('waveletTheoryDocumentMultiresolutionLevel', 'Wavelet Theory', '(value)', 'Return a structured explanation of a multiresolution level and related assumptions.', 'professional_function_catalog.md'), + ('waveletTheoryDocumentScalingCoefficient', 'Wavelet Theory', '(value)', 'Return a structured explanation of a scaling coefficient and related assumptions.', 'professional_function_catalog.md'), + ('waveletTheoryDocumentSignalDetail', 'Wavelet Theory', '(value)', 'Return a structured explanation of a signal detail and related assumptions.', 'professional_function_catalog.md'), + ('waveletTheoryDocumentWaveletCoefficient', 'Wavelet Theory', '(value)', 'Return a structured explanation of a wavelet coefficient and related assumptions.', 'professional_function_catalog.md'), + ('waveletTheoryEnumerateFilterBank', 'Wavelet Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a filter bank.', 'professional_function_catalog.md'), + ('waveletTheoryEnumerateMultiresolutionLevel', 'Wavelet Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a multiresolution level.', 'professional_function_catalog.md'), + ('waveletTheoryEnumerateScalingCoefficient', 'Wavelet Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a scaling coefficient.', 'professional_function_catalog.md'), + ('waveletTheoryEnumerateSignalDetail', 'Wavelet Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a signal detail.', 'professional_function_catalog.md'), + ('waveletTheoryEnumerateWaveletCoefficient', 'Wavelet Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a wavelet coefficient.', 'professional_function_catalog.md'), + ('waveletTheoryEstimateFilterBank', 'Wavelet Theory', '(value, samples=None)', 'Estimate a filter bank property from finite samples or approximations.', 'professional_function_catalog.md'), + ('waveletTheoryEstimateMultiresolutionLevel', 'Wavelet Theory', '(value, samples=None)', 'Estimate a multiresolution level property from finite samples or approximations.', 'professional_function_catalog.md'), + ('waveletTheoryEstimateScalingCoefficient', 'Wavelet Theory', '(value, samples=None)', 'Estimate a scaling coefficient property from finite samples or approximations.', 'professional_function_catalog.md'), + ('waveletTheoryEstimateSignalDetail', 'Wavelet Theory', '(value, samples=None)', 'Estimate a signal detail property from finite samples or approximations.', 'professional_function_catalog.md'), + ('waveletTheoryEstimateWaveletCoefficient', 'Wavelet Theory', '(value, samples=None)', 'Estimate a wavelet coefficient property from finite samples or approximations.', 'professional_function_catalog.md'), + ('waveletTheoryEvaluateFilterBank', 'Wavelet Theory', '(value, point=None)', 'Evaluate a filter bank at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('waveletTheoryEvaluateMultiresolutionLevel', 'Wavelet Theory', '(value, point=None)', 'Evaluate a multiresolution level at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('waveletTheoryEvaluateScalingCoefficient', 'Wavelet Theory', '(value, point=None)', 'Evaluate a scaling coefficient at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('waveletTheoryEvaluateSignalDetail', 'Wavelet Theory', '(value, point=None)', 'Evaluate a signal detail at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('waveletTheoryEvaluateWaveletCoefficient', 'Wavelet Theory', '(value, point=None)', 'Evaluate a wavelet coefficient at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('waveletTheoryFormatFilterBank', 'Wavelet Theory', '(value)', 'Format a filter bank for deterministic user-facing output.', 'professional_function_catalog.md'), + ('waveletTheoryFormatMultiresolutionLevel', 'Wavelet Theory', '(value)', 'Format a multiresolution level for deterministic user-facing output.', 'professional_function_catalog.md'), + ('waveletTheoryFormatScalingCoefficient', 'Wavelet Theory', '(value)', 'Format a scaling coefficient for deterministic user-facing output.', 'professional_function_catalog.md'), + ('waveletTheoryFormatSignalDetail', 'Wavelet Theory', '(value)', 'Format a signal detail for deterministic user-facing output.', 'professional_function_catalog.md'), + ('waveletTheoryFormatWaveletCoefficient', 'Wavelet Theory', '(value)', 'Format a wavelet coefficient for deterministic user-facing output.', 'professional_function_catalog.md'), + ('waveletTheoryGenerateExampleFilterBank', 'Wavelet Theory', '(size=3)', 'Generate a small documented example of a filter bank.', 'professional_function_catalog.md'), + ('waveletTheoryGenerateExampleMultiresolutionLevel', 'Wavelet Theory', '(size=3)', 'Generate a small documented example of a multiresolution level.', 'professional_function_catalog.md'), + ('waveletTheoryGenerateExampleScalingCoefficient', 'Wavelet Theory', '(size=3)', 'Generate a small documented example of a scaling coefficient.', 'professional_function_catalog.md'), + ('waveletTheoryGenerateExampleSignalDetail', 'Wavelet Theory', '(size=3)', 'Generate a small documented example of a signal detail.', 'professional_function_catalog.md'), + ('waveletTheoryGenerateExampleWaveletCoefficient', 'Wavelet Theory', '(size=3)', 'Generate a small documented example of a wavelet coefficient.', 'professional_function_catalog.md'), + ('waveletTheoryNormalizeFilterBank', 'Wavelet Theory', '(value)', 'Normalize a filter bank into the standard Wavelet Theory representation.', 'professional_function_catalog.md'), + ('waveletTheoryNormalizeMultiresolutionLevel', 'Wavelet Theory', '(value)', 'Normalize a multiresolution level into the standard Wavelet Theory representation.', 'professional_function_catalog.md'), + ('waveletTheoryNormalizeScalingCoefficient', 'Wavelet Theory', '(value)', 'Normalize a scaling coefficient into the standard Wavelet Theory representation.', 'professional_function_catalog.md'), + ('waveletTheoryNormalizeSignalDetail', 'Wavelet Theory', '(value)', 'Normalize a signal detail into the standard Wavelet Theory representation.', 'professional_function_catalog.md'), + ('waveletTheoryNormalizeWaveletCoefficient', 'Wavelet Theory', '(value)', 'Normalize a wavelet coefficient into the standard Wavelet Theory representation.', 'professional_function_catalog.md'), + ('waveletTheoryParseFilterBank', 'Wavelet Theory', '(text)', 'Parse a text or structured value into a filter bank.', 'professional_function_catalog.md'), + ('waveletTheoryParseMultiresolutionLevel', 'Wavelet Theory', '(text)', 'Parse a text or structured value into a multiresolution level.', 'professional_function_catalog.md'), + ('waveletTheoryParseScalingCoefficient', 'Wavelet Theory', '(text)', 'Parse a text or structured value into a scaling coefficient.', 'professional_function_catalog.md'), + ('waveletTheoryParseSignalDetail', 'Wavelet Theory', '(text)', 'Parse a text or structured value into a signal detail.', 'professional_function_catalog.md'), + ('waveletTheoryParseWaveletCoefficient', 'Wavelet Theory', '(text)', 'Parse a text or structured value into a wavelet coefficient.', 'professional_function_catalog.md'), + ('waveletTheorySimplifyFilterBank', 'Wavelet Theory', '(value)', 'Simplify a filter bank without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('waveletTheorySimplifyMultiresolutionLevel', 'Wavelet Theory', '(value)', 'Simplify a multiresolution level without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('waveletTheorySimplifyScalingCoefficient', 'Wavelet Theory', '(value)', 'Simplify a scaling coefficient without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('waveletTheorySimplifySignalDetail', 'Wavelet Theory', '(value)', 'Simplify a signal detail without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('waveletTheorySimplifyWaveletCoefficient', 'Wavelet Theory', '(value)', 'Simplify a wavelet coefficient without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('waveletTheoryTestEquivalenceFilterBank', 'Wavelet Theory', '(left, right)', 'Test whether two filter bank values are equivalent in Wavelet Theory.', 'professional_function_catalog.md'), + ('waveletTheoryTestEquivalenceMultiresolutionLevel', 'Wavelet Theory', '(left, right)', 'Test whether two multiresolution level values are equivalent in Wavelet Theory.', 'professional_function_catalog.md'), + ('waveletTheoryTestEquivalenceScalingCoefficient', 'Wavelet Theory', '(left, right)', 'Test whether two scaling coefficient values are equivalent in Wavelet Theory.', 'professional_function_catalog.md'), + ('waveletTheoryTestEquivalenceSignalDetail', 'Wavelet Theory', '(left, right)', 'Test whether two signal detail values are equivalent in Wavelet Theory.', 'professional_function_catalog.md'), + ('waveletTheoryTestEquivalenceWaveletCoefficient', 'Wavelet Theory', '(left, right)', 'Test whether two wavelet coefficient values are equivalent in Wavelet Theory.', 'professional_function_catalog.md'), + ('waveletTheoryTransformFilterBank', 'Wavelet Theory', '(value, mapping)', 'Transform a filter bank through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('waveletTheoryTransformMultiresolutionLevel', 'Wavelet Theory', '(value, mapping)', 'Transform a multiresolution level through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('waveletTheoryTransformScalingCoefficient', 'Wavelet Theory', '(value, mapping)', 'Transform a scaling coefficient through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('waveletTheoryTransformSignalDetail', 'Wavelet Theory', '(value, mapping)', 'Transform a signal detail through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('waveletTheoryTransformWaveletCoefficient', 'Wavelet Theory', '(value, mapping)', 'Transform a wavelet coefficient through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('waveletTheoryValidateFilterBank', 'Wavelet Theory', '(value)', 'Validate the filter bank representation and domain rules for Wavelet Theory.', 'professional_function_catalog.md'), + ('waveletTheoryValidateMultiresolutionLevel', 'Wavelet Theory', '(value)', 'Validate the multiresolution level representation and domain rules for Wavelet Theory.', 'professional_function_catalog.md'), + ('waveletTheoryValidateScalingCoefficient', 'Wavelet Theory', '(value)', 'Validate the scaling coefficient representation and domain rules for Wavelet Theory.', 'professional_function_catalog.md'), + ('waveletTheoryValidateSignalDetail', 'Wavelet Theory', '(value)', 'Validate the signal detail representation and domain rules for Wavelet Theory.', 'professional_function_catalog.md'), + ('waveletTheoryValidateWaveletCoefficient', 'Wavelet Theory', '(value)', 'Validate the wavelet coefficient representation and domain rules for Wavelet Theory.', 'professional_function_catalog.md'), + ('cartesianProductAxiom', 'ZFC Axiomatic Set Theory', '(set1, set2)', 'Planned roadmap function for ZFC Axiomatic Set Theory from upcoming.md.', 'upcoming.md'), + ('finiteCardinalEquivalent', 'ZFC Axiomatic Set Theory', '(set1, set2)', 'Planned roadmap function for ZFC Axiomatic Set Theory from upcoming.md.', 'upcoming.md'), + ('orderedPair', 'ZFC Axiomatic Set Theory', '(a, b)', 'Planned roadmap function for ZFC Axiomatic Set Theory from upcoming.md.', 'upcoming.md'), + ('ordinalLessThan', 'ZFC Axiomatic Set Theory', '(a, b)', 'Planned roadmap function for ZFC Axiomatic Set Theory from upcoming.md.', 'upcoming.md'), + ('powerSetAxiom', 'ZFC Axiomatic Set Theory', '(set)', 'Planned roadmap function for ZFC Axiomatic Set Theory from upcoming.md.', 'upcoming.md'), + ('successorOrdinal', 'ZFC Axiomatic Set Theory', '(n)', 'Planned roadmap function for ZFC Axiomatic Set Theory from upcoming.md.', 'upcoming.md'), + ('transitiveSet', 'ZFC Axiomatic Set Theory', '(set)', 'Planned roadmap function for ZFC Axiomatic Set Theory from upcoming.md.', 'upcoming.md'), + ('vonNeumannOrdinal', 'ZFC Axiomatic Set Theory', '(n)', 'Planned roadmap function for ZFC Axiomatic Set Theory from upcoming.md.', 'upcoming.md'), + ('zfcAxiomaticSetTheoryApproximateAxiomModel', 'ZFC Axiomatic Set Theory', '(value, tolerance=1e-9)', 'Approximate a axiom model with explicit tolerance controls.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryApproximateCardinal', 'ZFC Axiomatic Set Theory', '(value, tolerance=1e-9)', 'Approximate a cardinal with explicit tolerance controls.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryApproximateMembershipStructure', 'ZFC Axiomatic Set Theory', '(value, tolerance=1e-9)', 'Approximate a membership structure with explicit tolerance controls.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryApproximateOrdinal', 'ZFC Axiomatic Set Theory', '(value, tolerance=1e-9)', 'Approximate a ordinal with explicit tolerance controls.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryApproximateSetConstruction', 'ZFC Axiomatic Set Theory', '(value, tolerance=1e-9)', 'Approximate a set construction with explicit tolerance controls.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryCanonicalizeAxiomModel', 'ZFC Axiomatic Set Theory', '(value)', 'Canonicalize a axiom model so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryCanonicalizeCardinal', 'ZFC Axiomatic Set Theory', '(value)', 'Canonicalize a cardinal so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryCanonicalizeMembershipStructure', 'ZFC Axiomatic Set Theory', '(value)', 'Canonicalize a membership structure so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryCanonicalizeOrdinal', 'ZFC Axiomatic Set Theory', '(value)', 'Canonicalize a ordinal so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryCanonicalizeSetConstruction', 'ZFC Axiomatic Set Theory', '(value)', 'Canonicalize a set construction so equivalent inputs share one form.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryClassifyAxiomModel', 'ZFC Axiomatic Set Theory', '(value)', 'Classify a axiom model by its standard ZFC Axiomatic Set Theory invariants.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryClassifyCardinal', 'ZFC Axiomatic Set Theory', '(value)', 'Classify a cardinal by its standard ZFC Axiomatic Set Theory invariants.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryClassifyMembershipStructure', 'ZFC Axiomatic Set Theory', '(value)', 'Classify a membership structure by its standard ZFC Axiomatic Set Theory invariants.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryClassifyOrdinal', 'ZFC Axiomatic Set Theory', '(value)', 'Classify a ordinal by its standard ZFC Axiomatic Set Theory invariants.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryClassifySetConstruction', 'ZFC Axiomatic Set Theory', '(value)', 'Classify a set construction by its standard ZFC Axiomatic Set Theory invariants.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryCombineAxiomModel', 'ZFC Axiomatic Set Theory', '(left, right)', 'Combine two axiom model values with the natural operation for ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryCombineCardinal', 'ZFC Axiomatic Set Theory', '(left, right)', 'Combine two cardinal values with the natural operation for ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryCombineMembershipStructure', 'ZFC Axiomatic Set Theory', '(left, right)', 'Combine two membership structure values with the natural operation for ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryCombineOrdinal', 'ZFC Axiomatic Set Theory', '(left, right)', 'Combine two ordinal values with the natural operation for ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryCombineSetConstruction', 'ZFC Axiomatic Set Theory', '(left, right)', 'Combine two set construction values with the natural operation for ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryCompareAxiomModel', 'ZFC Axiomatic Set Theory', '(left, right)', 'Compare two axiom model values under the conventions of ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryCompareCardinal', 'ZFC Axiomatic Set Theory', '(left, right)', 'Compare two cardinal values under the conventions of ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryCompareMembershipStructure', 'ZFC Axiomatic Set Theory', '(left, right)', 'Compare two membership structure values under the conventions of ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryCompareOrdinal', 'ZFC Axiomatic Set Theory', '(left, right)', 'Compare two ordinal values under the conventions of ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryCompareSetConstruction', 'ZFC Axiomatic Set Theory', '(left, right)', 'Compare two set construction values under the conventions of ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryComputeAxiomModel', 'ZFC Axiomatic Set Theory', '(value)', 'Compute the central numerical or symbolic data of a axiom model.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryComputeCardinal', 'ZFC Axiomatic Set Theory', '(value)', 'Compute the central numerical or symbolic data of a cardinal.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryComputeMembershipStructure', 'ZFC Axiomatic Set Theory', '(value)', 'Compute the central numerical or symbolic data of a membership structure.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryComputeOrdinal', 'ZFC Axiomatic Set Theory', '(value)', 'Compute the central numerical or symbolic data of a ordinal.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryComputeSetConstruction', 'ZFC Axiomatic Set Theory', '(value)', 'Compute the central numerical or symbolic data of a set construction.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryConstructAxiomModel', 'ZFC Axiomatic Set Theory', '(*args)', 'Construct a axiom model from explicit inputs for ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryConstructCardinal', 'ZFC Axiomatic Set Theory', '(*args)', 'Construct a cardinal from explicit inputs for ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryConstructMembershipStructure', 'ZFC Axiomatic Set Theory', '(*args)', 'Construct a membership structure from explicit inputs for ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryConstructOrdinal', 'ZFC Axiomatic Set Theory', '(*args)', 'Construct a ordinal from explicit inputs for ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryConstructSetConstruction', 'ZFC Axiomatic Set Theory', '(*args)', 'Construct a set construction from explicit inputs for ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryDecomposeAxiomModel', 'ZFC Axiomatic Set Theory', '(value)', 'Decompose a axiom model into simpler or canonical components.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryDecomposeCardinal', 'ZFC Axiomatic Set Theory', '(value)', 'Decompose a cardinal into simpler or canonical components.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryDecomposeMembershipStructure', 'ZFC Axiomatic Set Theory', '(value)', 'Decompose a membership structure into simpler or canonical components.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryDecomposeOrdinal', 'ZFC Axiomatic Set Theory', '(value)', 'Decompose a ordinal into simpler or canonical components.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryDecomposeSetConstruction', 'ZFC Axiomatic Set Theory', '(value)', 'Decompose a set construction into simpler or canonical components.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryDocumentAxiomModel', 'ZFC Axiomatic Set Theory', '(value)', 'Return a structured explanation of a axiom model and related assumptions.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryDocumentCardinal', 'ZFC Axiomatic Set Theory', '(value)', 'Return a structured explanation of a cardinal and related assumptions.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryDocumentMembershipStructure', 'ZFC Axiomatic Set Theory', '(value)', 'Return a structured explanation of a membership structure and related assumptions.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryDocumentOrdinal', 'ZFC Axiomatic Set Theory', '(value)', 'Return a structured explanation of a ordinal and related assumptions.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryDocumentSetConstruction', 'ZFC Axiomatic Set Theory', '(value)', 'Return a structured explanation of a set construction and related assumptions.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryEnumerateAxiomModel', 'ZFC Axiomatic Set Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a axiom model.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryEnumerateCardinal', 'ZFC Axiomatic Set Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a cardinal.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryEnumerateMembershipStructure', 'ZFC Axiomatic Set Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a membership structure.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryEnumerateOrdinal', 'ZFC Axiomatic Set Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a ordinal.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryEnumerateSetConstruction', 'ZFC Axiomatic Set Theory', '(value, limit=None)', 'Enumerate finite members, cases, or derived objects for a set construction.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryEstimateAxiomModel', 'ZFC Axiomatic Set Theory', '(value, samples=None)', 'Estimate a axiom model property from finite samples or approximations.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryEstimateCardinal', 'ZFC Axiomatic Set Theory', '(value, samples=None)', 'Estimate a cardinal property from finite samples or approximations.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryEstimateMembershipStructure', 'ZFC Axiomatic Set Theory', '(value, samples=None)', 'Estimate a membership structure property from finite samples or approximations.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryEstimateOrdinal', 'ZFC Axiomatic Set Theory', '(value, samples=None)', 'Estimate a ordinal property from finite samples or approximations.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryEstimateSetConstruction', 'ZFC Axiomatic Set Theory', '(value, samples=None)', 'Estimate a set construction property from finite samples or approximations.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryEvaluateAxiomModel', 'ZFC Axiomatic Set Theory', '(value, point=None)', 'Evaluate a axiom model at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryEvaluateCardinal', 'ZFC Axiomatic Set Theory', '(value, point=None)', 'Evaluate a cardinal at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryEvaluateMembershipStructure', 'ZFC Axiomatic Set Theory', '(value, point=None)', 'Evaluate a membership structure at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryEvaluateOrdinal', 'ZFC Axiomatic Set Theory', '(value, point=None)', 'Evaluate a ordinal at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryEvaluateSetConstruction', 'ZFC Axiomatic Set Theory', '(value, point=None)', 'Evaluate a set construction at a point, sample, or finite model.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryFormatAxiomModel', 'ZFC Axiomatic Set Theory', '(value)', 'Format a axiom model for deterministic user-facing output.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryFormatCardinal', 'ZFC Axiomatic Set Theory', '(value)', 'Format a cardinal for deterministic user-facing output.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryFormatMembershipStructure', 'ZFC Axiomatic Set Theory', '(value)', 'Format a membership structure for deterministic user-facing output.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryFormatOrdinal', 'ZFC Axiomatic Set Theory', '(value)', 'Format a ordinal for deterministic user-facing output.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryFormatSetConstruction', 'ZFC Axiomatic Set Theory', '(value)', 'Format a set construction for deterministic user-facing output.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryGenerateExampleAxiomModel', 'ZFC Axiomatic Set Theory', '(size=3)', 'Generate a small documented example of a axiom model.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryGenerateExampleCardinal', 'ZFC Axiomatic Set Theory', '(size=3)', 'Generate a small documented example of a cardinal.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryGenerateExampleMembershipStructure', 'ZFC Axiomatic Set Theory', '(size=3)', 'Generate a small documented example of a membership structure.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryGenerateExampleOrdinal', 'ZFC Axiomatic Set Theory', '(size=3)', 'Generate a small documented example of a ordinal.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryGenerateExampleSetConstruction', 'ZFC Axiomatic Set Theory', '(size=3)', 'Generate a small documented example of a set construction.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryNormalizeAxiomModel', 'ZFC Axiomatic Set Theory', '(value)', 'Normalize a axiom model into the standard ZFC Axiomatic Set Theory representation.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryNormalizeCardinal', 'ZFC Axiomatic Set Theory', '(value)', 'Normalize a cardinal into the standard ZFC Axiomatic Set Theory representation.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryNormalizeMembershipStructure', 'ZFC Axiomatic Set Theory', '(value)', 'Normalize a membership structure into the standard ZFC Axiomatic Set Theory representation.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryNormalizeOrdinal', 'ZFC Axiomatic Set Theory', '(value)', 'Normalize a ordinal into the standard ZFC Axiomatic Set Theory representation.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryNormalizeSetConstruction', 'ZFC Axiomatic Set Theory', '(value)', 'Normalize a set construction into the standard ZFC Axiomatic Set Theory representation.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryParseAxiomModel', 'ZFC Axiomatic Set Theory', '(text)', 'Parse a text or structured value into a axiom model.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryParseCardinal', 'ZFC Axiomatic Set Theory', '(text)', 'Parse a text or structured value into a cardinal.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryParseMembershipStructure', 'ZFC Axiomatic Set Theory', '(text)', 'Parse a text or structured value into a membership structure.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryParseOrdinal', 'ZFC Axiomatic Set Theory', '(text)', 'Parse a text or structured value into a ordinal.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryParseSetConstruction', 'ZFC Axiomatic Set Theory', '(text)', 'Parse a text or structured value into a set construction.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheorySimplifyAxiomModel', 'ZFC Axiomatic Set Theory', '(value)', 'Simplify a axiom model without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheorySimplifyCardinal', 'ZFC Axiomatic Set Theory', '(value)', 'Simplify a cardinal without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheorySimplifyMembershipStructure', 'ZFC Axiomatic Set Theory', '(value)', 'Simplify a membership structure without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheorySimplifyOrdinal', 'ZFC Axiomatic Set Theory', '(value)', 'Simplify a ordinal without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheorySimplifySetConstruction', 'ZFC Axiomatic Set Theory', '(value)', 'Simplify a set construction without changing its mathematical meaning.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryTestEquivalenceAxiomModel', 'ZFC Axiomatic Set Theory', '(left, right)', 'Test whether two axiom model values are equivalent in ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryTestEquivalenceCardinal', 'ZFC Axiomatic Set Theory', '(left, right)', 'Test whether two cardinal values are equivalent in ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryTestEquivalenceMembershipStructure', 'ZFC Axiomatic Set Theory', '(left, right)', 'Test whether two membership structure values are equivalent in ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryTestEquivalenceOrdinal', 'ZFC Axiomatic Set Theory', '(left, right)', 'Test whether two ordinal values are equivalent in ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryTestEquivalenceSetConstruction', 'ZFC Axiomatic Set Theory', '(left, right)', 'Test whether two set construction values are equivalent in ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryTransformAxiomModel', 'ZFC Axiomatic Set Theory', '(value, mapping)', 'Transform a axiom model through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryTransformCardinal', 'ZFC Axiomatic Set Theory', '(value, mapping)', 'Transform a cardinal through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryTransformMembershipStructure', 'ZFC Axiomatic Set Theory', '(value, mapping)', 'Transform a membership structure through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryTransformOrdinal', 'ZFC Axiomatic Set Theory', '(value, mapping)', 'Transform a ordinal through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryTransformSetConstruction', 'ZFC Axiomatic Set Theory', '(value, mapping)', 'Transform a set construction through a map, operator, or representation change.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryValidateAxiomModel', 'ZFC Axiomatic Set Theory', '(value)', 'Validate the axiom model representation and domain rules for ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryValidateCardinal', 'ZFC Axiomatic Set Theory', '(value)', 'Validate the cardinal representation and domain rules for ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryValidateMembershipStructure', 'ZFC Axiomatic Set Theory', '(value)', 'Validate the membership structure representation and domain rules for ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryValidateOrdinal', 'ZFC Axiomatic Set Theory', '(value)', 'Validate the ordinal representation and domain rules for ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), + ('zfcAxiomaticSetTheoryValidateSetConstruction', 'ZFC Axiomatic Set Theory', '(value)', 'Validate the set construction representation and domain rules for ZFC Axiomatic Set Theory.', 'professional_function_catalog.md'), +) + +UPCOMING_FUNCTION_ENTRIES = tuple(UpcomingFunction(*entry) for entry in _RAW_FUNCTIONS) + +UPCOMING_FUNCTIONS = {} +for entry in UPCOMING_FUNCTION_ENTRIES: + UPCOMING_FUNCTIONS.setdefault(entry.name, []).append(entry) +UPCOMING_FUNCTIONS = {name: tuple(values) for name, values in UPCOMING_FUNCTIONS.items()} + +UPCOMING_TOPICS = {} +for entry in UPCOMING_FUNCTION_ENTRIES: + UPCOMING_TOPICS.setdefault(entry.topic, []).append(entry) +UPCOMING_TOPICS = {topic: tuple(values) for topic, values in UPCOMING_TOPICS.items()} + + +class UpcomingFunctionNotImplemented(NotImplementedError): + """Raised when a planned roadmap function is called before implementation.""" + + +def list_upcoming_topics(): + """Return all roadmap topics that have planned function metadata.""" + + return tuple(sorted(UPCOMING_TOPICS)) + + +def list_upcoming_functions(topic=None): + """Return planned function names, optionally filtered by topic.""" + + if topic is None: + return tuple(sorted(UPCOMING_FUNCTIONS)) + return tuple(sorted({entry.name for entry in UPCOMING_TOPICS.get(topic, ())})) + + +def get_upcoming_function_metadata(name): + """Return all metadata entries for a planned function name.""" + + return UPCOMING_FUNCTIONS.get(name, ()) + + +def is_upcoming_function(name): + """Return True when name is registered as a planned function.""" + + return name in UPCOMING_FUNCTIONS + + +def _make_upcoming_function(name): + entries = UPCOMING_FUNCTIONS[name] + topics = tuple(sorted({entry.topic for entry in entries})) + signatures = tuple(sorted({entry.signature for entry in entries})) + + def upcoming_function(*args, **kwargs): + topic_text = ", ".join(topics) + raise UpcomingFunctionNotImplemented( + f"{name} is a planned mathfunctionize API for: {topic_text}. " + "See upcoming.md and professional_function_catalog.md for scope, " + "then replace this placeholder with a tested implementation." + ) + + upcoming_function.__name__ = name + upcoming_function.__qualname__ = name + upcoming_function.__doc__ = ( + f"Planned mathfunctionize function for {', '.join(topics)}. " + f"Roadmap signatures: {'; '.join(signatures)}. " + "Raises UpcomingFunctionNotImplemented until implemented." + ) + return upcoming_function + + +def install_upcoming_functions(namespace, overwrite=False): + """Install planned function placeholders into a namespace dictionary.""" + + installed = [] + for name in sorted(UPCOMING_FUNCTIONS): + if overwrite or name not in namespace: + namespace[name] = _make_upcoming_function(name) + installed.append(name) + return tuple(installed) + + +_INSTALLED_NAMES = install_upcoming_functions(globals(), overwrite=False) + +__all__ = ( + 'UpcomingFunction', + 'UpcomingFunctionNotImplemented', + 'UPCOMING_FUNCTION_ENTRIES', + 'UPCOMING_FUNCTIONS', + 'UPCOMING_TOPICS', + 'get_upcoming_function_metadata', + 'install_upcoming_functions', + 'is_upcoming_function', + 'list_upcoming_functions', + 'list_upcoming_topics', +) + _INSTALLED_NAMES diff --git a/professional_function_catalog.md b/professional_function_catalog.md new file mode 100644 index 0000000..4778edd --- /dev/null +++ b/professional_function_catalog.md @@ -0,0 +1,9739 @@ +# Professional function catalog + +This catalog expands `upcoming.md` into a professional API backlog. +Every roadmap topic below contains exactly 100 candidate functions, built +from five core object families and twenty implementation capabilities. The +catalog includes validators, constructors, transformations, computations, +approximations, classification helpers, examples, and documentation helpers +because mature mathematical APIs need stable representations as well as +high-level algorithms. + +The names are planning targets, not final public API commitments. Before +implementation, each group should be reviewed for naming consistency with the +existing flat `mathfunctionize` API. + +## Count summary + +- Topics covered: 86 +- Candidate functions per topic: 100 +- Total candidate functions: 8600 + +## Topic catalogs + +### Constants + +Core object families: + +- named constant +- constant registry +- precision profile +- numeric approximation +- constant identity + +Candidate functions: + +1. `constantsValidateNamedConstant(value)` - Validate the named constant representation and domain rules for Constants. +2. `constantsConstructNamedConstant(*args)` - Construct a named constant from explicit inputs for Constants. +3. `constantsNormalizeNamedConstant(value)` - Normalize a named constant into the standard Constants representation. +4. `constantsCanonicalizeNamedConstant(value)` - Canonicalize a named constant so equivalent inputs share one form. +5. `constantsParseNamedConstant(text)` - Parse a text or structured value into a named constant. +6. `constantsFormatNamedConstant(value)` - Format a named constant for deterministic user-facing output. +7. `constantsCompareNamedConstant(left, right)` - Compare two named constant values under the conventions of Constants. +8. `constantsCombineNamedConstant(left, right)` - Combine two named constant values with the natural operation for Constants. +9. `constantsDecomposeNamedConstant(value)` - Decompose a named constant into simpler or canonical components. +10. `constantsEvaluateNamedConstant(value, point=None)` - Evaluate a named constant at a point, sample, or finite model. +11. `constantsComputeNamedConstant(value)` - Compute the central numerical or symbolic data of a named constant. +12. `constantsEstimateNamedConstant(value, samples=None)` - Estimate a named constant property from finite samples or approximations. +13. `constantsApproximateNamedConstant(value, tolerance=1e-9)` - Approximate a named constant with explicit tolerance controls. +14. `constantsTransformNamedConstant(value, mapping)` - Transform a named constant through a map, operator, or representation change. +15. `constantsSimplifyNamedConstant(value)` - Simplify a named constant without changing its mathematical meaning. +16. `constantsEnumerateNamedConstant(value, limit=None)` - Enumerate finite members, cases, or derived objects for a named constant. +17. `constantsClassifyNamedConstant(value)` - Classify a named constant by its standard Constants invariants. +18. `constantsTestEquivalenceNamedConstant(left, right)` - Test whether two named constant values are equivalent in Constants. +19. `constantsGenerateExampleNamedConstant(size=3)` - Generate a small documented example of a named constant. +20. `constantsDocumentNamedConstant(value)` - Return a structured explanation of a named constant and related assumptions. +21. `constantsValidateConstantRegistry(value)` - Validate the constant registry representation and domain rules for Constants. +22. `constantsConstructConstantRegistry(*args)` - Construct a constant registry from explicit inputs for Constants. +23. `constantsNormalizeConstantRegistry(value)` - Normalize a constant registry into the standard Constants representation. +24. `constantsCanonicalizeConstantRegistry(value)` - Canonicalize a constant registry so equivalent inputs share one form. +25. `constantsParseConstantRegistry(text)` - Parse a text or structured value into a constant registry. +26. `constantsFormatConstantRegistry(value)` - Format a constant registry for deterministic user-facing output. +27. `constantsCompareConstantRegistry(left, right)` - Compare two constant registry values under the conventions of Constants. +28. `constantsCombineConstantRegistry(left, right)` - Combine two constant registry values with the natural operation for Constants. +29. `constantsDecomposeConstantRegistry(value)` - Decompose a constant registry into simpler or canonical components. +30. `constantsEvaluateConstantRegistry(value, point=None)` - Evaluate a constant registry at a point, sample, or finite model. +31. `constantsComputeConstantRegistry(value)` - Compute the central numerical or symbolic data of a constant registry. +32. `constantsEstimateConstantRegistry(value, samples=None)` - Estimate a constant registry property from finite samples or approximations. +33. `constantsApproximateConstantRegistry(value, tolerance=1e-9)` - Approximate a constant registry with explicit tolerance controls. +34. `constantsTransformConstantRegistry(value, mapping)` - Transform a constant registry through a map, operator, or representation change. +35. `constantsSimplifyConstantRegistry(value)` - Simplify a constant registry without changing its mathematical meaning. +36. `constantsEnumerateConstantRegistry(value, limit=None)` - Enumerate finite members, cases, or derived objects for a constant registry. +37. `constantsClassifyConstantRegistry(value)` - Classify a constant registry by its standard Constants invariants. +38. `constantsTestEquivalenceConstantRegistry(left, right)` - Test whether two constant registry values are equivalent in Constants. +39. `constantsGenerateExampleConstantRegistry(size=3)` - Generate a small documented example of a constant registry. +40. `constantsDocumentConstantRegistry(value)` - Return a structured explanation of a constant registry and related assumptions. +41. `constantsValidatePrecisionProfile(value)` - Validate the precision profile representation and domain rules for Constants. +42. `constantsConstructPrecisionProfile(*args)` - Construct a precision profile from explicit inputs for Constants. +43. `constantsNormalizePrecisionProfile(value)` - Normalize a precision profile into the standard Constants representation. +44. `constantsCanonicalizePrecisionProfile(value)` - Canonicalize a precision profile so equivalent inputs share one form. +45. `constantsParsePrecisionProfile(text)` - Parse a text or structured value into a precision profile. +46. `constantsFormatPrecisionProfile(value)` - Format a precision profile for deterministic user-facing output. +47. `constantsComparePrecisionProfile(left, right)` - Compare two precision profile values under the conventions of Constants. +48. `constantsCombinePrecisionProfile(left, right)` - Combine two precision profile values with the natural operation for Constants. +49. `constantsDecomposePrecisionProfile(value)` - Decompose a precision profile into simpler or canonical components. +50. `constantsEvaluatePrecisionProfile(value, point=None)` - Evaluate a precision profile at a point, sample, or finite model. +51. `constantsComputePrecisionProfile(value)` - Compute the central numerical or symbolic data of a precision profile. +52. `constantsEstimatePrecisionProfile(value, samples=None)` - Estimate a precision profile property from finite samples or approximations. +53. `constantsApproximatePrecisionProfile(value, tolerance=1e-9)` - Approximate a precision profile with explicit tolerance controls. +54. `constantsTransformPrecisionProfile(value, mapping)` - Transform a precision profile through a map, operator, or representation change. +55. `constantsSimplifyPrecisionProfile(value)` - Simplify a precision profile without changing its mathematical meaning. +56. `constantsEnumeratePrecisionProfile(value, limit=None)` - Enumerate finite members, cases, or derived objects for a precision profile. +57. `constantsClassifyPrecisionProfile(value)` - Classify a precision profile by its standard Constants invariants. +58. `constantsTestEquivalencePrecisionProfile(left, right)` - Test whether two precision profile values are equivalent in Constants. +59. `constantsGenerateExamplePrecisionProfile(size=3)` - Generate a small documented example of a precision profile. +60. `constantsDocumentPrecisionProfile(value)` - Return a structured explanation of a precision profile and related assumptions. +61. `constantsValidateNumericApproximation(value)` - Validate the numeric approximation representation and domain rules for Constants. +62. `constantsConstructNumericApproximation(*args)` - Construct a numeric approximation from explicit inputs for Constants. +63. `constantsNormalizeNumericApproximation(value)` - Normalize a numeric approximation into the standard Constants representation. +64. `constantsCanonicalizeNumericApproximation(value)` - Canonicalize a numeric approximation so equivalent inputs share one form. +65. `constantsParseNumericApproximation(text)` - Parse a text or structured value into a numeric approximation. +66. `constantsFormatNumericApproximation(value)` - Format a numeric approximation for deterministic user-facing output. +67. `constantsCompareNumericApproximation(left, right)` - Compare two numeric approximation values under the conventions of Constants. +68. `constantsCombineNumericApproximation(left, right)` - Combine two numeric approximation values with the natural operation for Constants. +69. `constantsDecomposeNumericApproximation(value)` - Decompose a numeric approximation into simpler or canonical components. +70. `constantsEvaluateNumericApproximation(value, point=None)` - Evaluate a numeric approximation at a point, sample, or finite model. +71. `constantsComputeNumericApproximation(value)` - Compute the central numerical or symbolic data of a numeric approximation. +72. `constantsEstimateNumericApproximation(value, samples=None)` - Estimate a numeric approximation property from finite samples or approximations. +73. `constantsApproximateNumericApproximation(value, tolerance=1e-9)` - Approximate a numeric approximation with explicit tolerance controls. +74. `constantsTransformNumericApproximation(value, mapping)` - Transform a numeric approximation through a map, operator, or representation change. +75. `constantsSimplifyNumericApproximation(value)` - Simplify a numeric approximation without changing its mathematical meaning. +76. `constantsEnumerateNumericApproximation(value, limit=None)` - Enumerate finite members, cases, or derived objects for a numeric approximation. +77. `constantsClassifyNumericApproximation(value)` - Classify a numeric approximation by its standard Constants invariants. +78. `constantsTestEquivalenceNumericApproximation(left, right)` - Test whether two numeric approximation values are equivalent in Constants. +79. `constantsGenerateExampleNumericApproximation(size=3)` - Generate a small documented example of a numeric approximation. +80. `constantsDocumentNumericApproximation(value)` - Return a structured explanation of a numeric approximation and related assumptions. +81. `constantsValidateConstantIdentity(value)` - Validate the constant identity representation and domain rules for Constants. +82. `constantsConstructConstantIdentity(*args)` - Construct a constant identity from explicit inputs for Constants. +83. `constantsNormalizeConstantIdentity(value)` - Normalize a constant identity into the standard Constants representation. +84. `constantsCanonicalizeConstantIdentity(value)` - Canonicalize a constant identity so equivalent inputs share one form. +85. `constantsParseConstantIdentity(text)` - Parse a text or structured value into a constant identity. +86. `constantsFormatConstantIdentity(value)` - Format a constant identity for deterministic user-facing output. +87. `constantsCompareConstantIdentity(left, right)` - Compare two constant identity values under the conventions of Constants. +88. `constantsCombineConstantIdentity(left, right)` - Combine two constant identity values with the natural operation for Constants. +89. `constantsDecomposeConstantIdentity(value)` - Decompose a constant identity into simpler or canonical components. +90. `constantsEvaluateConstantIdentity(value, point=None)` - Evaluate a constant identity at a point, sample, or finite model. +91. `constantsComputeConstantIdentity(value)` - Compute the central numerical or symbolic data of a constant identity. +92. `constantsEstimateConstantIdentity(value, samples=None)` - Estimate a constant identity property from finite samples or approximations. +93. `constantsApproximateConstantIdentity(value, tolerance=1e-9)` - Approximate a constant identity with explicit tolerance controls. +94. `constantsTransformConstantIdentity(value, mapping)` - Transform a constant identity through a map, operator, or representation change. +95. `constantsSimplifyConstantIdentity(value)` - Simplify a constant identity without changing its mathematical meaning. +96. `constantsEnumerateConstantIdentity(value, limit=None)` - Enumerate finite members, cases, or derived objects for a constant identity. +97. `constantsClassifyConstantIdentity(value)` - Classify a constant identity by its standard Constants invariants. +98. `constantsTestEquivalenceConstantIdentity(left, right)` - Test whether two constant identity values are equivalent in Constants. +99. `constantsGenerateExampleConstantIdentity(size=3)` - Generate a small documented example of a constant identity. +100. `constantsDocumentConstantIdentity(value)` - Return a structured explanation of a constant identity and related assumptions. + +### Arithmetic + +Core object families: + +- numeric sequence +- binary operation +- rounding rule +- ratio expression +- bounded interval + +Candidate functions: + +1. `arithmeticValidateNumericSequence(value)` - Validate the numeric sequence representation and domain rules for Arithmetic. +2. `arithmeticConstructNumericSequence(*args)` - Construct a numeric sequence from explicit inputs for Arithmetic. +3. `arithmeticNormalizeNumericSequence(value)` - Normalize a numeric sequence into the standard Arithmetic representation. +4. `arithmeticCanonicalizeNumericSequence(value)` - Canonicalize a numeric sequence so equivalent inputs share one form. +5. `arithmeticParseNumericSequence(text)` - Parse a text or structured value into a numeric sequence. +6. `arithmeticFormatNumericSequence(value)` - Format a numeric sequence for deterministic user-facing output. +7. `arithmeticCompareNumericSequence(left, right)` - Compare two numeric sequence values under the conventions of Arithmetic. +8. `arithmeticCombineNumericSequence(left, right)` - Combine two numeric sequence values with the natural operation for Arithmetic. +9. `arithmeticDecomposeNumericSequence(value)` - Decompose a numeric sequence into simpler or canonical components. +10. `arithmeticEvaluateNumericSequence(value, point=None)` - Evaluate a numeric sequence at a point, sample, or finite model. +11. `arithmeticComputeNumericSequence(value)` - Compute the central numerical or symbolic data of a numeric sequence. +12. `arithmeticEstimateNumericSequence(value, samples=None)` - Estimate a numeric sequence property from finite samples or approximations. +13. `arithmeticApproximateNumericSequence(value, tolerance=1e-9)` - Approximate a numeric sequence with explicit tolerance controls. +14. `arithmeticTransformNumericSequence(value, mapping)` - Transform a numeric sequence through a map, operator, or representation change. +15. `arithmeticSimplifyNumericSequence(value)` - Simplify a numeric sequence without changing its mathematical meaning. +16. `arithmeticEnumerateNumericSequence(value, limit=None)` - Enumerate finite members, cases, or derived objects for a numeric sequence. +17. `arithmeticClassifyNumericSequence(value)` - Classify a numeric sequence by its standard Arithmetic invariants. +18. `arithmeticTestEquivalenceNumericSequence(left, right)` - Test whether two numeric sequence values are equivalent in Arithmetic. +19. `arithmeticGenerateExampleNumericSequence(size=3)` - Generate a small documented example of a numeric sequence. +20. `arithmeticDocumentNumericSequence(value)` - Return a structured explanation of a numeric sequence and related assumptions. +21. `arithmeticValidateBinaryOperation(value)` - Validate the binary operation representation and domain rules for Arithmetic. +22. `arithmeticConstructBinaryOperation(*args)` - Construct a binary operation from explicit inputs for Arithmetic. +23. `arithmeticNormalizeBinaryOperation(value)` - Normalize a binary operation into the standard Arithmetic representation. +24. `arithmeticCanonicalizeBinaryOperation(value)` - Canonicalize a binary operation so equivalent inputs share one form. +25. `arithmeticParseBinaryOperation(text)` - Parse a text or structured value into a binary operation. +26. `arithmeticFormatBinaryOperation(value)` - Format a binary operation for deterministic user-facing output. +27. `arithmeticCompareBinaryOperation(left, right)` - Compare two binary operation values under the conventions of Arithmetic. +28. `arithmeticCombineBinaryOperation(left, right)` - Combine two binary operation values with the natural operation for Arithmetic. +29. `arithmeticDecomposeBinaryOperation(value)` - Decompose a binary operation into simpler or canonical components. +30. `arithmeticEvaluateBinaryOperation(value, point=None)` - Evaluate a binary operation at a point, sample, or finite model. +31. `arithmeticComputeBinaryOperation(value)` - Compute the central numerical or symbolic data of a binary operation. +32. `arithmeticEstimateBinaryOperation(value, samples=None)` - Estimate a binary operation property from finite samples or approximations. +33. `arithmeticApproximateBinaryOperation(value, tolerance=1e-9)` - Approximate a binary operation with explicit tolerance controls. +34. `arithmeticTransformBinaryOperation(value, mapping)` - Transform a binary operation through a map, operator, or representation change. +35. `arithmeticSimplifyBinaryOperation(value)` - Simplify a binary operation without changing its mathematical meaning. +36. `arithmeticEnumerateBinaryOperation(value, limit=None)` - Enumerate finite members, cases, or derived objects for a binary operation. +37. `arithmeticClassifyBinaryOperation(value)` - Classify a binary operation by its standard Arithmetic invariants. +38. `arithmeticTestEquivalenceBinaryOperation(left, right)` - Test whether two binary operation values are equivalent in Arithmetic. +39. `arithmeticGenerateExampleBinaryOperation(size=3)` - Generate a small documented example of a binary operation. +40. `arithmeticDocumentBinaryOperation(value)` - Return a structured explanation of a binary operation and related assumptions. +41. `arithmeticValidateRoundingRule(value)` - Validate the rounding rule representation and domain rules for Arithmetic. +42. `arithmeticConstructRoundingRule(*args)` - Construct a rounding rule from explicit inputs for Arithmetic. +43. `arithmeticNormalizeRoundingRule(value)` - Normalize a rounding rule into the standard Arithmetic representation. +44. `arithmeticCanonicalizeRoundingRule(value)` - Canonicalize a rounding rule so equivalent inputs share one form. +45. `arithmeticParseRoundingRule(text)` - Parse a text or structured value into a rounding rule. +46. `arithmeticFormatRoundingRule(value)` - Format a rounding rule for deterministic user-facing output. +47. `arithmeticCompareRoundingRule(left, right)` - Compare two rounding rule values under the conventions of Arithmetic. +48. `arithmeticCombineRoundingRule(left, right)` - Combine two rounding rule values with the natural operation for Arithmetic. +49. `arithmeticDecomposeRoundingRule(value)` - Decompose a rounding rule into simpler or canonical components. +50. `arithmeticEvaluateRoundingRule(value, point=None)` - Evaluate a rounding rule at a point, sample, or finite model. +51. `arithmeticComputeRoundingRule(value)` - Compute the central numerical or symbolic data of a rounding rule. +52. `arithmeticEstimateRoundingRule(value, samples=None)` - Estimate a rounding rule property from finite samples or approximations. +53. `arithmeticApproximateRoundingRule(value, tolerance=1e-9)` - Approximate a rounding rule with explicit tolerance controls. +54. `arithmeticTransformRoundingRule(value, mapping)` - Transform a rounding rule through a map, operator, or representation change. +55. `arithmeticSimplifyRoundingRule(value)` - Simplify a rounding rule without changing its mathematical meaning. +56. `arithmeticEnumerateRoundingRule(value, limit=None)` - Enumerate finite members, cases, or derived objects for a rounding rule. +57. `arithmeticClassifyRoundingRule(value)` - Classify a rounding rule by its standard Arithmetic invariants. +58. `arithmeticTestEquivalenceRoundingRule(left, right)` - Test whether two rounding rule values are equivalent in Arithmetic. +59. `arithmeticGenerateExampleRoundingRule(size=3)` - Generate a small documented example of a rounding rule. +60. `arithmeticDocumentRoundingRule(value)` - Return a structured explanation of a rounding rule and related assumptions. +61. `arithmeticValidateRatioExpression(value)` - Validate the ratio expression representation and domain rules for Arithmetic. +62. `arithmeticConstructRatioExpression(*args)` - Construct a ratio expression from explicit inputs for Arithmetic. +63. `arithmeticNormalizeRatioExpression(value)` - Normalize a ratio expression into the standard Arithmetic representation. +64. `arithmeticCanonicalizeRatioExpression(value)` - Canonicalize a ratio expression so equivalent inputs share one form. +65. `arithmeticParseRatioExpression(text)` - Parse a text or structured value into a ratio expression. +66. `arithmeticFormatRatioExpression(value)` - Format a ratio expression for deterministic user-facing output. +67. `arithmeticCompareRatioExpression(left, right)` - Compare two ratio expression values under the conventions of Arithmetic. +68. `arithmeticCombineRatioExpression(left, right)` - Combine two ratio expression values with the natural operation for Arithmetic. +69. `arithmeticDecomposeRatioExpression(value)` - Decompose a ratio expression into simpler or canonical components. +70. `arithmeticEvaluateRatioExpression(value, point=None)` - Evaluate a ratio expression at a point, sample, or finite model. +71. `arithmeticComputeRatioExpression(value)` - Compute the central numerical or symbolic data of a ratio expression. +72. `arithmeticEstimateRatioExpression(value, samples=None)` - Estimate a ratio expression property from finite samples or approximations. +73. `arithmeticApproximateRatioExpression(value, tolerance=1e-9)` - Approximate a ratio expression with explicit tolerance controls. +74. `arithmeticTransformRatioExpression(value, mapping)` - Transform a ratio expression through a map, operator, or representation change. +75. `arithmeticSimplifyRatioExpression(value)` - Simplify a ratio expression without changing its mathematical meaning. +76. `arithmeticEnumerateRatioExpression(value, limit=None)` - Enumerate finite members, cases, or derived objects for a ratio expression. +77. `arithmeticClassifyRatioExpression(value)` - Classify a ratio expression by its standard Arithmetic invariants. +78. `arithmeticTestEquivalenceRatioExpression(left, right)` - Test whether two ratio expression values are equivalent in Arithmetic. +79. `arithmeticGenerateExampleRatioExpression(size=3)` - Generate a small documented example of a ratio expression. +80. `arithmeticDocumentRatioExpression(value)` - Return a structured explanation of a ratio expression and related assumptions. +81. `arithmeticValidateBoundedInterval(value)` - Validate the bounded interval representation and domain rules for Arithmetic. +82. `arithmeticConstructBoundedInterval(*args)` - Construct a bounded interval from explicit inputs for Arithmetic. +83. `arithmeticNormalizeBoundedInterval(value)` - Normalize a bounded interval into the standard Arithmetic representation. +84. `arithmeticCanonicalizeBoundedInterval(value)` - Canonicalize a bounded interval so equivalent inputs share one form. +85. `arithmeticParseBoundedInterval(text)` - Parse a text or structured value into a bounded interval. +86. `arithmeticFormatBoundedInterval(value)` - Format a bounded interval for deterministic user-facing output. +87. `arithmeticCompareBoundedInterval(left, right)` - Compare two bounded interval values under the conventions of Arithmetic. +88. `arithmeticCombineBoundedInterval(left, right)` - Combine two bounded interval values with the natural operation for Arithmetic. +89. `arithmeticDecomposeBoundedInterval(value)` - Decompose a bounded interval into simpler or canonical components. +90. `arithmeticEvaluateBoundedInterval(value, point=None)` - Evaluate a bounded interval at a point, sample, or finite model. +91. `arithmeticComputeBoundedInterval(value)` - Compute the central numerical or symbolic data of a bounded interval. +92. `arithmeticEstimateBoundedInterval(value, samples=None)` - Estimate a bounded interval property from finite samples or approximations. +93. `arithmeticApproximateBoundedInterval(value, tolerance=1e-9)` - Approximate a bounded interval with explicit tolerance controls. +94. `arithmeticTransformBoundedInterval(value, mapping)` - Transform a bounded interval through a map, operator, or representation change. +95. `arithmeticSimplifyBoundedInterval(value)` - Simplify a bounded interval without changing its mathematical meaning. +96. `arithmeticEnumerateBoundedInterval(value, limit=None)` - Enumerate finite members, cases, or derived objects for a bounded interval. +97. `arithmeticClassifyBoundedInterval(value)` - Classify a bounded interval by its standard Arithmetic invariants. +98. `arithmeticTestEquivalenceBoundedInterval(left, right)` - Test whether two bounded interval values are equivalent in Arithmetic. +99. `arithmeticGenerateExampleBoundedInterval(size=3)` - Generate a small documented example of a bounded interval. +100. `arithmeticDocumentBoundedInterval(value)` - Return a structured explanation of a bounded interval and related assumptions. + +### Algebra + +Core object families: + +- algebraic expression +- equation +- root expression +- factorial expression +- exponential form + +Candidate functions: + +1. `algebraValidateAlgebraicExpression(value)` - Validate the algebraic expression representation and domain rules for Algebra. +2. `algebraConstructAlgebraicExpression(*args)` - Construct a algebraic expression from explicit inputs for Algebra. +3. `algebraNormalizeAlgebraicExpression(value)` - Normalize a algebraic expression into the standard Algebra representation. +4. `algebraCanonicalizeAlgebraicExpression(value)` - Canonicalize a algebraic expression so equivalent inputs share one form. +5. `algebraParseAlgebraicExpression(text)` - Parse a text or structured value into a algebraic expression. +6. `algebraFormatAlgebraicExpression(value)` - Format a algebraic expression for deterministic user-facing output. +7. `algebraCompareAlgebraicExpression(left, right)` - Compare two algebraic expression values under the conventions of Algebra. +8. `algebraCombineAlgebraicExpression(left, right)` - Combine two algebraic expression values with the natural operation for Algebra. +9. `algebraDecomposeAlgebraicExpression(value)` - Decompose a algebraic expression into simpler or canonical components. +10. `algebraEvaluateAlgebraicExpression(value, point=None)` - Evaluate a algebraic expression at a point, sample, or finite model. +11. `algebraComputeAlgebraicExpression(value)` - Compute the central numerical or symbolic data of a algebraic expression. +12. `algebraEstimateAlgebraicExpression(value, samples=None)` - Estimate a algebraic expression property from finite samples or approximations. +13. `algebraApproximateAlgebraicExpression(value, tolerance=1e-9)` - Approximate a algebraic expression with explicit tolerance controls. +14. `algebraTransformAlgebraicExpression(value, mapping)` - Transform a algebraic expression through a map, operator, or representation change. +15. `algebraSimplifyAlgebraicExpression(value)` - Simplify a algebraic expression without changing its mathematical meaning. +16. `algebraEnumerateAlgebraicExpression(value, limit=None)` - Enumerate finite members, cases, or derived objects for a algebraic expression. +17. `algebraClassifyAlgebraicExpression(value)` - Classify a algebraic expression by its standard Algebra invariants. +18. `algebraTestEquivalenceAlgebraicExpression(left, right)` - Test whether two algebraic expression values are equivalent in Algebra. +19. `algebraGenerateExampleAlgebraicExpression(size=3)` - Generate a small documented example of a algebraic expression. +20. `algebraDocumentAlgebraicExpression(value)` - Return a structured explanation of a algebraic expression and related assumptions. +21. `algebraValidateEquation(value)` - Validate the equation representation and domain rules for Algebra. +22. `algebraConstructEquation(*args)` - Construct a equation from explicit inputs for Algebra. +23. `algebraNormalizeEquation(value)` - Normalize a equation into the standard Algebra representation. +24. `algebraCanonicalizeEquation(value)` - Canonicalize a equation so equivalent inputs share one form. +25. `algebraParseEquation(text)` - Parse a text or structured value into a equation. +26. `algebraFormatEquation(value)` - Format a equation for deterministic user-facing output. +27. `algebraCompareEquation(left, right)` - Compare two equation values under the conventions of Algebra. +28. `algebraCombineEquation(left, right)` - Combine two equation values with the natural operation for Algebra. +29. `algebraDecomposeEquation(value)` - Decompose a equation into simpler or canonical components. +30. `algebraEvaluateEquation(value, point=None)` - Evaluate a equation at a point, sample, or finite model. +31. `algebraComputeEquation(value)` - Compute the central numerical or symbolic data of a equation. +32. `algebraEstimateEquation(value, samples=None)` - Estimate a equation property from finite samples or approximations. +33. `algebraApproximateEquation(value, tolerance=1e-9)` - Approximate a equation with explicit tolerance controls. +34. `algebraTransformEquation(value, mapping)` - Transform a equation through a map, operator, or representation change. +35. `algebraSimplifyEquation(value)` - Simplify a equation without changing its mathematical meaning. +36. `algebraEnumerateEquation(value, limit=None)` - Enumerate finite members, cases, or derived objects for a equation. +37. `algebraClassifyEquation(value)` - Classify a equation by its standard Algebra invariants. +38. `algebraTestEquivalenceEquation(left, right)` - Test whether two equation values are equivalent in Algebra. +39. `algebraGenerateExampleEquation(size=3)` - Generate a small documented example of a equation. +40. `algebraDocumentEquation(value)` - Return a structured explanation of a equation and related assumptions. +41. `algebraValidateRootExpression(value)` - Validate the root expression representation and domain rules for Algebra. +42. `algebraConstructRootExpression(*args)` - Construct a root expression from explicit inputs for Algebra. +43. `algebraNormalizeRootExpression(value)` - Normalize a root expression into the standard Algebra representation. +44. `algebraCanonicalizeRootExpression(value)` - Canonicalize a root expression so equivalent inputs share one form. +45. `algebraParseRootExpression(text)` - Parse a text or structured value into a root expression. +46. `algebraFormatRootExpression(value)` - Format a root expression for deterministic user-facing output. +47. `algebraCompareRootExpression(left, right)` - Compare two root expression values under the conventions of Algebra. +48. `algebraCombineRootExpression(left, right)` - Combine two root expression values with the natural operation for Algebra. +49. `algebraDecomposeRootExpression(value)` - Decompose a root expression into simpler or canonical components. +50. `algebraEvaluateRootExpression(value, point=None)` - Evaluate a root expression at a point, sample, or finite model. +51. `algebraComputeRootExpression(value)` - Compute the central numerical or symbolic data of a root expression. +52. `algebraEstimateRootExpression(value, samples=None)` - Estimate a root expression property from finite samples or approximations. +53. `algebraApproximateRootExpression(value, tolerance=1e-9)` - Approximate a root expression with explicit tolerance controls. +54. `algebraTransformRootExpression(value, mapping)` - Transform a root expression through a map, operator, or representation change. +55. `algebraSimplifyRootExpression(value)` - Simplify a root expression without changing its mathematical meaning. +56. `algebraEnumerateRootExpression(value, limit=None)` - Enumerate finite members, cases, or derived objects for a root expression. +57. `algebraClassifyRootExpression(value)` - Classify a root expression by its standard Algebra invariants. +58. `algebraTestEquivalenceRootExpression(left, right)` - Test whether two root expression values are equivalent in Algebra. +59. `algebraGenerateExampleRootExpression(size=3)` - Generate a small documented example of a root expression. +60. `algebraDocumentRootExpression(value)` - Return a structured explanation of a root expression and related assumptions. +61. `algebraValidateFactorialExpression(value)` - Validate the factorial expression representation and domain rules for Algebra. +62. `algebraConstructFactorialExpression(*args)` - Construct a factorial expression from explicit inputs for Algebra. +63. `algebraNormalizeFactorialExpression(value)` - Normalize a factorial expression into the standard Algebra representation. +64. `algebraCanonicalizeFactorialExpression(value)` - Canonicalize a factorial expression so equivalent inputs share one form. +65. `algebraParseFactorialExpression(text)` - Parse a text or structured value into a factorial expression. +66. `algebraFormatFactorialExpression(value)` - Format a factorial expression for deterministic user-facing output. +67. `algebraCompareFactorialExpression(left, right)` - Compare two factorial expression values under the conventions of Algebra. +68. `algebraCombineFactorialExpression(left, right)` - Combine two factorial expression values with the natural operation for Algebra. +69. `algebraDecomposeFactorialExpression(value)` - Decompose a factorial expression into simpler or canonical components. +70. `algebraEvaluateFactorialExpression(value, point=None)` - Evaluate a factorial expression at a point, sample, or finite model. +71. `algebraComputeFactorialExpression(value)` - Compute the central numerical or symbolic data of a factorial expression. +72. `algebraEstimateFactorialExpression(value, samples=None)` - Estimate a factorial expression property from finite samples or approximations. +73. `algebraApproximateFactorialExpression(value, tolerance=1e-9)` - Approximate a factorial expression with explicit tolerance controls. +74. `algebraTransformFactorialExpression(value, mapping)` - Transform a factorial expression through a map, operator, or representation change. +75. `algebraSimplifyFactorialExpression(value)` - Simplify a factorial expression without changing its mathematical meaning. +76. `algebraEnumerateFactorialExpression(value, limit=None)` - Enumerate finite members, cases, or derived objects for a factorial expression. +77. `algebraClassifyFactorialExpression(value)` - Classify a factorial expression by its standard Algebra invariants. +78. `algebraTestEquivalenceFactorialExpression(left, right)` - Test whether two factorial expression values are equivalent in Algebra. +79. `algebraGenerateExampleFactorialExpression(size=3)` - Generate a small documented example of a factorial expression. +80. `algebraDocumentFactorialExpression(value)` - Return a structured explanation of a factorial expression and related assumptions. +81. `algebraValidateExponentialForm(value)` - Validate the exponential form representation and domain rules for Algebra. +82. `algebraConstructExponentialForm(*args)` - Construct a exponential form from explicit inputs for Algebra. +83. `algebraNormalizeExponentialForm(value)` - Normalize a exponential form into the standard Algebra representation. +84. `algebraCanonicalizeExponentialForm(value)` - Canonicalize a exponential form so equivalent inputs share one form. +85. `algebraParseExponentialForm(text)` - Parse a text or structured value into a exponential form. +86. `algebraFormatExponentialForm(value)` - Format a exponential form for deterministic user-facing output. +87. `algebraCompareExponentialForm(left, right)` - Compare two exponential form values under the conventions of Algebra. +88. `algebraCombineExponentialForm(left, right)` - Combine two exponential form values with the natural operation for Algebra. +89. `algebraDecomposeExponentialForm(value)` - Decompose a exponential form into simpler or canonical components. +90. `algebraEvaluateExponentialForm(value, point=None)` - Evaluate a exponential form at a point, sample, or finite model. +91. `algebraComputeExponentialForm(value)` - Compute the central numerical or symbolic data of a exponential form. +92. `algebraEstimateExponentialForm(value, samples=None)` - Estimate a exponential form property from finite samples or approximations. +93. `algebraApproximateExponentialForm(value, tolerance=1e-9)` - Approximate a exponential form with explicit tolerance controls. +94. `algebraTransformExponentialForm(value, mapping)` - Transform a exponential form through a map, operator, or representation change. +95. `algebraSimplifyExponentialForm(value)` - Simplify a exponential form without changing its mathematical meaning. +96. `algebraEnumerateExponentialForm(value, limit=None)` - Enumerate finite members, cases, or derived objects for a exponential form. +97. `algebraClassifyExponentialForm(value)` - Classify a exponential form by its standard Algebra invariants. +98. `algebraTestEquivalenceExponentialForm(left, right)` - Test whether two exponential form values are equivalent in Algebra. +99. `algebraGenerateExampleExponentialForm(size=3)` - Generate a small documented example of a exponential form. +100. `algebraDocumentExponentialForm(value)` - Return a structured explanation of a exponential form and related assumptions. + +### Counting + +Core object families: + +- selection model +- arrangement model +- partition count +- recurrence count +- combinatorial identity + +Candidate functions: + +1. `countingValidateSelectionModel(value)` - Validate the selection model representation and domain rules for Counting. +2. `countingConstructSelectionModel(*args)` - Construct a selection model from explicit inputs for Counting. +3. `countingNormalizeSelectionModel(value)` - Normalize a selection model into the standard Counting representation. +4. `countingCanonicalizeSelectionModel(value)` - Canonicalize a selection model so equivalent inputs share one form. +5. `countingParseSelectionModel(text)` - Parse a text or structured value into a selection model. +6. `countingFormatSelectionModel(value)` - Format a selection model for deterministic user-facing output. +7. `countingCompareSelectionModel(left, right)` - Compare two selection model values under the conventions of Counting. +8. `countingCombineSelectionModel(left, right)` - Combine two selection model values with the natural operation for Counting. +9. `countingDecomposeSelectionModel(value)` - Decompose a selection model into simpler or canonical components. +10. `countingEvaluateSelectionModel(value, point=None)` - Evaluate a selection model at a point, sample, or finite model. +11. `countingComputeSelectionModel(value)` - Compute the central numerical or symbolic data of a selection model. +12. `countingEstimateSelectionModel(value, samples=None)` - Estimate a selection model property from finite samples or approximations. +13. `countingApproximateSelectionModel(value, tolerance=1e-9)` - Approximate a selection model with explicit tolerance controls. +14. `countingTransformSelectionModel(value, mapping)` - Transform a selection model through a map, operator, or representation change. +15. `countingSimplifySelectionModel(value)` - Simplify a selection model without changing its mathematical meaning. +16. `countingEnumerateSelectionModel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a selection model. +17. `countingClassifySelectionModel(value)` - Classify a selection model by its standard Counting invariants. +18. `countingTestEquivalenceSelectionModel(left, right)` - Test whether two selection model values are equivalent in Counting. +19. `countingGenerateExampleSelectionModel(size=3)` - Generate a small documented example of a selection model. +20. `countingDocumentSelectionModel(value)` - Return a structured explanation of a selection model and related assumptions. +21. `countingValidateArrangementModel(value)` - Validate the arrangement model representation and domain rules for Counting. +22. `countingConstructArrangementModel(*args)` - Construct a arrangement model from explicit inputs for Counting. +23. `countingNormalizeArrangementModel(value)` - Normalize a arrangement model into the standard Counting representation. +24. `countingCanonicalizeArrangementModel(value)` - Canonicalize a arrangement model so equivalent inputs share one form. +25. `countingParseArrangementModel(text)` - Parse a text or structured value into a arrangement model. +26. `countingFormatArrangementModel(value)` - Format a arrangement model for deterministic user-facing output. +27. `countingCompareArrangementModel(left, right)` - Compare two arrangement model values under the conventions of Counting. +28. `countingCombineArrangementModel(left, right)` - Combine two arrangement model values with the natural operation for Counting. +29. `countingDecomposeArrangementModel(value)` - Decompose a arrangement model into simpler or canonical components. +30. `countingEvaluateArrangementModel(value, point=None)` - Evaluate a arrangement model at a point, sample, or finite model. +31. `countingComputeArrangementModel(value)` - Compute the central numerical or symbolic data of a arrangement model. +32. `countingEstimateArrangementModel(value, samples=None)` - Estimate a arrangement model property from finite samples or approximations. +33. `countingApproximateArrangementModel(value, tolerance=1e-9)` - Approximate a arrangement model with explicit tolerance controls. +34. `countingTransformArrangementModel(value, mapping)` - Transform a arrangement model through a map, operator, or representation change. +35. `countingSimplifyArrangementModel(value)` - Simplify a arrangement model without changing its mathematical meaning. +36. `countingEnumerateArrangementModel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a arrangement model. +37. `countingClassifyArrangementModel(value)` - Classify a arrangement model by its standard Counting invariants. +38. `countingTestEquivalenceArrangementModel(left, right)` - Test whether two arrangement model values are equivalent in Counting. +39. `countingGenerateExampleArrangementModel(size=3)` - Generate a small documented example of a arrangement model. +40. `countingDocumentArrangementModel(value)` - Return a structured explanation of a arrangement model and related assumptions. +41. `countingValidatePartitionCount(value)` - Validate the partition count representation and domain rules for Counting. +42. `countingConstructPartitionCount(*args)` - Construct a partition count from explicit inputs for Counting. +43. `countingNormalizePartitionCount(value)` - Normalize a partition count into the standard Counting representation. +44. `countingCanonicalizePartitionCount(value)` - Canonicalize a partition count so equivalent inputs share one form. +45. `countingParsePartitionCount(text)` - Parse a text or structured value into a partition count. +46. `countingFormatPartitionCount(value)` - Format a partition count for deterministic user-facing output. +47. `countingComparePartitionCount(left, right)` - Compare two partition count values under the conventions of Counting. +48. `countingCombinePartitionCount(left, right)` - Combine two partition count values with the natural operation for Counting. +49. `countingDecomposePartitionCount(value)` - Decompose a partition count into simpler or canonical components. +50. `countingEvaluatePartitionCount(value, point=None)` - Evaluate a partition count at a point, sample, or finite model. +51. `countingComputePartitionCount(value)` - Compute the central numerical or symbolic data of a partition count. +52. `countingEstimatePartitionCount(value, samples=None)` - Estimate a partition count property from finite samples or approximations. +53. `countingApproximatePartitionCount(value, tolerance=1e-9)` - Approximate a partition count with explicit tolerance controls. +54. `countingTransformPartitionCount(value, mapping)` - Transform a partition count through a map, operator, or representation change. +55. `countingSimplifyPartitionCount(value)` - Simplify a partition count without changing its mathematical meaning. +56. `countingEnumeratePartitionCount(value, limit=None)` - Enumerate finite members, cases, or derived objects for a partition count. +57. `countingClassifyPartitionCount(value)` - Classify a partition count by its standard Counting invariants. +58. `countingTestEquivalencePartitionCount(left, right)` - Test whether two partition count values are equivalent in Counting. +59. `countingGenerateExamplePartitionCount(size=3)` - Generate a small documented example of a partition count. +60. `countingDocumentPartitionCount(value)` - Return a structured explanation of a partition count and related assumptions. +61. `countingValidateRecurrenceCount(value)` - Validate the recurrence count representation and domain rules for Counting. +62. `countingConstructRecurrenceCount(*args)` - Construct a recurrence count from explicit inputs for Counting. +63. `countingNormalizeRecurrenceCount(value)` - Normalize a recurrence count into the standard Counting representation. +64. `countingCanonicalizeRecurrenceCount(value)` - Canonicalize a recurrence count so equivalent inputs share one form. +65. `countingParseRecurrenceCount(text)` - Parse a text or structured value into a recurrence count. +66. `countingFormatRecurrenceCount(value)` - Format a recurrence count for deterministic user-facing output. +67. `countingCompareRecurrenceCount(left, right)` - Compare two recurrence count values under the conventions of Counting. +68. `countingCombineRecurrenceCount(left, right)` - Combine two recurrence count values with the natural operation for Counting. +69. `countingDecomposeRecurrenceCount(value)` - Decompose a recurrence count into simpler or canonical components. +70. `countingEvaluateRecurrenceCount(value, point=None)` - Evaluate a recurrence count at a point, sample, or finite model. +71. `countingComputeRecurrenceCount(value)` - Compute the central numerical or symbolic data of a recurrence count. +72. `countingEstimateRecurrenceCount(value, samples=None)` - Estimate a recurrence count property from finite samples or approximations. +73. `countingApproximateRecurrenceCount(value, tolerance=1e-9)` - Approximate a recurrence count with explicit tolerance controls. +74. `countingTransformRecurrenceCount(value, mapping)` - Transform a recurrence count through a map, operator, or representation change. +75. `countingSimplifyRecurrenceCount(value)` - Simplify a recurrence count without changing its mathematical meaning. +76. `countingEnumerateRecurrenceCount(value, limit=None)` - Enumerate finite members, cases, or derived objects for a recurrence count. +77. `countingClassifyRecurrenceCount(value)` - Classify a recurrence count by its standard Counting invariants. +78. `countingTestEquivalenceRecurrenceCount(left, right)` - Test whether two recurrence count values are equivalent in Counting. +79. `countingGenerateExampleRecurrenceCount(size=3)` - Generate a small documented example of a recurrence count. +80. `countingDocumentRecurrenceCount(value)` - Return a structured explanation of a recurrence count and related assumptions. +81. `countingValidateCombinatorialIdentity(value)` - Validate the combinatorial identity representation and domain rules for Counting. +82. `countingConstructCombinatorialIdentity(*args)` - Construct a combinatorial identity from explicit inputs for Counting. +83. `countingNormalizeCombinatorialIdentity(value)` - Normalize a combinatorial identity into the standard Counting representation. +84. `countingCanonicalizeCombinatorialIdentity(value)` - Canonicalize a combinatorial identity so equivalent inputs share one form. +85. `countingParseCombinatorialIdentity(text)` - Parse a text or structured value into a combinatorial identity. +86. `countingFormatCombinatorialIdentity(value)` - Format a combinatorial identity for deterministic user-facing output. +87. `countingCompareCombinatorialIdentity(left, right)` - Compare two combinatorial identity values under the conventions of Counting. +88. `countingCombineCombinatorialIdentity(left, right)` - Combine two combinatorial identity values with the natural operation for Counting. +89. `countingDecomposeCombinatorialIdentity(value)` - Decompose a combinatorial identity into simpler or canonical components. +90. `countingEvaluateCombinatorialIdentity(value, point=None)` - Evaluate a combinatorial identity at a point, sample, or finite model. +91. `countingComputeCombinatorialIdentity(value)` - Compute the central numerical or symbolic data of a combinatorial identity. +92. `countingEstimateCombinatorialIdentity(value, samples=None)` - Estimate a combinatorial identity property from finite samples or approximations. +93. `countingApproximateCombinatorialIdentity(value, tolerance=1e-9)` - Approximate a combinatorial identity with explicit tolerance controls. +94. `countingTransformCombinatorialIdentity(value, mapping)` - Transform a combinatorial identity through a map, operator, or representation change. +95. `countingSimplifyCombinatorialIdentity(value)` - Simplify a combinatorial identity without changing its mathematical meaning. +96. `countingEnumerateCombinatorialIdentity(value, limit=None)` - Enumerate finite members, cases, or derived objects for a combinatorial identity. +97. `countingClassifyCombinatorialIdentity(value)` - Classify a combinatorial identity by its standard Counting invariants. +98. `countingTestEquivalenceCombinatorialIdentity(left, right)` - Test whether two combinatorial identity values are equivalent in Counting. +99. `countingGenerateExampleCombinatorialIdentity(size=3)` - Generate a small documented example of a combinatorial identity. +100. `countingDocumentCombinatorialIdentity(value)` - Return a structured explanation of a combinatorial identity and related assumptions. + +### Probability + +Core object families: + +- distribution +- event model +- density function +- mass function +- probability space + +Candidate functions: + +1. `probabilityValidateDistribution(value)` - Validate the distribution representation and domain rules for Probability. +2. `probabilityConstructDistribution(*args)` - Construct a distribution from explicit inputs for Probability. +3. `probabilityNormalizeDistribution(value)` - Normalize a distribution into the standard Probability representation. +4. `probabilityCanonicalizeDistribution(value)` - Canonicalize a distribution so equivalent inputs share one form. +5. `probabilityParseDistribution(text)` - Parse a text or structured value into a distribution. +6. `probabilityFormatDistribution(value)` - Format a distribution for deterministic user-facing output. +7. `probabilityCompareDistribution(left, right)` - Compare two distribution values under the conventions of Probability. +8. `probabilityCombineDistribution(left, right)` - Combine two distribution values with the natural operation for Probability. +9. `probabilityDecomposeDistribution(value)` - Decompose a distribution into simpler or canonical components. +10. `probabilityEvaluateDistribution(value, point=None)` - Evaluate a distribution at a point, sample, or finite model. +11. `probabilityComputeDistribution(value)` - Compute the central numerical or symbolic data of a distribution. +12. `probabilityEstimateDistribution(value, samples=None)` - Estimate a distribution property from finite samples or approximations. +13. `probabilityApproximateDistribution(value, tolerance=1e-9)` - Approximate a distribution with explicit tolerance controls. +14. `probabilityTransformDistribution(value, mapping)` - Transform a distribution through a map, operator, or representation change. +15. `probabilitySimplifyDistribution(value)` - Simplify a distribution without changing its mathematical meaning. +16. `probabilityEnumerateDistribution(value, limit=None)` - Enumerate finite members, cases, or derived objects for a distribution. +17. `probabilityClassifyDistribution(value)` - Classify a distribution by its standard Probability invariants. +18. `probabilityTestEquivalenceDistribution(left, right)` - Test whether two distribution values are equivalent in Probability. +19. `probabilityGenerateExampleDistribution(size=3)` - Generate a small documented example of a distribution. +20. `probabilityDocumentDistribution(value)` - Return a structured explanation of a distribution and related assumptions. +21. `probabilityValidateEventModel(value)` - Validate the event model representation and domain rules for Probability. +22. `probabilityConstructEventModel(*args)` - Construct a event model from explicit inputs for Probability. +23. `probabilityNormalizeEventModel(value)` - Normalize a event model into the standard Probability representation. +24. `probabilityCanonicalizeEventModel(value)` - Canonicalize a event model so equivalent inputs share one form. +25. `probabilityParseEventModel(text)` - Parse a text or structured value into a event model. +26. `probabilityFormatEventModel(value)` - Format a event model for deterministic user-facing output. +27. `probabilityCompareEventModel(left, right)` - Compare two event model values under the conventions of Probability. +28. `probabilityCombineEventModel(left, right)` - Combine two event model values with the natural operation for Probability. +29. `probabilityDecomposeEventModel(value)` - Decompose a event model into simpler or canonical components. +30. `probabilityEvaluateEventModel(value, point=None)` - Evaluate a event model at a point, sample, or finite model. +31. `probabilityComputeEventModel(value)` - Compute the central numerical or symbolic data of a event model. +32. `probabilityEstimateEventModel(value, samples=None)` - Estimate a event model property from finite samples or approximations. +33. `probabilityApproximateEventModel(value, tolerance=1e-9)` - Approximate a event model with explicit tolerance controls. +34. `probabilityTransformEventModel(value, mapping)` - Transform a event model through a map, operator, or representation change. +35. `probabilitySimplifyEventModel(value)` - Simplify a event model without changing its mathematical meaning. +36. `probabilityEnumerateEventModel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a event model. +37. `probabilityClassifyEventModel(value)` - Classify a event model by its standard Probability invariants. +38. `probabilityTestEquivalenceEventModel(left, right)` - Test whether two event model values are equivalent in Probability. +39. `probabilityGenerateExampleEventModel(size=3)` - Generate a small documented example of a event model. +40. `probabilityDocumentEventModel(value)` - Return a structured explanation of a event model and related assumptions. +41. `probabilityValidateDensityFunction(value)` - Validate the density function representation and domain rules for Probability. +42. `probabilityConstructDensityFunction(*args)` - Construct a density function from explicit inputs for Probability. +43. `probabilityNormalizeDensityFunction(value)` - Normalize a density function into the standard Probability representation. +44. `probabilityCanonicalizeDensityFunction(value)` - Canonicalize a density function so equivalent inputs share one form. +45. `probabilityParseDensityFunction(text)` - Parse a text or structured value into a density function. +46. `probabilityFormatDensityFunction(value)` - Format a density function for deterministic user-facing output. +47. `probabilityCompareDensityFunction(left, right)` - Compare two density function values under the conventions of Probability. +48. `probabilityCombineDensityFunction(left, right)` - Combine two density function values with the natural operation for Probability. +49. `probabilityDecomposeDensityFunction(value)` - Decompose a density function into simpler or canonical components. +50. `probabilityEvaluateDensityFunction(value, point=None)` - Evaluate a density function at a point, sample, or finite model. +51. `probabilityComputeDensityFunction(value)` - Compute the central numerical or symbolic data of a density function. +52. `probabilityEstimateDensityFunction(value, samples=None)` - Estimate a density function property from finite samples or approximations. +53. `probabilityApproximateDensityFunction(value, tolerance=1e-9)` - Approximate a density function with explicit tolerance controls. +54. `probabilityTransformDensityFunction(value, mapping)` - Transform a density function through a map, operator, or representation change. +55. `probabilitySimplifyDensityFunction(value)` - Simplify a density function without changing its mathematical meaning. +56. `probabilityEnumerateDensityFunction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a density function. +57. `probabilityClassifyDensityFunction(value)` - Classify a density function by its standard Probability invariants. +58. `probabilityTestEquivalenceDensityFunction(left, right)` - Test whether two density function values are equivalent in Probability. +59. `probabilityGenerateExampleDensityFunction(size=3)` - Generate a small documented example of a density function. +60. `probabilityDocumentDensityFunction(value)` - Return a structured explanation of a density function and related assumptions. +61. `probabilityValidateMassFunction(value)` - Validate the mass function representation and domain rules for Probability. +62. `probabilityConstructMassFunction(*args)` - Construct a mass function from explicit inputs for Probability. +63. `probabilityNormalizeMassFunction(value)` - Normalize a mass function into the standard Probability representation. +64. `probabilityCanonicalizeMassFunction(value)` - Canonicalize a mass function so equivalent inputs share one form. +65. `probabilityParseMassFunction(text)` - Parse a text or structured value into a mass function. +66. `probabilityFormatMassFunction(value)` - Format a mass function for deterministic user-facing output. +67. `probabilityCompareMassFunction(left, right)` - Compare two mass function values under the conventions of Probability. +68. `probabilityCombineMassFunction(left, right)` - Combine two mass function values with the natural operation for Probability. +69. `probabilityDecomposeMassFunction(value)` - Decompose a mass function into simpler or canonical components. +70. `probabilityEvaluateMassFunction(value, point=None)` - Evaluate a mass function at a point, sample, or finite model. +71. `probabilityComputeMassFunction(value)` - Compute the central numerical or symbolic data of a mass function. +72. `probabilityEstimateMassFunction(value, samples=None)` - Estimate a mass function property from finite samples or approximations. +73. `probabilityApproximateMassFunction(value, tolerance=1e-9)` - Approximate a mass function with explicit tolerance controls. +74. `probabilityTransformMassFunction(value, mapping)` - Transform a mass function through a map, operator, or representation change. +75. `probabilitySimplifyMassFunction(value)` - Simplify a mass function without changing its mathematical meaning. +76. `probabilityEnumerateMassFunction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a mass function. +77. `probabilityClassifyMassFunction(value)` - Classify a mass function by its standard Probability invariants. +78. `probabilityTestEquivalenceMassFunction(left, right)` - Test whether two mass function values are equivalent in Probability. +79. `probabilityGenerateExampleMassFunction(size=3)` - Generate a small documented example of a mass function. +80. `probabilityDocumentMassFunction(value)` - Return a structured explanation of a mass function and related assumptions. +81. `probabilityValidateProbabilitySpace(value)` - Validate the probability space representation and domain rules for Probability. +82. `probabilityConstructProbabilitySpace(*args)` - Construct a probability space from explicit inputs for Probability. +83. `probabilityNormalizeProbabilitySpace(value)` - Normalize a probability space into the standard Probability representation. +84. `probabilityCanonicalizeProbabilitySpace(value)` - Canonicalize a probability space so equivalent inputs share one form. +85. `probabilityParseProbabilitySpace(text)` - Parse a text or structured value into a probability space. +86. `probabilityFormatProbabilitySpace(value)` - Format a probability space for deterministic user-facing output. +87. `probabilityCompareProbabilitySpace(left, right)` - Compare two probability space values under the conventions of Probability. +88. `probabilityCombineProbabilitySpace(left, right)` - Combine two probability space values with the natural operation for Probability. +89. `probabilityDecomposeProbabilitySpace(value)` - Decompose a probability space into simpler or canonical components. +90. `probabilityEvaluateProbabilitySpace(value, point=None)` - Evaluate a probability space at a point, sample, or finite model. +91. `probabilityComputeProbabilitySpace(value)` - Compute the central numerical or symbolic data of a probability space. +92. `probabilityEstimateProbabilitySpace(value, samples=None)` - Estimate a probability space property from finite samples or approximations. +93. `probabilityApproximateProbabilitySpace(value, tolerance=1e-9)` - Approximate a probability space with explicit tolerance controls. +94. `probabilityTransformProbabilitySpace(value, mapping)` - Transform a probability space through a map, operator, or representation change. +95. `probabilitySimplifyProbabilitySpace(value)` - Simplify a probability space without changing its mathematical meaning. +96. `probabilityEnumerateProbabilitySpace(value, limit=None)` - Enumerate finite members, cases, or derived objects for a probability space. +97. `probabilityClassifyProbabilitySpace(value)` - Classify a probability space by its standard Probability invariants. +98. `probabilityTestEquivalenceProbabilitySpace(left, right)` - Test whether two probability space values are equivalent in Probability. +99. `probabilityGenerateExampleProbabilitySpace(size=3)` - Generate a small documented example of a probability space. +100. `probabilityDocumentProbabilitySpace(value)` - Return a structured explanation of a probability space and related assumptions. + +### Complex Numbers + +Core object families: + +- complex value +- rectangular form +- polar form +- complex operation +- complex sequence + +Candidate functions: + +1. `complexNumbersValidateComplexValue(value)` - Validate the complex value representation and domain rules for Complex Numbers. +2. `complexNumbersConstructComplexValue(*args)` - Construct a complex value from explicit inputs for Complex Numbers. +3. `complexNumbersNormalizeComplexValue(value)` - Normalize a complex value into the standard Complex Numbers representation. +4. `complexNumbersCanonicalizeComplexValue(value)` - Canonicalize a complex value so equivalent inputs share one form. +5. `complexNumbersParseComplexValue(text)` - Parse a text or structured value into a complex value. +6. `complexNumbersFormatComplexValue(value)` - Format a complex value for deterministic user-facing output. +7. `complexNumbersCompareComplexValue(left, right)` - Compare two complex value values under the conventions of Complex Numbers. +8. `complexNumbersCombineComplexValue(left, right)` - Combine two complex value values with the natural operation for Complex Numbers. +9. `complexNumbersDecomposeComplexValue(value)` - Decompose a complex value into simpler or canonical components. +10. `complexNumbersEvaluateComplexValue(value, point=None)` - Evaluate a complex value at a point, sample, or finite model. +11. `complexNumbersComputeComplexValue(value)` - Compute the central numerical or symbolic data of a complex value. +12. `complexNumbersEstimateComplexValue(value, samples=None)` - Estimate a complex value property from finite samples or approximations. +13. `complexNumbersApproximateComplexValue(value, tolerance=1e-9)` - Approximate a complex value with explicit tolerance controls. +14. `complexNumbersTransformComplexValue(value, mapping)` - Transform a complex value through a map, operator, or representation change. +15. `complexNumbersSimplifyComplexValue(value)` - Simplify a complex value without changing its mathematical meaning. +16. `complexNumbersEnumerateComplexValue(value, limit=None)` - Enumerate finite members, cases, or derived objects for a complex value. +17. `complexNumbersClassifyComplexValue(value)` - Classify a complex value by its standard Complex Numbers invariants. +18. `complexNumbersTestEquivalenceComplexValue(left, right)` - Test whether two complex value values are equivalent in Complex Numbers. +19. `complexNumbersGenerateExampleComplexValue(size=3)` - Generate a small documented example of a complex value. +20. `complexNumbersDocumentComplexValue(value)` - Return a structured explanation of a complex value and related assumptions. +21. `complexNumbersValidateRectangularForm(value)` - Validate the rectangular form representation and domain rules for Complex Numbers. +22. `complexNumbersConstructRectangularForm(*args)` - Construct a rectangular form from explicit inputs for Complex Numbers. +23. `complexNumbersNormalizeRectangularForm(value)` - Normalize a rectangular form into the standard Complex Numbers representation. +24. `complexNumbersCanonicalizeRectangularForm(value)` - Canonicalize a rectangular form so equivalent inputs share one form. +25. `complexNumbersParseRectangularForm(text)` - Parse a text or structured value into a rectangular form. +26. `complexNumbersFormatRectangularForm(value)` - Format a rectangular form for deterministic user-facing output. +27. `complexNumbersCompareRectangularForm(left, right)` - Compare two rectangular form values under the conventions of Complex Numbers. +28. `complexNumbersCombineRectangularForm(left, right)` - Combine two rectangular form values with the natural operation for Complex Numbers. +29. `complexNumbersDecomposeRectangularForm(value)` - Decompose a rectangular form into simpler or canonical components. +30. `complexNumbersEvaluateRectangularForm(value, point=None)` - Evaluate a rectangular form at a point, sample, or finite model. +31. `complexNumbersComputeRectangularForm(value)` - Compute the central numerical or symbolic data of a rectangular form. +32. `complexNumbersEstimateRectangularForm(value, samples=None)` - Estimate a rectangular form property from finite samples or approximations. +33. `complexNumbersApproximateRectangularForm(value, tolerance=1e-9)` - Approximate a rectangular form with explicit tolerance controls. +34. `complexNumbersTransformRectangularForm(value, mapping)` - Transform a rectangular form through a map, operator, or representation change. +35. `complexNumbersSimplifyRectangularForm(value)` - Simplify a rectangular form without changing its mathematical meaning. +36. `complexNumbersEnumerateRectangularForm(value, limit=None)` - Enumerate finite members, cases, or derived objects for a rectangular form. +37. `complexNumbersClassifyRectangularForm(value)` - Classify a rectangular form by its standard Complex Numbers invariants. +38. `complexNumbersTestEquivalenceRectangularForm(left, right)` - Test whether two rectangular form values are equivalent in Complex Numbers. +39. `complexNumbersGenerateExampleRectangularForm(size=3)` - Generate a small documented example of a rectangular form. +40. `complexNumbersDocumentRectangularForm(value)` - Return a structured explanation of a rectangular form and related assumptions. +41. `complexNumbersValidatePolarForm(value)` - Validate the polar form representation and domain rules for Complex Numbers. +42. `complexNumbersConstructPolarForm(*args)` - Construct a polar form from explicit inputs for Complex Numbers. +43. `complexNumbersNormalizePolarForm(value)` - Normalize a polar form into the standard Complex Numbers representation. +44. `complexNumbersCanonicalizePolarForm(value)` - Canonicalize a polar form so equivalent inputs share one form. +45. `complexNumbersParsePolarForm(text)` - Parse a text or structured value into a polar form. +46. `complexNumbersFormatPolarForm(value)` - Format a polar form for deterministic user-facing output. +47. `complexNumbersComparePolarForm(left, right)` - Compare two polar form values under the conventions of Complex Numbers. +48. `complexNumbersCombinePolarForm(left, right)` - Combine two polar form values with the natural operation for Complex Numbers. +49. `complexNumbersDecomposePolarForm(value)` - Decompose a polar form into simpler or canonical components. +50. `complexNumbersEvaluatePolarForm(value, point=None)` - Evaluate a polar form at a point, sample, or finite model. +51. `complexNumbersComputePolarForm(value)` - Compute the central numerical or symbolic data of a polar form. +52. `complexNumbersEstimatePolarForm(value, samples=None)` - Estimate a polar form property from finite samples or approximations. +53. `complexNumbersApproximatePolarForm(value, tolerance=1e-9)` - Approximate a polar form with explicit tolerance controls. +54. `complexNumbersTransformPolarForm(value, mapping)` - Transform a polar form through a map, operator, or representation change. +55. `complexNumbersSimplifyPolarForm(value)` - Simplify a polar form without changing its mathematical meaning. +56. `complexNumbersEnumeratePolarForm(value, limit=None)` - Enumerate finite members, cases, or derived objects for a polar form. +57. `complexNumbersClassifyPolarForm(value)` - Classify a polar form by its standard Complex Numbers invariants. +58. `complexNumbersTestEquivalencePolarForm(left, right)` - Test whether two polar form values are equivalent in Complex Numbers. +59. `complexNumbersGenerateExamplePolarForm(size=3)` - Generate a small documented example of a polar form. +60. `complexNumbersDocumentPolarForm(value)` - Return a structured explanation of a polar form and related assumptions. +61. `complexNumbersValidateComplexOperation(value)` - Validate the complex operation representation and domain rules for Complex Numbers. +62. `complexNumbersConstructComplexOperation(*args)` - Construct a complex operation from explicit inputs for Complex Numbers. +63. `complexNumbersNormalizeComplexOperation(value)` - Normalize a complex operation into the standard Complex Numbers representation. +64. `complexNumbersCanonicalizeComplexOperation(value)` - Canonicalize a complex operation so equivalent inputs share one form. +65. `complexNumbersParseComplexOperation(text)` - Parse a text or structured value into a complex operation. +66. `complexNumbersFormatComplexOperation(value)` - Format a complex operation for deterministic user-facing output. +67. `complexNumbersCompareComplexOperation(left, right)` - Compare two complex operation values under the conventions of Complex Numbers. +68. `complexNumbersCombineComplexOperation(left, right)` - Combine two complex operation values with the natural operation for Complex Numbers. +69. `complexNumbersDecomposeComplexOperation(value)` - Decompose a complex operation into simpler or canonical components. +70. `complexNumbersEvaluateComplexOperation(value, point=None)` - Evaluate a complex operation at a point, sample, or finite model. +71. `complexNumbersComputeComplexOperation(value)` - Compute the central numerical or symbolic data of a complex operation. +72. `complexNumbersEstimateComplexOperation(value, samples=None)` - Estimate a complex operation property from finite samples or approximations. +73. `complexNumbersApproximateComplexOperation(value, tolerance=1e-9)` - Approximate a complex operation with explicit tolerance controls. +74. `complexNumbersTransformComplexOperation(value, mapping)` - Transform a complex operation through a map, operator, or representation change. +75. `complexNumbersSimplifyComplexOperation(value)` - Simplify a complex operation without changing its mathematical meaning. +76. `complexNumbersEnumerateComplexOperation(value, limit=None)` - Enumerate finite members, cases, or derived objects for a complex operation. +77. `complexNumbersClassifyComplexOperation(value)` - Classify a complex operation by its standard Complex Numbers invariants. +78. `complexNumbersTestEquivalenceComplexOperation(left, right)` - Test whether two complex operation values are equivalent in Complex Numbers. +79. `complexNumbersGenerateExampleComplexOperation(size=3)` - Generate a small documented example of a complex operation. +80. `complexNumbersDocumentComplexOperation(value)` - Return a structured explanation of a complex operation and related assumptions. +81. `complexNumbersValidateComplexSequence(value)` - Validate the complex sequence representation and domain rules for Complex Numbers. +82. `complexNumbersConstructComplexSequence(*args)` - Construct a complex sequence from explicit inputs for Complex Numbers. +83. `complexNumbersNormalizeComplexSequence(value)` - Normalize a complex sequence into the standard Complex Numbers representation. +84. `complexNumbersCanonicalizeComplexSequence(value)` - Canonicalize a complex sequence so equivalent inputs share one form. +85. `complexNumbersParseComplexSequence(text)` - Parse a text or structured value into a complex sequence. +86. `complexNumbersFormatComplexSequence(value)` - Format a complex sequence for deterministic user-facing output. +87. `complexNumbersCompareComplexSequence(left, right)` - Compare two complex sequence values under the conventions of Complex Numbers. +88. `complexNumbersCombineComplexSequence(left, right)` - Combine two complex sequence values with the natural operation for Complex Numbers. +89. `complexNumbersDecomposeComplexSequence(value)` - Decompose a complex sequence into simpler or canonical components. +90. `complexNumbersEvaluateComplexSequence(value, point=None)` - Evaluate a complex sequence at a point, sample, or finite model. +91. `complexNumbersComputeComplexSequence(value)` - Compute the central numerical or symbolic data of a complex sequence. +92. `complexNumbersEstimateComplexSequence(value, samples=None)` - Estimate a complex sequence property from finite samples or approximations. +93. `complexNumbersApproximateComplexSequence(value, tolerance=1e-9)` - Approximate a complex sequence with explicit tolerance controls. +94. `complexNumbersTransformComplexSequence(value, mapping)` - Transform a complex sequence through a map, operator, or representation change. +95. `complexNumbersSimplifyComplexSequence(value)` - Simplify a complex sequence without changing its mathematical meaning. +96. `complexNumbersEnumerateComplexSequence(value, limit=None)` - Enumerate finite members, cases, or derived objects for a complex sequence. +97. `complexNumbersClassifyComplexSequence(value)` - Classify a complex sequence by its standard Complex Numbers invariants. +98. `complexNumbersTestEquivalenceComplexSequence(left, right)` - Test whether two complex sequence values are equivalent in Complex Numbers. +99. `complexNumbersGenerateExampleComplexSequence(size=3)` - Generate a small documented example of a complex sequence. +100. `complexNumbersDocumentComplexSequence(value)` - Return a structured explanation of a complex sequence and related assumptions. + +### Trigonometry + +Core object families: + +- angle +- triangle model +- trig identity +- periodic function +- hyperbolic function + +Candidate functions: + +1. `trigonometryValidateAngle(value)` - Validate the angle representation and domain rules for Trigonometry. +2. `trigonometryConstructAngle(*args)` - Construct a angle from explicit inputs for Trigonometry. +3. `trigonometryNormalizeAngle(value)` - Normalize a angle into the standard Trigonometry representation. +4. `trigonometryCanonicalizeAngle(value)` - Canonicalize a angle so equivalent inputs share one form. +5. `trigonometryParseAngle(text)` - Parse a text or structured value into a angle. +6. `trigonometryFormatAngle(value)` - Format a angle for deterministic user-facing output. +7. `trigonometryCompareAngle(left, right)` - Compare two angle values under the conventions of Trigonometry. +8. `trigonometryCombineAngle(left, right)` - Combine two angle values with the natural operation for Trigonometry. +9. `trigonometryDecomposeAngle(value)` - Decompose a angle into simpler or canonical components. +10. `trigonometryEvaluateAngle(value, point=None)` - Evaluate a angle at a point, sample, or finite model. +11. `trigonometryComputeAngle(value)` - Compute the central numerical or symbolic data of a angle. +12. `trigonometryEstimateAngle(value, samples=None)` - Estimate a angle property from finite samples or approximations. +13. `trigonometryApproximateAngle(value, tolerance=1e-9)` - Approximate a angle with explicit tolerance controls. +14. `trigonometryTransformAngle(value, mapping)` - Transform a angle through a map, operator, or representation change. +15. `trigonometrySimplifyAngle(value)` - Simplify a angle without changing its mathematical meaning. +16. `trigonometryEnumerateAngle(value, limit=None)` - Enumerate finite members, cases, or derived objects for a angle. +17. `trigonometryClassifyAngle(value)` - Classify a angle by its standard Trigonometry invariants. +18. `trigonometryTestEquivalenceAngle(left, right)` - Test whether two angle values are equivalent in Trigonometry. +19. `trigonometryGenerateExampleAngle(size=3)` - Generate a small documented example of a angle. +20. `trigonometryDocumentAngle(value)` - Return a structured explanation of a angle and related assumptions. +21. `trigonometryValidateTriangleModel(value)` - Validate the triangle model representation and domain rules for Trigonometry. +22. `trigonometryConstructTriangleModel(*args)` - Construct a triangle model from explicit inputs for Trigonometry. +23. `trigonometryNormalizeTriangleModel(value)` - Normalize a triangle model into the standard Trigonometry representation. +24. `trigonometryCanonicalizeTriangleModel(value)` - Canonicalize a triangle model so equivalent inputs share one form. +25. `trigonometryParseTriangleModel(text)` - Parse a text or structured value into a triangle model. +26. `trigonometryFormatTriangleModel(value)` - Format a triangle model for deterministic user-facing output. +27. `trigonometryCompareTriangleModel(left, right)` - Compare two triangle model values under the conventions of Trigonometry. +28. `trigonometryCombineTriangleModel(left, right)` - Combine two triangle model values with the natural operation for Trigonometry. +29. `trigonometryDecomposeTriangleModel(value)` - Decompose a triangle model into simpler or canonical components. +30. `trigonometryEvaluateTriangleModel(value, point=None)` - Evaluate a triangle model at a point, sample, or finite model. +31. `trigonometryComputeTriangleModel(value)` - Compute the central numerical or symbolic data of a triangle model. +32. `trigonometryEstimateTriangleModel(value, samples=None)` - Estimate a triangle model property from finite samples or approximations. +33. `trigonometryApproximateTriangleModel(value, tolerance=1e-9)` - Approximate a triangle model with explicit tolerance controls. +34. `trigonometryTransformTriangleModel(value, mapping)` - Transform a triangle model through a map, operator, or representation change. +35. `trigonometrySimplifyTriangleModel(value)` - Simplify a triangle model without changing its mathematical meaning. +36. `trigonometryEnumerateTriangleModel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a triangle model. +37. `trigonometryClassifyTriangleModel(value)` - Classify a triangle model by its standard Trigonometry invariants. +38. `trigonometryTestEquivalenceTriangleModel(left, right)` - Test whether two triangle model values are equivalent in Trigonometry. +39. `trigonometryGenerateExampleTriangleModel(size=3)` - Generate a small documented example of a triangle model. +40. `trigonometryDocumentTriangleModel(value)` - Return a structured explanation of a triangle model and related assumptions. +41. `trigonometryValidateTrigIdentity(value)` - Validate the trig identity representation and domain rules for Trigonometry. +42. `trigonometryConstructTrigIdentity(*args)` - Construct a trig identity from explicit inputs for Trigonometry. +43. `trigonometryNormalizeTrigIdentity(value)` - Normalize a trig identity into the standard Trigonometry representation. +44. `trigonometryCanonicalizeTrigIdentity(value)` - Canonicalize a trig identity so equivalent inputs share one form. +45. `trigonometryParseTrigIdentity(text)` - Parse a text or structured value into a trig identity. +46. `trigonometryFormatTrigIdentity(value)` - Format a trig identity for deterministic user-facing output. +47. `trigonometryCompareTrigIdentity(left, right)` - Compare two trig identity values under the conventions of Trigonometry. +48. `trigonometryCombineTrigIdentity(left, right)` - Combine two trig identity values with the natural operation for Trigonometry. +49. `trigonometryDecomposeTrigIdentity(value)` - Decompose a trig identity into simpler or canonical components. +50. `trigonometryEvaluateTrigIdentity(value, point=None)` - Evaluate a trig identity at a point, sample, or finite model. +51. `trigonometryComputeTrigIdentity(value)` - Compute the central numerical or symbolic data of a trig identity. +52. `trigonometryEstimateTrigIdentity(value, samples=None)` - Estimate a trig identity property from finite samples or approximations. +53. `trigonometryApproximateTrigIdentity(value, tolerance=1e-9)` - Approximate a trig identity with explicit tolerance controls. +54. `trigonometryTransformTrigIdentity(value, mapping)` - Transform a trig identity through a map, operator, or representation change. +55. `trigonometrySimplifyTrigIdentity(value)` - Simplify a trig identity without changing its mathematical meaning. +56. `trigonometryEnumerateTrigIdentity(value, limit=None)` - Enumerate finite members, cases, or derived objects for a trig identity. +57. `trigonometryClassifyTrigIdentity(value)` - Classify a trig identity by its standard Trigonometry invariants. +58. `trigonometryTestEquivalenceTrigIdentity(left, right)` - Test whether two trig identity values are equivalent in Trigonometry. +59. `trigonometryGenerateExampleTrigIdentity(size=3)` - Generate a small documented example of a trig identity. +60. `trigonometryDocumentTrigIdentity(value)` - Return a structured explanation of a trig identity and related assumptions. +61. `trigonometryValidatePeriodicFunction(value)` - Validate the periodic function representation and domain rules for Trigonometry. +62. `trigonometryConstructPeriodicFunction(*args)` - Construct a periodic function from explicit inputs for Trigonometry. +63. `trigonometryNormalizePeriodicFunction(value)` - Normalize a periodic function into the standard Trigonometry representation. +64. `trigonometryCanonicalizePeriodicFunction(value)` - Canonicalize a periodic function so equivalent inputs share one form. +65. `trigonometryParsePeriodicFunction(text)` - Parse a text or structured value into a periodic function. +66. `trigonometryFormatPeriodicFunction(value)` - Format a periodic function for deterministic user-facing output. +67. `trigonometryComparePeriodicFunction(left, right)` - Compare two periodic function values under the conventions of Trigonometry. +68. `trigonometryCombinePeriodicFunction(left, right)` - Combine two periodic function values with the natural operation for Trigonometry. +69. `trigonometryDecomposePeriodicFunction(value)` - Decompose a periodic function into simpler or canonical components. +70. `trigonometryEvaluatePeriodicFunction(value, point=None)` - Evaluate a periodic function at a point, sample, or finite model. +71. `trigonometryComputePeriodicFunction(value)` - Compute the central numerical or symbolic data of a periodic function. +72. `trigonometryEstimatePeriodicFunction(value, samples=None)` - Estimate a periodic function property from finite samples or approximations. +73. `trigonometryApproximatePeriodicFunction(value, tolerance=1e-9)` - Approximate a periodic function with explicit tolerance controls. +74. `trigonometryTransformPeriodicFunction(value, mapping)` - Transform a periodic function through a map, operator, or representation change. +75. `trigonometrySimplifyPeriodicFunction(value)` - Simplify a periodic function without changing its mathematical meaning. +76. `trigonometryEnumeratePeriodicFunction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a periodic function. +77. `trigonometryClassifyPeriodicFunction(value)` - Classify a periodic function by its standard Trigonometry invariants. +78. `trigonometryTestEquivalencePeriodicFunction(left, right)` - Test whether two periodic function values are equivalent in Trigonometry. +79. `trigonometryGenerateExamplePeriodicFunction(size=3)` - Generate a small documented example of a periodic function. +80. `trigonometryDocumentPeriodicFunction(value)` - Return a structured explanation of a periodic function and related assumptions. +81. `trigonometryValidateHyperbolicFunction(value)` - Validate the hyperbolic function representation and domain rules for Trigonometry. +82. `trigonometryConstructHyperbolicFunction(*args)` - Construct a hyperbolic function from explicit inputs for Trigonometry. +83. `trigonometryNormalizeHyperbolicFunction(value)` - Normalize a hyperbolic function into the standard Trigonometry representation. +84. `trigonometryCanonicalizeHyperbolicFunction(value)` - Canonicalize a hyperbolic function so equivalent inputs share one form. +85. `trigonometryParseHyperbolicFunction(text)` - Parse a text or structured value into a hyperbolic function. +86. `trigonometryFormatHyperbolicFunction(value)` - Format a hyperbolic function for deterministic user-facing output. +87. `trigonometryCompareHyperbolicFunction(left, right)` - Compare two hyperbolic function values under the conventions of Trigonometry. +88. `trigonometryCombineHyperbolicFunction(left, right)` - Combine two hyperbolic function values with the natural operation for Trigonometry. +89. `trigonometryDecomposeHyperbolicFunction(value)` - Decompose a hyperbolic function into simpler or canonical components. +90. `trigonometryEvaluateHyperbolicFunction(value, point=None)` - Evaluate a hyperbolic function at a point, sample, or finite model. +91. `trigonometryComputeHyperbolicFunction(value)` - Compute the central numerical or symbolic data of a hyperbolic function. +92. `trigonometryEstimateHyperbolicFunction(value, samples=None)` - Estimate a hyperbolic function property from finite samples or approximations. +93. `trigonometryApproximateHyperbolicFunction(value, tolerance=1e-9)` - Approximate a hyperbolic function with explicit tolerance controls. +94. `trigonometryTransformHyperbolicFunction(value, mapping)` - Transform a hyperbolic function through a map, operator, or representation change. +95. `trigonometrySimplifyHyperbolicFunction(value)` - Simplify a hyperbolic function without changing its mathematical meaning. +96. `trigonometryEnumerateHyperbolicFunction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a hyperbolic function. +97. `trigonometryClassifyHyperbolicFunction(value)` - Classify a hyperbolic function by its standard Trigonometry invariants. +98. `trigonometryTestEquivalenceHyperbolicFunction(left, right)` - Test whether two hyperbolic function values are equivalent in Trigonometry. +99. `trigonometryGenerateExampleHyperbolicFunction(size=3)` - Generate a small documented example of a hyperbolic function. +100. `trigonometryDocumentHyperbolicFunction(value)` - Return a structured explanation of a hyperbolic function and related assumptions. + +### Quantitative Analysis + +Core object families: + +- data sequence +- extremum profile +- trend segment +- change profile +- ranking model + +Candidate functions: + +1. `quantitativeAnalysisValidateDataSequence(value)` - Validate the data sequence representation and domain rules for Quantitative Analysis. +2. `quantitativeAnalysisConstructDataSequence(*args)` - Construct a data sequence from explicit inputs for Quantitative Analysis. +3. `quantitativeAnalysisNormalizeDataSequence(value)` - Normalize a data sequence into the standard Quantitative Analysis representation. +4. `quantitativeAnalysisCanonicalizeDataSequence(value)` - Canonicalize a data sequence so equivalent inputs share one form. +5. `quantitativeAnalysisParseDataSequence(text)` - Parse a text or structured value into a data sequence. +6. `quantitativeAnalysisFormatDataSequence(value)` - Format a data sequence for deterministic user-facing output. +7. `quantitativeAnalysisCompareDataSequence(left, right)` - Compare two data sequence values under the conventions of Quantitative Analysis. +8. `quantitativeAnalysisCombineDataSequence(left, right)` - Combine two data sequence values with the natural operation for Quantitative Analysis. +9. `quantitativeAnalysisDecomposeDataSequence(value)` - Decompose a data sequence into simpler or canonical components. +10. `quantitativeAnalysisEvaluateDataSequence(value, point=None)` - Evaluate a data sequence at a point, sample, or finite model. +11. `quantitativeAnalysisComputeDataSequence(value)` - Compute the central numerical or symbolic data of a data sequence. +12. `quantitativeAnalysisEstimateDataSequence(value, samples=None)` - Estimate a data sequence property from finite samples or approximations. +13. `quantitativeAnalysisApproximateDataSequence(value, tolerance=1e-9)` - Approximate a data sequence with explicit tolerance controls. +14. `quantitativeAnalysisTransformDataSequence(value, mapping)` - Transform a data sequence through a map, operator, or representation change. +15. `quantitativeAnalysisSimplifyDataSequence(value)` - Simplify a data sequence without changing its mathematical meaning. +16. `quantitativeAnalysisEnumerateDataSequence(value, limit=None)` - Enumerate finite members, cases, or derived objects for a data sequence. +17. `quantitativeAnalysisClassifyDataSequence(value)` - Classify a data sequence by its standard Quantitative Analysis invariants. +18. `quantitativeAnalysisTestEquivalenceDataSequence(left, right)` - Test whether two data sequence values are equivalent in Quantitative Analysis. +19. `quantitativeAnalysisGenerateExampleDataSequence(size=3)` - Generate a small documented example of a data sequence. +20. `quantitativeAnalysisDocumentDataSequence(value)` - Return a structured explanation of a data sequence and related assumptions. +21. `quantitativeAnalysisValidateExtremumProfile(value)` - Validate the extremum profile representation and domain rules for Quantitative Analysis. +22. `quantitativeAnalysisConstructExtremumProfile(*args)` - Construct a extremum profile from explicit inputs for Quantitative Analysis. +23. `quantitativeAnalysisNormalizeExtremumProfile(value)` - Normalize a extremum profile into the standard Quantitative Analysis representation. +24. `quantitativeAnalysisCanonicalizeExtremumProfile(value)` - Canonicalize a extremum profile so equivalent inputs share one form. +25. `quantitativeAnalysisParseExtremumProfile(text)` - Parse a text or structured value into a extremum profile. +26. `quantitativeAnalysisFormatExtremumProfile(value)` - Format a extremum profile for deterministic user-facing output. +27. `quantitativeAnalysisCompareExtremumProfile(left, right)` - Compare two extremum profile values under the conventions of Quantitative Analysis. +28. `quantitativeAnalysisCombineExtremumProfile(left, right)` - Combine two extremum profile values with the natural operation for Quantitative Analysis. +29. `quantitativeAnalysisDecomposeExtremumProfile(value)` - Decompose a extremum profile into simpler or canonical components. +30. `quantitativeAnalysisEvaluateExtremumProfile(value, point=None)` - Evaluate a extremum profile at a point, sample, or finite model. +31. `quantitativeAnalysisComputeExtremumProfile(value)` - Compute the central numerical or symbolic data of a extremum profile. +32. `quantitativeAnalysisEstimateExtremumProfile(value, samples=None)` - Estimate a extremum profile property from finite samples or approximations. +33. `quantitativeAnalysisApproximateExtremumProfile(value, tolerance=1e-9)` - Approximate a extremum profile with explicit tolerance controls. +34. `quantitativeAnalysisTransformExtremumProfile(value, mapping)` - Transform a extremum profile through a map, operator, or representation change. +35. `quantitativeAnalysisSimplifyExtremumProfile(value)` - Simplify a extremum profile without changing its mathematical meaning. +36. `quantitativeAnalysisEnumerateExtremumProfile(value, limit=None)` - Enumerate finite members, cases, or derived objects for a extremum profile. +37. `quantitativeAnalysisClassifyExtremumProfile(value)` - Classify a extremum profile by its standard Quantitative Analysis invariants. +38. `quantitativeAnalysisTestEquivalenceExtremumProfile(left, right)` - Test whether two extremum profile values are equivalent in Quantitative Analysis. +39. `quantitativeAnalysisGenerateExampleExtremumProfile(size=3)` - Generate a small documented example of a extremum profile. +40. `quantitativeAnalysisDocumentExtremumProfile(value)` - Return a structured explanation of a extremum profile and related assumptions. +41. `quantitativeAnalysisValidateTrendSegment(value)` - Validate the trend segment representation and domain rules for Quantitative Analysis. +42. `quantitativeAnalysisConstructTrendSegment(*args)` - Construct a trend segment from explicit inputs for Quantitative Analysis. +43. `quantitativeAnalysisNormalizeTrendSegment(value)` - Normalize a trend segment into the standard Quantitative Analysis representation. +44. `quantitativeAnalysisCanonicalizeTrendSegment(value)` - Canonicalize a trend segment so equivalent inputs share one form. +45. `quantitativeAnalysisParseTrendSegment(text)` - Parse a text or structured value into a trend segment. +46. `quantitativeAnalysisFormatTrendSegment(value)` - Format a trend segment for deterministic user-facing output. +47. `quantitativeAnalysisCompareTrendSegment(left, right)` - Compare two trend segment values under the conventions of Quantitative Analysis. +48. `quantitativeAnalysisCombineTrendSegment(left, right)` - Combine two trend segment values with the natural operation for Quantitative Analysis. +49. `quantitativeAnalysisDecomposeTrendSegment(value)` - Decompose a trend segment into simpler or canonical components. +50. `quantitativeAnalysisEvaluateTrendSegment(value, point=None)` - Evaluate a trend segment at a point, sample, or finite model. +51. `quantitativeAnalysisComputeTrendSegment(value)` - Compute the central numerical or symbolic data of a trend segment. +52. `quantitativeAnalysisEstimateTrendSegment(value, samples=None)` - Estimate a trend segment property from finite samples or approximations. +53. `quantitativeAnalysisApproximateTrendSegment(value, tolerance=1e-9)` - Approximate a trend segment with explicit tolerance controls. +54. `quantitativeAnalysisTransformTrendSegment(value, mapping)` - Transform a trend segment through a map, operator, or representation change. +55. `quantitativeAnalysisSimplifyTrendSegment(value)` - Simplify a trend segment without changing its mathematical meaning. +56. `quantitativeAnalysisEnumerateTrendSegment(value, limit=None)` - Enumerate finite members, cases, or derived objects for a trend segment. +57. `quantitativeAnalysisClassifyTrendSegment(value)` - Classify a trend segment by its standard Quantitative Analysis invariants. +58. `quantitativeAnalysisTestEquivalenceTrendSegment(left, right)` - Test whether two trend segment values are equivalent in Quantitative Analysis. +59. `quantitativeAnalysisGenerateExampleTrendSegment(size=3)` - Generate a small documented example of a trend segment. +60. `quantitativeAnalysisDocumentTrendSegment(value)` - Return a structured explanation of a trend segment and related assumptions. +61. `quantitativeAnalysisValidateChangeProfile(value)` - Validate the change profile representation and domain rules for Quantitative Analysis. +62. `quantitativeAnalysisConstructChangeProfile(*args)` - Construct a change profile from explicit inputs for Quantitative Analysis. +63. `quantitativeAnalysisNormalizeChangeProfile(value)` - Normalize a change profile into the standard Quantitative Analysis representation. +64. `quantitativeAnalysisCanonicalizeChangeProfile(value)` - Canonicalize a change profile so equivalent inputs share one form. +65. `quantitativeAnalysisParseChangeProfile(text)` - Parse a text or structured value into a change profile. +66. `quantitativeAnalysisFormatChangeProfile(value)` - Format a change profile for deterministic user-facing output. +67. `quantitativeAnalysisCompareChangeProfile(left, right)` - Compare two change profile values under the conventions of Quantitative Analysis. +68. `quantitativeAnalysisCombineChangeProfile(left, right)` - Combine two change profile values with the natural operation for Quantitative Analysis. +69. `quantitativeAnalysisDecomposeChangeProfile(value)` - Decompose a change profile into simpler or canonical components. +70. `quantitativeAnalysisEvaluateChangeProfile(value, point=None)` - Evaluate a change profile at a point, sample, or finite model. +71. `quantitativeAnalysisComputeChangeProfile(value)` - Compute the central numerical or symbolic data of a change profile. +72. `quantitativeAnalysisEstimateChangeProfile(value, samples=None)` - Estimate a change profile property from finite samples or approximations. +73. `quantitativeAnalysisApproximateChangeProfile(value, tolerance=1e-9)` - Approximate a change profile with explicit tolerance controls. +74. `quantitativeAnalysisTransformChangeProfile(value, mapping)` - Transform a change profile through a map, operator, or representation change. +75. `quantitativeAnalysisSimplifyChangeProfile(value)` - Simplify a change profile without changing its mathematical meaning. +76. `quantitativeAnalysisEnumerateChangeProfile(value, limit=None)` - Enumerate finite members, cases, or derived objects for a change profile. +77. `quantitativeAnalysisClassifyChangeProfile(value)` - Classify a change profile by its standard Quantitative Analysis invariants. +78. `quantitativeAnalysisTestEquivalenceChangeProfile(left, right)` - Test whether two change profile values are equivalent in Quantitative Analysis. +79. `quantitativeAnalysisGenerateExampleChangeProfile(size=3)` - Generate a small documented example of a change profile. +80. `quantitativeAnalysisDocumentChangeProfile(value)` - Return a structured explanation of a change profile and related assumptions. +81. `quantitativeAnalysisValidateRankingModel(value)` - Validate the ranking model representation and domain rules for Quantitative Analysis. +82. `quantitativeAnalysisConstructRankingModel(*args)` - Construct a ranking model from explicit inputs for Quantitative Analysis. +83. `quantitativeAnalysisNormalizeRankingModel(value)` - Normalize a ranking model into the standard Quantitative Analysis representation. +84. `quantitativeAnalysisCanonicalizeRankingModel(value)` - Canonicalize a ranking model so equivalent inputs share one form. +85. `quantitativeAnalysisParseRankingModel(text)` - Parse a text or structured value into a ranking model. +86. `quantitativeAnalysisFormatRankingModel(value)` - Format a ranking model for deterministic user-facing output. +87. `quantitativeAnalysisCompareRankingModel(left, right)` - Compare two ranking model values under the conventions of Quantitative Analysis. +88. `quantitativeAnalysisCombineRankingModel(left, right)` - Combine two ranking model values with the natural operation for Quantitative Analysis. +89. `quantitativeAnalysisDecomposeRankingModel(value)` - Decompose a ranking model into simpler or canonical components. +90. `quantitativeAnalysisEvaluateRankingModel(value, point=None)` - Evaluate a ranking model at a point, sample, or finite model. +91. `quantitativeAnalysisComputeRankingModel(value)` - Compute the central numerical or symbolic data of a ranking model. +92. `quantitativeAnalysisEstimateRankingModel(value, samples=None)` - Estimate a ranking model property from finite samples or approximations. +93. `quantitativeAnalysisApproximateRankingModel(value, tolerance=1e-9)` - Approximate a ranking model with explicit tolerance controls. +94. `quantitativeAnalysisTransformRankingModel(value, mapping)` - Transform a ranking model through a map, operator, or representation change. +95. `quantitativeAnalysisSimplifyRankingModel(value)` - Simplify a ranking model without changing its mathematical meaning. +96. `quantitativeAnalysisEnumerateRankingModel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a ranking model. +97. `quantitativeAnalysisClassifyRankingModel(value)` - Classify a ranking model by its standard Quantitative Analysis invariants. +98. `quantitativeAnalysisTestEquivalenceRankingModel(left, right)` - Test whether two ranking model values are equivalent in Quantitative Analysis. +99. `quantitativeAnalysisGenerateExampleRankingModel(size=3)` - Generate a small documented example of a ranking model. +100. `quantitativeAnalysisDocumentRankingModel(value)` - Return a structured explanation of a ranking model and related assumptions. + +### Statistics + +Core object families: + +- sample +- estimator +- summary statistic +- regression model +- distribution summary + +Candidate functions: + +1. `statisticsValidateSample(value)` - Validate the sample representation and domain rules for Statistics. +2. `statisticsConstructSample(*args)` - Construct a sample from explicit inputs for Statistics. +3. `statisticsNormalizeSample(value)` - Normalize a sample into the standard Statistics representation. +4. `statisticsCanonicalizeSample(value)` - Canonicalize a sample so equivalent inputs share one form. +5. `statisticsParseSample(text)` - Parse a text or structured value into a sample. +6. `statisticsFormatSample(value)` - Format a sample for deterministic user-facing output. +7. `statisticsCompareSample(left, right)` - Compare two sample values under the conventions of Statistics. +8. `statisticsCombineSample(left, right)` - Combine two sample values with the natural operation for Statistics. +9. `statisticsDecomposeSample(value)` - Decompose a sample into simpler or canonical components. +10. `statisticsEvaluateSample(value, point=None)` - Evaluate a sample at a point, sample, or finite model. +11. `statisticsComputeSample(value)` - Compute the central numerical or symbolic data of a sample. +12. `statisticsEstimateSample(value, samples=None)` - Estimate a sample property from finite samples or approximations. +13. `statisticsApproximateSample(value, tolerance=1e-9)` - Approximate a sample with explicit tolerance controls. +14. `statisticsTransformSample(value, mapping)` - Transform a sample through a map, operator, or representation change. +15. `statisticsSimplifySample(value)` - Simplify a sample without changing its mathematical meaning. +16. `statisticsEnumerateSample(value, limit=None)` - Enumerate finite members, cases, or derived objects for a sample. +17. `statisticsClassifySample(value)` - Classify a sample by its standard Statistics invariants. +18. `statisticsTestEquivalenceSample(left, right)` - Test whether two sample values are equivalent in Statistics. +19. `statisticsGenerateExampleSample(size=3)` - Generate a small documented example of a sample. +20. `statisticsDocumentSample(value)` - Return a structured explanation of a sample and related assumptions. +21. `statisticsValidateEstimator(value)` - Validate the estimator representation and domain rules for Statistics. +22. `statisticsConstructEstimator(*args)` - Construct a estimator from explicit inputs for Statistics. +23. `statisticsNormalizeEstimator(value)` - Normalize a estimator into the standard Statistics representation. +24. `statisticsCanonicalizeEstimator(value)` - Canonicalize a estimator so equivalent inputs share one form. +25. `statisticsParseEstimator(text)` - Parse a text or structured value into a estimator. +26. `statisticsFormatEstimator(value)` - Format a estimator for deterministic user-facing output. +27. `statisticsCompareEstimator(left, right)` - Compare two estimator values under the conventions of Statistics. +28. `statisticsCombineEstimator(left, right)` - Combine two estimator values with the natural operation for Statistics. +29. `statisticsDecomposeEstimator(value)` - Decompose a estimator into simpler or canonical components. +30. `statisticsEvaluateEstimator(value, point=None)` - Evaluate a estimator at a point, sample, or finite model. +31. `statisticsComputeEstimator(value)` - Compute the central numerical or symbolic data of a estimator. +32. `statisticsEstimateEstimator(value, samples=None)` - Estimate a estimator property from finite samples or approximations. +33. `statisticsApproximateEstimator(value, tolerance=1e-9)` - Approximate a estimator with explicit tolerance controls. +34. `statisticsTransformEstimator(value, mapping)` - Transform a estimator through a map, operator, or representation change. +35. `statisticsSimplifyEstimator(value)` - Simplify a estimator without changing its mathematical meaning. +36. `statisticsEnumerateEstimator(value, limit=None)` - Enumerate finite members, cases, or derived objects for a estimator. +37. `statisticsClassifyEstimator(value)` - Classify a estimator by its standard Statistics invariants. +38. `statisticsTestEquivalenceEstimator(left, right)` - Test whether two estimator values are equivalent in Statistics. +39. `statisticsGenerateExampleEstimator(size=3)` - Generate a small documented example of a estimator. +40. `statisticsDocumentEstimator(value)` - Return a structured explanation of a estimator and related assumptions. +41. `statisticsValidateSummaryStatistic(value)` - Validate the summary statistic representation and domain rules for Statistics. +42. `statisticsConstructSummaryStatistic(*args)` - Construct a summary statistic from explicit inputs for Statistics. +43. `statisticsNormalizeSummaryStatistic(value)` - Normalize a summary statistic into the standard Statistics representation. +44. `statisticsCanonicalizeSummaryStatistic(value)` - Canonicalize a summary statistic so equivalent inputs share one form. +45. `statisticsParseSummaryStatistic(text)` - Parse a text or structured value into a summary statistic. +46. `statisticsFormatSummaryStatistic(value)` - Format a summary statistic for deterministic user-facing output. +47. `statisticsCompareSummaryStatistic(left, right)` - Compare two summary statistic values under the conventions of Statistics. +48. `statisticsCombineSummaryStatistic(left, right)` - Combine two summary statistic values with the natural operation for Statistics. +49. `statisticsDecomposeSummaryStatistic(value)` - Decompose a summary statistic into simpler or canonical components. +50. `statisticsEvaluateSummaryStatistic(value, point=None)` - Evaluate a summary statistic at a point, sample, or finite model. +51. `statisticsComputeSummaryStatistic(value)` - Compute the central numerical or symbolic data of a summary statistic. +52. `statisticsEstimateSummaryStatistic(value, samples=None)` - Estimate a summary statistic property from finite samples or approximations. +53. `statisticsApproximateSummaryStatistic(value, tolerance=1e-9)` - Approximate a summary statistic with explicit tolerance controls. +54. `statisticsTransformSummaryStatistic(value, mapping)` - Transform a summary statistic through a map, operator, or representation change. +55. `statisticsSimplifySummaryStatistic(value)` - Simplify a summary statistic without changing its mathematical meaning. +56. `statisticsEnumerateSummaryStatistic(value, limit=None)` - Enumerate finite members, cases, or derived objects for a summary statistic. +57. `statisticsClassifySummaryStatistic(value)` - Classify a summary statistic by its standard Statistics invariants. +58. `statisticsTestEquivalenceSummaryStatistic(left, right)` - Test whether two summary statistic values are equivalent in Statistics. +59. `statisticsGenerateExampleSummaryStatistic(size=3)` - Generate a small documented example of a summary statistic. +60. `statisticsDocumentSummaryStatistic(value)` - Return a structured explanation of a summary statistic and related assumptions. +61. `statisticsValidateRegressionModel(value)` - Validate the regression model representation and domain rules for Statistics. +62. `statisticsConstructRegressionModel(*args)` - Construct a regression model from explicit inputs for Statistics. +63. `statisticsNormalizeRegressionModel(value)` - Normalize a regression model into the standard Statistics representation. +64. `statisticsCanonicalizeRegressionModel(value)` - Canonicalize a regression model so equivalent inputs share one form. +65. `statisticsParseRegressionModel(text)` - Parse a text or structured value into a regression model. +66. `statisticsFormatRegressionModel(value)` - Format a regression model for deterministic user-facing output. +67. `statisticsCompareRegressionModel(left, right)` - Compare two regression model values under the conventions of Statistics. +68. `statisticsCombineRegressionModel(left, right)` - Combine two regression model values with the natural operation for Statistics. +69. `statisticsDecomposeRegressionModel(value)` - Decompose a regression model into simpler or canonical components. +70. `statisticsEvaluateRegressionModel(value, point=None)` - Evaluate a regression model at a point, sample, or finite model. +71. `statisticsComputeRegressionModel(value)` - Compute the central numerical or symbolic data of a regression model. +72. `statisticsEstimateRegressionModel(value, samples=None)` - Estimate a regression model property from finite samples or approximations. +73. `statisticsApproximateRegressionModel(value, tolerance=1e-9)` - Approximate a regression model with explicit tolerance controls. +74. `statisticsTransformRegressionModel(value, mapping)` - Transform a regression model through a map, operator, or representation change. +75. `statisticsSimplifyRegressionModel(value)` - Simplify a regression model without changing its mathematical meaning. +76. `statisticsEnumerateRegressionModel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a regression model. +77. `statisticsClassifyRegressionModel(value)` - Classify a regression model by its standard Statistics invariants. +78. `statisticsTestEquivalenceRegressionModel(left, right)` - Test whether two regression model values are equivalent in Statistics. +79. `statisticsGenerateExampleRegressionModel(size=3)` - Generate a small documented example of a regression model. +80. `statisticsDocumentRegressionModel(value)` - Return a structured explanation of a regression model and related assumptions. +81. `statisticsValidateDistributionSummary(value)` - Validate the distribution summary representation and domain rules for Statistics. +82. `statisticsConstructDistributionSummary(*args)` - Construct a distribution summary from explicit inputs for Statistics. +83. `statisticsNormalizeDistributionSummary(value)` - Normalize a distribution summary into the standard Statistics representation. +84. `statisticsCanonicalizeDistributionSummary(value)` - Canonicalize a distribution summary so equivalent inputs share one form. +85. `statisticsParseDistributionSummary(text)` - Parse a text or structured value into a distribution summary. +86. `statisticsFormatDistributionSummary(value)` - Format a distribution summary for deterministic user-facing output. +87. `statisticsCompareDistributionSummary(left, right)` - Compare two distribution summary values under the conventions of Statistics. +88. `statisticsCombineDistributionSummary(left, right)` - Combine two distribution summary values with the natural operation for Statistics. +89. `statisticsDecomposeDistributionSummary(value)` - Decompose a distribution summary into simpler or canonical components. +90. `statisticsEvaluateDistributionSummary(value, point=None)` - Evaluate a distribution summary at a point, sample, or finite model. +91. `statisticsComputeDistributionSummary(value)` - Compute the central numerical or symbolic data of a distribution summary. +92. `statisticsEstimateDistributionSummary(value, samples=None)` - Estimate a distribution summary property from finite samples or approximations. +93. `statisticsApproximateDistributionSummary(value, tolerance=1e-9)` - Approximate a distribution summary with explicit tolerance controls. +94. `statisticsTransformDistributionSummary(value, mapping)` - Transform a distribution summary through a map, operator, or representation change. +95. `statisticsSimplifyDistributionSummary(value)` - Simplify a distribution summary without changing its mathematical meaning. +96. `statisticsEnumerateDistributionSummary(value, limit=None)` - Enumerate finite members, cases, or derived objects for a distribution summary. +97. `statisticsClassifyDistributionSummary(value)` - Classify a distribution summary by its standard Statistics invariants. +98. `statisticsTestEquivalenceDistributionSummary(left, right)` - Test whether two distribution summary values are equivalent in Statistics. +99. `statisticsGenerateExampleDistributionSummary(size=3)` - Generate a small documented example of a distribution summary. +100. `statisticsDocumentDistributionSummary(value)` - Return a structured explanation of a distribution summary and related assumptions. + +### Naive Set Theory + +Core object families: + +- finite set +- relation +- mapping +- partition +- set operation + +Candidate functions: + +1. `naiveSetTheoryValidateFiniteSet(value)` - Validate the finite set representation and domain rules for Naive Set Theory. +2. `naiveSetTheoryConstructFiniteSet(*args)` - Construct a finite set from explicit inputs for Naive Set Theory. +3. `naiveSetTheoryNormalizeFiniteSet(value)` - Normalize a finite set into the standard Naive Set Theory representation. +4. `naiveSetTheoryCanonicalizeFiniteSet(value)` - Canonicalize a finite set so equivalent inputs share one form. +5. `naiveSetTheoryParseFiniteSet(text)` - Parse a text or structured value into a finite set. +6. `naiveSetTheoryFormatFiniteSet(value)` - Format a finite set for deterministic user-facing output. +7. `naiveSetTheoryCompareFiniteSet(left, right)` - Compare two finite set values under the conventions of Naive Set Theory. +8. `naiveSetTheoryCombineFiniteSet(left, right)` - Combine two finite set values with the natural operation for Naive Set Theory. +9. `naiveSetTheoryDecomposeFiniteSet(value)` - Decompose a finite set into simpler or canonical components. +10. `naiveSetTheoryEvaluateFiniteSet(value, point=None)` - Evaluate a finite set at a point, sample, or finite model. +11. `naiveSetTheoryComputeFiniteSet(value)` - Compute the central numerical or symbolic data of a finite set. +12. `naiveSetTheoryEstimateFiniteSet(value, samples=None)` - Estimate a finite set property from finite samples or approximations. +13. `naiveSetTheoryApproximateFiniteSet(value, tolerance=1e-9)` - Approximate a finite set with explicit tolerance controls. +14. `naiveSetTheoryTransformFiniteSet(value, mapping)` - Transform a finite set through a map, operator, or representation change. +15. `naiveSetTheorySimplifyFiniteSet(value)` - Simplify a finite set without changing its mathematical meaning. +16. `naiveSetTheoryEnumerateFiniteSet(value, limit=None)` - Enumerate finite members, cases, or derived objects for a finite set. +17. `naiveSetTheoryClassifyFiniteSet(value)` - Classify a finite set by its standard Naive Set Theory invariants. +18. `naiveSetTheoryTestEquivalenceFiniteSet(left, right)` - Test whether two finite set values are equivalent in Naive Set Theory. +19. `naiveSetTheoryGenerateExampleFiniteSet(size=3)` - Generate a small documented example of a finite set. +20. `naiveSetTheoryDocumentFiniteSet(value)` - Return a structured explanation of a finite set and related assumptions. +21. `naiveSetTheoryValidateRelation(value)` - Validate the relation representation and domain rules for Naive Set Theory. +22. `naiveSetTheoryConstructRelation(*args)` - Construct a relation from explicit inputs for Naive Set Theory. +23. `naiveSetTheoryNormalizeRelation(value)` - Normalize a relation into the standard Naive Set Theory representation. +24. `naiveSetTheoryCanonicalizeRelation(value)` - Canonicalize a relation so equivalent inputs share one form. +25. `naiveSetTheoryParseRelation(text)` - Parse a text or structured value into a relation. +26. `naiveSetTheoryFormatRelation(value)` - Format a relation for deterministic user-facing output. +27. `naiveSetTheoryCompareRelation(left, right)` - Compare two relation values under the conventions of Naive Set Theory. +28. `naiveSetTheoryCombineRelation(left, right)` - Combine two relation values with the natural operation for Naive Set Theory. +29. `naiveSetTheoryDecomposeRelation(value)` - Decompose a relation into simpler or canonical components. +30. `naiveSetTheoryEvaluateRelation(value, point=None)` - Evaluate a relation at a point, sample, or finite model. +31. `naiveSetTheoryComputeRelation(value)` - Compute the central numerical or symbolic data of a relation. +32. `naiveSetTheoryEstimateRelation(value, samples=None)` - Estimate a relation property from finite samples or approximations. +33. `naiveSetTheoryApproximateRelation(value, tolerance=1e-9)` - Approximate a relation with explicit tolerance controls. +34. `naiveSetTheoryTransformRelation(value, mapping)` - Transform a relation through a map, operator, or representation change. +35. `naiveSetTheorySimplifyRelation(value)` - Simplify a relation without changing its mathematical meaning. +36. `naiveSetTheoryEnumerateRelation(value, limit=None)` - Enumerate finite members, cases, or derived objects for a relation. +37. `naiveSetTheoryClassifyRelation(value)` - Classify a relation by its standard Naive Set Theory invariants. +38. `naiveSetTheoryTestEquivalenceRelation(left, right)` - Test whether two relation values are equivalent in Naive Set Theory. +39. `naiveSetTheoryGenerateExampleRelation(size=3)` - Generate a small documented example of a relation. +40. `naiveSetTheoryDocumentRelation(value)` - Return a structured explanation of a relation and related assumptions. +41. `naiveSetTheoryValidateMapping(value)` - Validate the mapping representation and domain rules for Naive Set Theory. +42. `naiveSetTheoryConstructMapping(*args)` - Construct a mapping from explicit inputs for Naive Set Theory. +43. `naiveSetTheoryNormalizeMapping(value)` - Normalize a mapping into the standard Naive Set Theory representation. +44. `naiveSetTheoryCanonicalizeMapping(value)` - Canonicalize a mapping so equivalent inputs share one form. +45. `naiveSetTheoryParseMapping(text)` - Parse a text or structured value into a mapping. +46. `naiveSetTheoryFormatMapping(value)` - Format a mapping for deterministic user-facing output. +47. `naiveSetTheoryCompareMapping(left, right)` - Compare two mapping values under the conventions of Naive Set Theory. +48. `naiveSetTheoryCombineMapping(left, right)` - Combine two mapping values with the natural operation for Naive Set Theory. +49. `naiveSetTheoryDecomposeMapping(value)` - Decompose a mapping into simpler or canonical components. +50. `naiveSetTheoryEvaluateMapping(value, point=None)` - Evaluate a mapping at a point, sample, or finite model. +51. `naiveSetTheoryComputeMapping(value)` - Compute the central numerical or symbolic data of a mapping. +52. `naiveSetTheoryEstimateMapping(value, samples=None)` - Estimate a mapping property from finite samples or approximations. +53. `naiveSetTheoryApproximateMapping(value, tolerance=1e-9)` - Approximate a mapping with explicit tolerance controls. +54. `naiveSetTheoryTransformMapping(value, mapping)` - Transform a mapping through a map, operator, or representation change. +55. `naiveSetTheorySimplifyMapping(value)` - Simplify a mapping without changing its mathematical meaning. +56. `naiveSetTheoryEnumerateMapping(value, limit=None)` - Enumerate finite members, cases, or derived objects for a mapping. +57. `naiveSetTheoryClassifyMapping(value)` - Classify a mapping by its standard Naive Set Theory invariants. +58. `naiveSetTheoryTestEquivalenceMapping(left, right)` - Test whether two mapping values are equivalent in Naive Set Theory. +59. `naiveSetTheoryGenerateExampleMapping(size=3)` - Generate a small documented example of a mapping. +60. `naiveSetTheoryDocumentMapping(value)` - Return a structured explanation of a mapping and related assumptions. +61. `naiveSetTheoryValidatePartition(value)` - Validate the partition representation and domain rules for Naive Set Theory. +62. `naiveSetTheoryConstructPartition(*args)` - Construct a partition from explicit inputs for Naive Set Theory. +63. `naiveSetTheoryNormalizePartition(value)` - Normalize a partition into the standard Naive Set Theory representation. +64. `naiveSetTheoryCanonicalizePartition(value)` - Canonicalize a partition so equivalent inputs share one form. +65. `naiveSetTheoryParsePartition(text)` - Parse a text or structured value into a partition. +66. `naiveSetTheoryFormatPartition(value)` - Format a partition for deterministic user-facing output. +67. `naiveSetTheoryComparePartition(left, right)` - Compare two partition values under the conventions of Naive Set Theory. +68. `naiveSetTheoryCombinePartition(left, right)` - Combine two partition values with the natural operation for Naive Set Theory. +69. `naiveSetTheoryDecomposePartition(value)` - Decompose a partition into simpler or canonical components. +70. `naiveSetTheoryEvaluatePartition(value, point=None)` - Evaluate a partition at a point, sample, or finite model. +71. `naiveSetTheoryComputePartition(value)` - Compute the central numerical or symbolic data of a partition. +72. `naiveSetTheoryEstimatePartition(value, samples=None)` - Estimate a partition property from finite samples or approximations. +73. `naiveSetTheoryApproximatePartition(value, tolerance=1e-9)` - Approximate a partition with explicit tolerance controls. +74. `naiveSetTheoryTransformPartition(value, mapping)` - Transform a partition through a map, operator, or representation change. +75. `naiveSetTheorySimplifyPartition(value)` - Simplify a partition without changing its mathematical meaning. +76. `naiveSetTheoryEnumeratePartition(value, limit=None)` - Enumerate finite members, cases, or derived objects for a partition. +77. `naiveSetTheoryClassifyPartition(value)` - Classify a partition by its standard Naive Set Theory invariants. +78. `naiveSetTheoryTestEquivalencePartition(left, right)` - Test whether two partition values are equivalent in Naive Set Theory. +79. `naiveSetTheoryGenerateExamplePartition(size=3)` - Generate a small documented example of a partition. +80. `naiveSetTheoryDocumentPartition(value)` - Return a structured explanation of a partition and related assumptions. +81. `naiveSetTheoryValidateSetOperation(value)` - Validate the set operation representation and domain rules for Naive Set Theory. +82. `naiveSetTheoryConstructSetOperation(*args)` - Construct a set operation from explicit inputs for Naive Set Theory. +83. `naiveSetTheoryNormalizeSetOperation(value)` - Normalize a set operation into the standard Naive Set Theory representation. +84. `naiveSetTheoryCanonicalizeSetOperation(value)` - Canonicalize a set operation so equivalent inputs share one form. +85. `naiveSetTheoryParseSetOperation(text)` - Parse a text or structured value into a set operation. +86. `naiveSetTheoryFormatSetOperation(value)` - Format a set operation for deterministic user-facing output. +87. `naiveSetTheoryCompareSetOperation(left, right)` - Compare two set operation values under the conventions of Naive Set Theory. +88. `naiveSetTheoryCombineSetOperation(left, right)` - Combine two set operation values with the natural operation for Naive Set Theory. +89. `naiveSetTheoryDecomposeSetOperation(value)` - Decompose a set operation into simpler or canonical components. +90. `naiveSetTheoryEvaluateSetOperation(value, point=None)` - Evaluate a set operation at a point, sample, or finite model. +91. `naiveSetTheoryComputeSetOperation(value)` - Compute the central numerical or symbolic data of a set operation. +92. `naiveSetTheoryEstimateSetOperation(value, samples=None)` - Estimate a set operation property from finite samples or approximations. +93. `naiveSetTheoryApproximateSetOperation(value, tolerance=1e-9)` - Approximate a set operation with explicit tolerance controls. +94. `naiveSetTheoryTransformSetOperation(value, mapping)` - Transform a set operation through a map, operator, or representation change. +95. `naiveSetTheorySimplifySetOperation(value)` - Simplify a set operation without changing its mathematical meaning. +96. `naiveSetTheoryEnumerateSetOperation(value, limit=None)` - Enumerate finite members, cases, or derived objects for a set operation. +97. `naiveSetTheoryClassifySetOperation(value)` - Classify a set operation by its standard Naive Set Theory invariants. +98. `naiveSetTheoryTestEquivalenceSetOperation(left, right)` - Test whether two set operation values are equivalent in Naive Set Theory. +99. `naiveSetTheoryGenerateExampleSetOperation(size=3)` - Generate a small documented example of a set operation. +100. `naiveSetTheoryDocumentSetOperation(value)` - Return a structured explanation of a set operation and related assumptions. + +### ZFC Axiomatic Set Theory + +Core object families: + +- axiom model +- ordinal +- cardinal +- set construction +- membership structure + +Candidate functions: + +1. `zfcAxiomaticSetTheoryValidateAxiomModel(value)` - Validate the axiom model representation and domain rules for ZFC Axiomatic Set Theory. +2. `zfcAxiomaticSetTheoryConstructAxiomModel(*args)` - Construct a axiom model from explicit inputs for ZFC Axiomatic Set Theory. +3. `zfcAxiomaticSetTheoryNormalizeAxiomModel(value)` - Normalize a axiom model into the standard ZFC Axiomatic Set Theory representation. +4. `zfcAxiomaticSetTheoryCanonicalizeAxiomModel(value)` - Canonicalize a axiom model so equivalent inputs share one form. +5. `zfcAxiomaticSetTheoryParseAxiomModel(text)` - Parse a text or structured value into a axiom model. +6. `zfcAxiomaticSetTheoryFormatAxiomModel(value)` - Format a axiom model for deterministic user-facing output. +7. `zfcAxiomaticSetTheoryCompareAxiomModel(left, right)` - Compare two axiom model values under the conventions of ZFC Axiomatic Set Theory. +8. `zfcAxiomaticSetTheoryCombineAxiomModel(left, right)` - Combine two axiom model values with the natural operation for ZFC Axiomatic Set Theory. +9. `zfcAxiomaticSetTheoryDecomposeAxiomModel(value)` - Decompose a axiom model into simpler or canonical components. +10. `zfcAxiomaticSetTheoryEvaluateAxiomModel(value, point=None)` - Evaluate a axiom model at a point, sample, or finite model. +11. `zfcAxiomaticSetTheoryComputeAxiomModel(value)` - Compute the central numerical or symbolic data of a axiom model. +12. `zfcAxiomaticSetTheoryEstimateAxiomModel(value, samples=None)` - Estimate a axiom model property from finite samples or approximations. +13. `zfcAxiomaticSetTheoryApproximateAxiomModel(value, tolerance=1e-9)` - Approximate a axiom model with explicit tolerance controls. +14. `zfcAxiomaticSetTheoryTransformAxiomModel(value, mapping)` - Transform a axiom model through a map, operator, or representation change. +15. `zfcAxiomaticSetTheorySimplifyAxiomModel(value)` - Simplify a axiom model without changing its mathematical meaning. +16. `zfcAxiomaticSetTheoryEnumerateAxiomModel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a axiom model. +17. `zfcAxiomaticSetTheoryClassifyAxiomModel(value)` - Classify a axiom model by its standard ZFC Axiomatic Set Theory invariants. +18. `zfcAxiomaticSetTheoryTestEquivalenceAxiomModel(left, right)` - Test whether two axiom model values are equivalent in ZFC Axiomatic Set Theory. +19. `zfcAxiomaticSetTheoryGenerateExampleAxiomModel(size=3)` - Generate a small documented example of a axiom model. +20. `zfcAxiomaticSetTheoryDocumentAxiomModel(value)` - Return a structured explanation of a axiom model and related assumptions. +21. `zfcAxiomaticSetTheoryValidateOrdinal(value)` - Validate the ordinal representation and domain rules for ZFC Axiomatic Set Theory. +22. `zfcAxiomaticSetTheoryConstructOrdinal(*args)` - Construct a ordinal from explicit inputs for ZFC Axiomatic Set Theory. +23. `zfcAxiomaticSetTheoryNormalizeOrdinal(value)` - Normalize a ordinal into the standard ZFC Axiomatic Set Theory representation. +24. `zfcAxiomaticSetTheoryCanonicalizeOrdinal(value)` - Canonicalize a ordinal so equivalent inputs share one form. +25. `zfcAxiomaticSetTheoryParseOrdinal(text)` - Parse a text or structured value into a ordinal. +26. `zfcAxiomaticSetTheoryFormatOrdinal(value)` - Format a ordinal for deterministic user-facing output. +27. `zfcAxiomaticSetTheoryCompareOrdinal(left, right)` - Compare two ordinal values under the conventions of ZFC Axiomatic Set Theory. +28. `zfcAxiomaticSetTheoryCombineOrdinal(left, right)` - Combine two ordinal values with the natural operation for ZFC Axiomatic Set Theory. +29. `zfcAxiomaticSetTheoryDecomposeOrdinal(value)` - Decompose a ordinal into simpler or canonical components. +30. `zfcAxiomaticSetTheoryEvaluateOrdinal(value, point=None)` - Evaluate a ordinal at a point, sample, or finite model. +31. `zfcAxiomaticSetTheoryComputeOrdinal(value)` - Compute the central numerical or symbolic data of a ordinal. +32. `zfcAxiomaticSetTheoryEstimateOrdinal(value, samples=None)` - Estimate a ordinal property from finite samples or approximations. +33. `zfcAxiomaticSetTheoryApproximateOrdinal(value, tolerance=1e-9)` - Approximate a ordinal with explicit tolerance controls. +34. `zfcAxiomaticSetTheoryTransformOrdinal(value, mapping)` - Transform a ordinal through a map, operator, or representation change. +35. `zfcAxiomaticSetTheorySimplifyOrdinal(value)` - Simplify a ordinal without changing its mathematical meaning. +36. `zfcAxiomaticSetTheoryEnumerateOrdinal(value, limit=None)` - Enumerate finite members, cases, or derived objects for a ordinal. +37. `zfcAxiomaticSetTheoryClassifyOrdinal(value)` - Classify a ordinal by its standard ZFC Axiomatic Set Theory invariants. +38. `zfcAxiomaticSetTheoryTestEquivalenceOrdinal(left, right)` - Test whether two ordinal values are equivalent in ZFC Axiomatic Set Theory. +39. `zfcAxiomaticSetTheoryGenerateExampleOrdinal(size=3)` - Generate a small documented example of a ordinal. +40. `zfcAxiomaticSetTheoryDocumentOrdinal(value)` - Return a structured explanation of a ordinal and related assumptions. +41. `zfcAxiomaticSetTheoryValidateCardinal(value)` - Validate the cardinal representation and domain rules for ZFC Axiomatic Set Theory. +42. `zfcAxiomaticSetTheoryConstructCardinal(*args)` - Construct a cardinal from explicit inputs for ZFC Axiomatic Set Theory. +43. `zfcAxiomaticSetTheoryNormalizeCardinal(value)` - Normalize a cardinal into the standard ZFC Axiomatic Set Theory representation. +44. `zfcAxiomaticSetTheoryCanonicalizeCardinal(value)` - Canonicalize a cardinal so equivalent inputs share one form. +45. `zfcAxiomaticSetTheoryParseCardinal(text)` - Parse a text or structured value into a cardinal. +46. `zfcAxiomaticSetTheoryFormatCardinal(value)` - Format a cardinal for deterministic user-facing output. +47. `zfcAxiomaticSetTheoryCompareCardinal(left, right)` - Compare two cardinal values under the conventions of ZFC Axiomatic Set Theory. +48. `zfcAxiomaticSetTheoryCombineCardinal(left, right)` - Combine two cardinal values with the natural operation for ZFC Axiomatic Set Theory. +49. `zfcAxiomaticSetTheoryDecomposeCardinal(value)` - Decompose a cardinal into simpler or canonical components. +50. `zfcAxiomaticSetTheoryEvaluateCardinal(value, point=None)` - Evaluate a cardinal at a point, sample, or finite model. +51. `zfcAxiomaticSetTheoryComputeCardinal(value)` - Compute the central numerical or symbolic data of a cardinal. +52. `zfcAxiomaticSetTheoryEstimateCardinal(value, samples=None)` - Estimate a cardinal property from finite samples or approximations. +53. `zfcAxiomaticSetTheoryApproximateCardinal(value, tolerance=1e-9)` - Approximate a cardinal with explicit tolerance controls. +54. `zfcAxiomaticSetTheoryTransformCardinal(value, mapping)` - Transform a cardinal through a map, operator, or representation change. +55. `zfcAxiomaticSetTheorySimplifyCardinal(value)` - Simplify a cardinal without changing its mathematical meaning. +56. `zfcAxiomaticSetTheoryEnumerateCardinal(value, limit=None)` - Enumerate finite members, cases, or derived objects for a cardinal. +57. `zfcAxiomaticSetTheoryClassifyCardinal(value)` - Classify a cardinal by its standard ZFC Axiomatic Set Theory invariants. +58. `zfcAxiomaticSetTheoryTestEquivalenceCardinal(left, right)` - Test whether two cardinal values are equivalent in ZFC Axiomatic Set Theory. +59. `zfcAxiomaticSetTheoryGenerateExampleCardinal(size=3)` - Generate a small documented example of a cardinal. +60. `zfcAxiomaticSetTheoryDocumentCardinal(value)` - Return a structured explanation of a cardinal and related assumptions. +61. `zfcAxiomaticSetTheoryValidateSetConstruction(value)` - Validate the set construction representation and domain rules for ZFC Axiomatic Set Theory. +62. `zfcAxiomaticSetTheoryConstructSetConstruction(*args)` - Construct a set construction from explicit inputs for ZFC Axiomatic Set Theory. +63. `zfcAxiomaticSetTheoryNormalizeSetConstruction(value)` - Normalize a set construction into the standard ZFC Axiomatic Set Theory representation. +64. `zfcAxiomaticSetTheoryCanonicalizeSetConstruction(value)` - Canonicalize a set construction so equivalent inputs share one form. +65. `zfcAxiomaticSetTheoryParseSetConstruction(text)` - Parse a text or structured value into a set construction. +66. `zfcAxiomaticSetTheoryFormatSetConstruction(value)` - Format a set construction for deterministic user-facing output. +67. `zfcAxiomaticSetTheoryCompareSetConstruction(left, right)` - Compare two set construction values under the conventions of ZFC Axiomatic Set Theory. +68. `zfcAxiomaticSetTheoryCombineSetConstruction(left, right)` - Combine two set construction values with the natural operation for ZFC Axiomatic Set Theory. +69. `zfcAxiomaticSetTheoryDecomposeSetConstruction(value)` - Decompose a set construction into simpler or canonical components. +70. `zfcAxiomaticSetTheoryEvaluateSetConstruction(value, point=None)` - Evaluate a set construction at a point, sample, or finite model. +71. `zfcAxiomaticSetTheoryComputeSetConstruction(value)` - Compute the central numerical or symbolic data of a set construction. +72. `zfcAxiomaticSetTheoryEstimateSetConstruction(value, samples=None)` - Estimate a set construction property from finite samples or approximations. +73. `zfcAxiomaticSetTheoryApproximateSetConstruction(value, tolerance=1e-9)` - Approximate a set construction with explicit tolerance controls. +74. `zfcAxiomaticSetTheoryTransformSetConstruction(value, mapping)` - Transform a set construction through a map, operator, or representation change. +75. `zfcAxiomaticSetTheorySimplifySetConstruction(value)` - Simplify a set construction without changing its mathematical meaning. +76. `zfcAxiomaticSetTheoryEnumerateSetConstruction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a set construction. +77. `zfcAxiomaticSetTheoryClassifySetConstruction(value)` - Classify a set construction by its standard ZFC Axiomatic Set Theory invariants. +78. `zfcAxiomaticSetTheoryTestEquivalenceSetConstruction(left, right)` - Test whether two set construction values are equivalent in ZFC Axiomatic Set Theory. +79. `zfcAxiomaticSetTheoryGenerateExampleSetConstruction(size=3)` - Generate a small documented example of a set construction. +80. `zfcAxiomaticSetTheoryDocumentSetConstruction(value)` - Return a structured explanation of a set construction and related assumptions. +81. `zfcAxiomaticSetTheoryValidateMembershipStructure(value)` - Validate the membership structure representation and domain rules for ZFC Axiomatic Set Theory. +82. `zfcAxiomaticSetTheoryConstructMembershipStructure(*args)` - Construct a membership structure from explicit inputs for ZFC Axiomatic Set Theory. +83. `zfcAxiomaticSetTheoryNormalizeMembershipStructure(value)` - Normalize a membership structure into the standard ZFC Axiomatic Set Theory representation. +84. `zfcAxiomaticSetTheoryCanonicalizeMembershipStructure(value)` - Canonicalize a membership structure so equivalent inputs share one form. +85. `zfcAxiomaticSetTheoryParseMembershipStructure(text)` - Parse a text or structured value into a membership structure. +86. `zfcAxiomaticSetTheoryFormatMembershipStructure(value)` - Format a membership structure for deterministic user-facing output. +87. `zfcAxiomaticSetTheoryCompareMembershipStructure(left, right)` - Compare two membership structure values under the conventions of ZFC Axiomatic Set Theory. +88. `zfcAxiomaticSetTheoryCombineMembershipStructure(left, right)` - Combine two membership structure values with the natural operation for ZFC Axiomatic Set Theory. +89. `zfcAxiomaticSetTheoryDecomposeMembershipStructure(value)` - Decompose a membership structure into simpler or canonical components. +90. `zfcAxiomaticSetTheoryEvaluateMembershipStructure(value, point=None)` - Evaluate a membership structure at a point, sample, or finite model. +91. `zfcAxiomaticSetTheoryComputeMembershipStructure(value)` - Compute the central numerical or symbolic data of a membership structure. +92. `zfcAxiomaticSetTheoryEstimateMembershipStructure(value, samples=None)` - Estimate a membership structure property from finite samples or approximations. +93. `zfcAxiomaticSetTheoryApproximateMembershipStructure(value, tolerance=1e-9)` - Approximate a membership structure with explicit tolerance controls. +94. `zfcAxiomaticSetTheoryTransformMembershipStructure(value, mapping)` - Transform a membership structure through a map, operator, or representation change. +95. `zfcAxiomaticSetTheorySimplifyMembershipStructure(value)` - Simplify a membership structure without changing its mathematical meaning. +96. `zfcAxiomaticSetTheoryEnumerateMembershipStructure(value, limit=None)` - Enumerate finite members, cases, or derived objects for a membership structure. +97. `zfcAxiomaticSetTheoryClassifyMembershipStructure(value)` - Classify a membership structure by its standard ZFC Axiomatic Set Theory invariants. +98. `zfcAxiomaticSetTheoryTestEquivalenceMembershipStructure(left, right)` - Test whether two membership structure values are equivalent in ZFC Axiomatic Set Theory. +99. `zfcAxiomaticSetTheoryGenerateExampleMembershipStructure(size=3)` - Generate a small documented example of a membership structure. +100. `zfcAxiomaticSetTheoryDocumentMembershipStructure(value)` - Return a structured explanation of a membership structure and related assumptions. + +### Linear Algebra + +Core object families: + +- matrix +- vector +- linear map +- subspace +- decomposition + +Candidate functions: + +1. `linearAlgebraValidateMatrix(value)` - Validate the matrix representation and domain rules for Linear Algebra. +2. `linearAlgebraConstructMatrix(*args)` - Construct a matrix from explicit inputs for Linear Algebra. +3. `linearAlgebraNormalizeMatrix(value)` - Normalize a matrix into the standard Linear Algebra representation. +4. `linearAlgebraCanonicalizeMatrix(value)` - Canonicalize a matrix so equivalent inputs share one form. +5. `linearAlgebraParseMatrix(text)` - Parse a text or structured value into a matrix. +6. `linearAlgebraFormatMatrix(value)` - Format a matrix for deterministic user-facing output. +7. `linearAlgebraCompareMatrix(left, right)` - Compare two matrix values under the conventions of Linear Algebra. +8. `linearAlgebraCombineMatrix(left, right)` - Combine two matrix values with the natural operation for Linear Algebra. +9. `linearAlgebraDecomposeMatrix(value)` - Decompose a matrix into simpler or canonical components. +10. `linearAlgebraEvaluateMatrix(value, point=None)` - Evaluate a matrix at a point, sample, or finite model. +11. `linearAlgebraComputeMatrix(value)` - Compute the central numerical or symbolic data of a matrix. +12. `linearAlgebraEstimateMatrix(value, samples=None)` - Estimate a matrix property from finite samples or approximations. +13. `linearAlgebraApproximateMatrix(value, tolerance=1e-9)` - Approximate a matrix with explicit tolerance controls. +14. `linearAlgebraTransformMatrix(value, mapping)` - Transform a matrix through a map, operator, or representation change. +15. `linearAlgebraSimplifyMatrix(value)` - Simplify a matrix without changing its mathematical meaning. +16. `linearAlgebraEnumerateMatrix(value, limit=None)` - Enumerate finite members, cases, or derived objects for a matrix. +17. `linearAlgebraClassifyMatrix(value)` - Classify a matrix by its standard Linear Algebra invariants. +18. `linearAlgebraTestEquivalenceMatrix(left, right)` - Test whether two matrix values are equivalent in Linear Algebra. +19. `linearAlgebraGenerateExampleMatrix(size=3)` - Generate a small documented example of a matrix. +20. `linearAlgebraDocumentMatrix(value)` - Return a structured explanation of a matrix and related assumptions. +21. `linearAlgebraValidateVector(value)` - Validate the vector representation and domain rules for Linear Algebra. +22. `linearAlgebraConstructVector(*args)` - Construct a vector from explicit inputs for Linear Algebra. +23. `linearAlgebraNormalizeVector(value)` - Normalize a vector into the standard Linear Algebra representation. +24. `linearAlgebraCanonicalizeVector(value)` - Canonicalize a vector so equivalent inputs share one form. +25. `linearAlgebraParseVector(text)` - Parse a text or structured value into a vector. +26. `linearAlgebraFormatVector(value)` - Format a vector for deterministic user-facing output. +27. `linearAlgebraCompareVector(left, right)` - Compare two vector values under the conventions of Linear Algebra. +28. `linearAlgebraCombineVector(left, right)` - Combine two vector values with the natural operation for Linear Algebra. +29. `linearAlgebraDecomposeVector(value)` - Decompose a vector into simpler or canonical components. +30. `linearAlgebraEvaluateVector(value, point=None)` - Evaluate a vector at a point, sample, or finite model. +31. `linearAlgebraComputeVector(value)` - Compute the central numerical or symbolic data of a vector. +32. `linearAlgebraEstimateVector(value, samples=None)` - Estimate a vector property from finite samples or approximations. +33. `linearAlgebraApproximateVector(value, tolerance=1e-9)` - Approximate a vector with explicit tolerance controls. +34. `linearAlgebraTransformVector(value, mapping)` - Transform a vector through a map, operator, or representation change. +35. `linearAlgebraSimplifyVector(value)` - Simplify a vector without changing its mathematical meaning. +36. `linearAlgebraEnumerateVector(value, limit=None)` - Enumerate finite members, cases, or derived objects for a vector. +37. `linearAlgebraClassifyVector(value)` - Classify a vector by its standard Linear Algebra invariants. +38. `linearAlgebraTestEquivalenceVector(left, right)` - Test whether two vector values are equivalent in Linear Algebra. +39. `linearAlgebraGenerateExampleVector(size=3)` - Generate a small documented example of a vector. +40. `linearAlgebraDocumentVector(value)` - Return a structured explanation of a vector and related assumptions. +41. `linearAlgebraValidateLinearMap(value)` - Validate the linear map representation and domain rules for Linear Algebra. +42. `linearAlgebraConstructLinearMap(*args)` - Construct a linear map from explicit inputs for Linear Algebra. +43. `linearAlgebraNormalizeLinearMap(value)` - Normalize a linear map into the standard Linear Algebra representation. +44. `linearAlgebraCanonicalizeLinearMap(value)` - Canonicalize a linear map so equivalent inputs share one form. +45. `linearAlgebraParseLinearMap(text)` - Parse a text or structured value into a linear map. +46. `linearAlgebraFormatLinearMap(value)` - Format a linear map for deterministic user-facing output. +47. `linearAlgebraCompareLinearMap(left, right)` - Compare two linear map values under the conventions of Linear Algebra. +48. `linearAlgebraCombineLinearMap(left, right)` - Combine two linear map values with the natural operation for Linear Algebra. +49. `linearAlgebraDecomposeLinearMap(value)` - Decompose a linear map into simpler or canonical components. +50. `linearAlgebraEvaluateLinearMap(value, point=None)` - Evaluate a linear map at a point, sample, or finite model. +51. `linearAlgebraComputeLinearMap(value)` - Compute the central numerical or symbolic data of a linear map. +52. `linearAlgebraEstimateLinearMap(value, samples=None)` - Estimate a linear map property from finite samples or approximations. +53. `linearAlgebraApproximateLinearMap(value, tolerance=1e-9)` - Approximate a linear map with explicit tolerance controls. +54. `linearAlgebraTransformLinearMap(value, mapping)` - Transform a linear map through a map, operator, or representation change. +55. `linearAlgebraSimplifyLinearMap(value)` - Simplify a linear map without changing its mathematical meaning. +56. `linearAlgebraEnumerateLinearMap(value, limit=None)` - Enumerate finite members, cases, or derived objects for a linear map. +57. `linearAlgebraClassifyLinearMap(value)` - Classify a linear map by its standard Linear Algebra invariants. +58. `linearAlgebraTestEquivalenceLinearMap(left, right)` - Test whether two linear map values are equivalent in Linear Algebra. +59. `linearAlgebraGenerateExampleLinearMap(size=3)` - Generate a small documented example of a linear map. +60. `linearAlgebraDocumentLinearMap(value)` - Return a structured explanation of a linear map and related assumptions. +61. `linearAlgebraValidateSubspace(value)` - Validate the subspace representation and domain rules for Linear Algebra. +62. `linearAlgebraConstructSubspace(*args)` - Construct a subspace from explicit inputs for Linear Algebra. +63. `linearAlgebraNormalizeSubspace(value)` - Normalize a subspace into the standard Linear Algebra representation. +64. `linearAlgebraCanonicalizeSubspace(value)` - Canonicalize a subspace so equivalent inputs share one form. +65. `linearAlgebraParseSubspace(text)` - Parse a text or structured value into a subspace. +66. `linearAlgebraFormatSubspace(value)` - Format a subspace for deterministic user-facing output. +67. `linearAlgebraCompareSubspace(left, right)` - Compare two subspace values under the conventions of Linear Algebra. +68. `linearAlgebraCombineSubspace(left, right)` - Combine two subspace values with the natural operation for Linear Algebra. +69. `linearAlgebraDecomposeSubspace(value)` - Decompose a subspace into simpler or canonical components. +70. `linearAlgebraEvaluateSubspace(value, point=None)` - Evaluate a subspace at a point, sample, or finite model. +71. `linearAlgebraComputeSubspace(value)` - Compute the central numerical or symbolic data of a subspace. +72. `linearAlgebraEstimateSubspace(value, samples=None)` - Estimate a subspace property from finite samples or approximations. +73. `linearAlgebraApproximateSubspace(value, tolerance=1e-9)` - Approximate a subspace with explicit tolerance controls. +74. `linearAlgebraTransformSubspace(value, mapping)` - Transform a subspace through a map, operator, or representation change. +75. `linearAlgebraSimplifySubspace(value)` - Simplify a subspace without changing its mathematical meaning. +76. `linearAlgebraEnumerateSubspace(value, limit=None)` - Enumerate finite members, cases, or derived objects for a subspace. +77. `linearAlgebraClassifySubspace(value)` - Classify a subspace by its standard Linear Algebra invariants. +78. `linearAlgebraTestEquivalenceSubspace(left, right)` - Test whether two subspace values are equivalent in Linear Algebra. +79. `linearAlgebraGenerateExampleSubspace(size=3)` - Generate a small documented example of a subspace. +80. `linearAlgebraDocumentSubspace(value)` - Return a structured explanation of a subspace and related assumptions. +81. `linearAlgebraValidateDecomposition(value)` - Validate the decomposition representation and domain rules for Linear Algebra. +82. `linearAlgebraConstructDecomposition(*args)` - Construct a decomposition from explicit inputs for Linear Algebra. +83. `linearAlgebraNormalizeDecomposition(value)` - Normalize a decomposition into the standard Linear Algebra representation. +84. `linearAlgebraCanonicalizeDecomposition(value)` - Canonicalize a decomposition so equivalent inputs share one form. +85. `linearAlgebraParseDecomposition(text)` - Parse a text or structured value into a decomposition. +86. `linearAlgebraFormatDecomposition(value)` - Format a decomposition for deterministic user-facing output. +87. `linearAlgebraCompareDecomposition(left, right)` - Compare two decomposition values under the conventions of Linear Algebra. +88. `linearAlgebraCombineDecomposition(left, right)` - Combine two decomposition values with the natural operation for Linear Algebra. +89. `linearAlgebraDecomposeDecomposition(value)` - Decompose a decomposition into simpler or canonical components. +90. `linearAlgebraEvaluateDecomposition(value, point=None)` - Evaluate a decomposition at a point, sample, or finite model. +91. `linearAlgebraComputeDecomposition(value)` - Compute the central numerical or symbolic data of a decomposition. +92. `linearAlgebraEstimateDecomposition(value, samples=None)` - Estimate a decomposition property from finite samples or approximations. +93. `linearAlgebraApproximateDecomposition(value, tolerance=1e-9)` - Approximate a decomposition with explicit tolerance controls. +94. `linearAlgebraTransformDecomposition(value, mapping)` - Transform a decomposition through a map, operator, or representation change. +95. `linearAlgebraSimplifyDecomposition(value)` - Simplify a decomposition without changing its mathematical meaning. +96. `linearAlgebraEnumerateDecomposition(value, limit=None)` - Enumerate finite members, cases, or derived objects for a decomposition. +97. `linearAlgebraClassifyDecomposition(value)` - Classify a decomposition by its standard Linear Algebra invariants. +98. `linearAlgebraTestEquivalenceDecomposition(left, right)` - Test whether two decomposition values are equivalent in Linear Algebra. +99. `linearAlgebraGenerateExampleDecomposition(size=3)` - Generate a small documented example of a decomposition. +100. `linearAlgebraDocumentDecomposition(value)` - Return a structured explanation of a decomposition and related assumptions. + +### Metric Spaces + +Core object families: + +- metric +- point cloud +- open ball +- sequence +- bounded set + +Candidate functions: + +1. `metricSpacesValidateMetric(value)` - Validate the metric representation and domain rules for Metric Spaces. +2. `metricSpacesConstructMetric(*args)` - Construct a metric from explicit inputs for Metric Spaces. +3. `metricSpacesNormalizeMetric(value)` - Normalize a metric into the standard Metric Spaces representation. +4. `metricSpacesCanonicalizeMetric(value)` - Canonicalize a metric so equivalent inputs share one form. +5. `metricSpacesParseMetric(text)` - Parse a text or structured value into a metric. +6. `metricSpacesFormatMetric(value)` - Format a metric for deterministic user-facing output. +7. `metricSpacesCompareMetric(left, right)` - Compare two metric values under the conventions of Metric Spaces. +8. `metricSpacesCombineMetric(left, right)` - Combine two metric values with the natural operation for Metric Spaces. +9. `metricSpacesDecomposeMetric(value)` - Decompose a metric into simpler or canonical components. +10. `metricSpacesEvaluateMetric(value, point=None)` - Evaluate a metric at a point, sample, or finite model. +11. `metricSpacesComputeMetric(value)` - Compute the central numerical or symbolic data of a metric. +12. `metricSpacesEstimateMetric(value, samples=None)` - Estimate a metric property from finite samples or approximations. +13. `metricSpacesApproximateMetric(value, tolerance=1e-9)` - Approximate a metric with explicit tolerance controls. +14. `metricSpacesTransformMetric(value, mapping)` - Transform a metric through a map, operator, or representation change. +15. `metricSpacesSimplifyMetric(value)` - Simplify a metric without changing its mathematical meaning. +16. `metricSpacesEnumerateMetric(value, limit=None)` - Enumerate finite members, cases, or derived objects for a metric. +17. `metricSpacesClassifyMetric(value)` - Classify a metric by its standard Metric Spaces invariants. +18. `metricSpacesTestEquivalenceMetric(left, right)` - Test whether two metric values are equivalent in Metric Spaces. +19. `metricSpacesGenerateExampleMetric(size=3)` - Generate a small documented example of a metric. +20. `metricSpacesDocumentMetric(value)` - Return a structured explanation of a metric and related assumptions. +21. `metricSpacesValidatePointCloud(value)` - Validate the point cloud representation and domain rules for Metric Spaces. +22. `metricSpacesConstructPointCloud(*args)` - Construct a point cloud from explicit inputs for Metric Spaces. +23. `metricSpacesNormalizePointCloud(value)` - Normalize a point cloud into the standard Metric Spaces representation. +24. `metricSpacesCanonicalizePointCloud(value)` - Canonicalize a point cloud so equivalent inputs share one form. +25. `metricSpacesParsePointCloud(text)` - Parse a text or structured value into a point cloud. +26. `metricSpacesFormatPointCloud(value)` - Format a point cloud for deterministic user-facing output. +27. `metricSpacesComparePointCloud(left, right)` - Compare two point cloud values under the conventions of Metric Spaces. +28. `metricSpacesCombinePointCloud(left, right)` - Combine two point cloud values with the natural operation for Metric Spaces. +29. `metricSpacesDecomposePointCloud(value)` - Decompose a point cloud into simpler or canonical components. +30. `metricSpacesEvaluatePointCloud(value, point=None)` - Evaluate a point cloud at a point, sample, or finite model. +31. `metricSpacesComputePointCloud(value)` - Compute the central numerical or symbolic data of a point cloud. +32. `metricSpacesEstimatePointCloud(value, samples=None)` - Estimate a point cloud property from finite samples or approximations. +33. `metricSpacesApproximatePointCloud(value, tolerance=1e-9)` - Approximate a point cloud with explicit tolerance controls. +34. `metricSpacesTransformPointCloud(value, mapping)` - Transform a point cloud through a map, operator, or representation change. +35. `metricSpacesSimplifyPointCloud(value)` - Simplify a point cloud without changing its mathematical meaning. +36. `metricSpacesEnumeratePointCloud(value, limit=None)` - Enumerate finite members, cases, or derived objects for a point cloud. +37. `metricSpacesClassifyPointCloud(value)` - Classify a point cloud by its standard Metric Spaces invariants. +38. `metricSpacesTestEquivalencePointCloud(left, right)` - Test whether two point cloud values are equivalent in Metric Spaces. +39. `metricSpacesGenerateExamplePointCloud(size=3)` - Generate a small documented example of a point cloud. +40. `metricSpacesDocumentPointCloud(value)` - Return a structured explanation of a point cloud and related assumptions. +41. `metricSpacesValidateOpenBall(value)` - Validate the open ball representation and domain rules for Metric Spaces. +42. `metricSpacesConstructOpenBall(*args)` - Construct a open ball from explicit inputs for Metric Spaces. +43. `metricSpacesNormalizeOpenBall(value)` - Normalize a open ball into the standard Metric Spaces representation. +44. `metricSpacesCanonicalizeOpenBall(value)` - Canonicalize a open ball so equivalent inputs share one form. +45. `metricSpacesParseOpenBall(text)` - Parse a text or structured value into a open ball. +46. `metricSpacesFormatOpenBall(value)` - Format a open ball for deterministic user-facing output. +47. `metricSpacesCompareOpenBall(left, right)` - Compare two open ball values under the conventions of Metric Spaces. +48. `metricSpacesCombineOpenBall(left, right)` - Combine two open ball values with the natural operation for Metric Spaces. +49. `metricSpacesDecomposeOpenBall(value)` - Decompose a open ball into simpler or canonical components. +50. `metricSpacesEvaluateOpenBall(value, point=None)` - Evaluate a open ball at a point, sample, or finite model. +51. `metricSpacesComputeOpenBall(value)` - Compute the central numerical or symbolic data of a open ball. +52. `metricSpacesEstimateOpenBall(value, samples=None)` - Estimate a open ball property from finite samples or approximations. +53. `metricSpacesApproximateOpenBall(value, tolerance=1e-9)` - Approximate a open ball with explicit tolerance controls. +54. `metricSpacesTransformOpenBall(value, mapping)` - Transform a open ball through a map, operator, or representation change. +55. `metricSpacesSimplifyOpenBall(value)` - Simplify a open ball without changing its mathematical meaning. +56. `metricSpacesEnumerateOpenBall(value, limit=None)` - Enumerate finite members, cases, or derived objects for a open ball. +57. `metricSpacesClassifyOpenBall(value)` - Classify a open ball by its standard Metric Spaces invariants. +58. `metricSpacesTestEquivalenceOpenBall(left, right)` - Test whether two open ball values are equivalent in Metric Spaces. +59. `metricSpacesGenerateExampleOpenBall(size=3)` - Generate a small documented example of a open ball. +60. `metricSpacesDocumentOpenBall(value)` - Return a structured explanation of a open ball and related assumptions. +61. `metricSpacesValidateSequence(value)` - Validate the sequence representation and domain rules for Metric Spaces. +62. `metricSpacesConstructSequence(*args)` - Construct a sequence from explicit inputs for Metric Spaces. +63. `metricSpacesNormalizeSequence(value)` - Normalize a sequence into the standard Metric Spaces representation. +64. `metricSpacesCanonicalizeSequence(value)` - Canonicalize a sequence so equivalent inputs share one form. +65. `metricSpacesParseSequence(text)` - Parse a text or structured value into a sequence. +66. `metricSpacesFormatSequence(value)` - Format a sequence for deterministic user-facing output. +67. `metricSpacesCompareSequence(left, right)` - Compare two sequence values under the conventions of Metric Spaces. +68. `metricSpacesCombineSequence(left, right)` - Combine two sequence values with the natural operation for Metric Spaces. +69. `metricSpacesDecomposeSequence(value)` - Decompose a sequence into simpler or canonical components. +70. `metricSpacesEvaluateSequence(value, point=None)` - Evaluate a sequence at a point, sample, or finite model. +71. `metricSpacesComputeSequence(value)` - Compute the central numerical or symbolic data of a sequence. +72. `metricSpacesEstimateSequence(value, samples=None)` - Estimate a sequence property from finite samples or approximations. +73. `metricSpacesApproximateSequence(value, tolerance=1e-9)` - Approximate a sequence with explicit tolerance controls. +74. `metricSpacesTransformSequence(value, mapping)` - Transform a sequence through a map, operator, or representation change. +75. `metricSpacesSimplifySequence(value)` - Simplify a sequence without changing its mathematical meaning. +76. `metricSpacesEnumerateSequence(value, limit=None)` - Enumerate finite members, cases, or derived objects for a sequence. +77. `metricSpacesClassifySequence(value)` - Classify a sequence by its standard Metric Spaces invariants. +78. `metricSpacesTestEquivalenceSequence(left, right)` - Test whether two sequence values are equivalent in Metric Spaces. +79. `metricSpacesGenerateExampleSequence(size=3)` - Generate a small documented example of a sequence. +80. `metricSpacesDocumentSequence(value)` - Return a structured explanation of a sequence and related assumptions. +81. `metricSpacesValidateBoundedSet(value)` - Validate the bounded set representation and domain rules for Metric Spaces. +82. `metricSpacesConstructBoundedSet(*args)` - Construct a bounded set from explicit inputs for Metric Spaces. +83. `metricSpacesNormalizeBoundedSet(value)` - Normalize a bounded set into the standard Metric Spaces representation. +84. `metricSpacesCanonicalizeBoundedSet(value)` - Canonicalize a bounded set so equivalent inputs share one form. +85. `metricSpacesParseBoundedSet(text)` - Parse a text or structured value into a bounded set. +86. `metricSpacesFormatBoundedSet(value)` - Format a bounded set for deterministic user-facing output. +87. `metricSpacesCompareBoundedSet(left, right)` - Compare two bounded set values under the conventions of Metric Spaces. +88. `metricSpacesCombineBoundedSet(left, right)` - Combine two bounded set values with the natural operation for Metric Spaces. +89. `metricSpacesDecomposeBoundedSet(value)` - Decompose a bounded set into simpler or canonical components. +90. `metricSpacesEvaluateBoundedSet(value, point=None)` - Evaluate a bounded set at a point, sample, or finite model. +91. `metricSpacesComputeBoundedSet(value)` - Compute the central numerical or symbolic data of a bounded set. +92. `metricSpacesEstimateBoundedSet(value, samples=None)` - Estimate a bounded set property from finite samples or approximations. +93. `metricSpacesApproximateBoundedSet(value, tolerance=1e-9)` - Approximate a bounded set with explicit tolerance controls. +94. `metricSpacesTransformBoundedSet(value, mapping)` - Transform a bounded set through a map, operator, or representation change. +95. `metricSpacesSimplifyBoundedSet(value)` - Simplify a bounded set without changing its mathematical meaning. +96. `metricSpacesEnumerateBoundedSet(value, limit=None)` - Enumerate finite members, cases, or derived objects for a bounded set. +97. `metricSpacesClassifyBoundedSet(value)` - Classify a bounded set by its standard Metric Spaces invariants. +98. `metricSpacesTestEquivalenceBoundedSet(left, right)` - Test whether two bounded set values are equivalent in Metric Spaces. +99. `metricSpacesGenerateExampleBoundedSet(size=3)` - Generate a small documented example of a bounded set. +100. `metricSpacesDocumentBoundedSet(value)` - Return a structured explanation of a bounded set and related assumptions. + +### Calculus + +Core object families: + +- single-variable function +- limit model +- derivative model +- integral model +- continuity profile + +Candidate functions: + +1. `calculusValidateSingleVariableFunction(value)` - Validate the single-variable function representation and domain rules for Calculus. +2. `calculusConstructSingleVariableFunction(*args)` - Construct a single-variable function from explicit inputs for Calculus. +3. `calculusNormalizeSingleVariableFunction(value)` - Normalize a single-variable function into the standard Calculus representation. +4. `calculusCanonicalizeSingleVariableFunction(value)` - Canonicalize a single-variable function so equivalent inputs share one form. +5. `calculusParseSingleVariableFunction(text)` - Parse a text or structured value into a single-variable function. +6. `calculusFormatSingleVariableFunction(value)` - Format a single-variable function for deterministic user-facing output. +7. `calculusCompareSingleVariableFunction(left, right)` - Compare two single-variable function values under the conventions of Calculus. +8. `calculusCombineSingleVariableFunction(left, right)` - Combine two single-variable function values with the natural operation for Calculus. +9. `calculusDecomposeSingleVariableFunction(value)` - Decompose a single-variable function into simpler or canonical components. +10. `calculusEvaluateSingleVariableFunction(value, point=None)` - Evaluate a single-variable function at a point, sample, or finite model. +11. `calculusComputeSingleVariableFunction(value)` - Compute the central numerical or symbolic data of a single-variable function. +12. `calculusEstimateSingleVariableFunction(value, samples=None)` - Estimate a single-variable function property from finite samples or approximations. +13. `calculusApproximateSingleVariableFunction(value, tolerance=1e-9)` - Approximate a single-variable function with explicit tolerance controls. +14. `calculusTransformSingleVariableFunction(value, mapping)` - Transform a single-variable function through a map, operator, or representation change. +15. `calculusSimplifySingleVariableFunction(value)` - Simplify a single-variable function without changing its mathematical meaning. +16. `calculusEnumerateSingleVariableFunction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a single-variable function. +17. `calculusClassifySingleVariableFunction(value)` - Classify a single-variable function by its standard Calculus invariants. +18. `calculusTestEquivalenceSingleVariableFunction(left, right)` - Test whether two single-variable function values are equivalent in Calculus. +19. `calculusGenerateExampleSingleVariableFunction(size=3)` - Generate a small documented example of a single-variable function. +20. `calculusDocumentSingleVariableFunction(value)` - Return a structured explanation of a single-variable function and related assumptions. +21. `calculusValidateLimitModel(value)` - Validate the limit model representation and domain rules for Calculus. +22. `calculusConstructLimitModel(*args)` - Construct a limit model from explicit inputs for Calculus. +23. `calculusNormalizeLimitModel(value)` - Normalize a limit model into the standard Calculus representation. +24. `calculusCanonicalizeLimitModel(value)` - Canonicalize a limit model so equivalent inputs share one form. +25. `calculusParseLimitModel(text)` - Parse a text or structured value into a limit model. +26. `calculusFormatLimitModel(value)` - Format a limit model for deterministic user-facing output. +27. `calculusCompareLimitModel(left, right)` - Compare two limit model values under the conventions of Calculus. +28. `calculusCombineLimitModel(left, right)` - Combine two limit model values with the natural operation for Calculus. +29. `calculusDecomposeLimitModel(value)` - Decompose a limit model into simpler or canonical components. +30. `calculusEvaluateLimitModel(value, point=None)` - Evaluate a limit model at a point, sample, or finite model. +31. `calculusComputeLimitModel(value)` - Compute the central numerical or symbolic data of a limit model. +32. `calculusEstimateLimitModel(value, samples=None)` - Estimate a limit model property from finite samples or approximations. +33. `calculusApproximateLimitModel(value, tolerance=1e-9)` - Approximate a limit model with explicit tolerance controls. +34. `calculusTransformLimitModel(value, mapping)` - Transform a limit model through a map, operator, or representation change. +35. `calculusSimplifyLimitModel(value)` - Simplify a limit model without changing its mathematical meaning. +36. `calculusEnumerateLimitModel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a limit model. +37. `calculusClassifyLimitModel(value)` - Classify a limit model by its standard Calculus invariants. +38. `calculusTestEquivalenceLimitModel(left, right)` - Test whether two limit model values are equivalent in Calculus. +39. `calculusGenerateExampleLimitModel(size=3)` - Generate a small documented example of a limit model. +40. `calculusDocumentLimitModel(value)` - Return a structured explanation of a limit model and related assumptions. +41. `calculusValidateDerivativeModel(value)` - Validate the derivative model representation and domain rules for Calculus. +42. `calculusConstructDerivativeModel(*args)` - Construct a derivative model from explicit inputs for Calculus. +43. `calculusNormalizeDerivativeModel(value)` - Normalize a derivative model into the standard Calculus representation. +44. `calculusCanonicalizeDerivativeModel(value)` - Canonicalize a derivative model so equivalent inputs share one form. +45. `calculusParseDerivativeModel(text)` - Parse a text or structured value into a derivative model. +46. `calculusFormatDerivativeModel(value)` - Format a derivative model for deterministic user-facing output. +47. `calculusCompareDerivativeModel(left, right)` - Compare two derivative model values under the conventions of Calculus. +48. `calculusCombineDerivativeModel(left, right)` - Combine two derivative model values with the natural operation for Calculus. +49. `calculusDecomposeDerivativeModel(value)` - Decompose a derivative model into simpler or canonical components. +50. `calculusEvaluateDerivativeModel(value, point=None)` - Evaluate a derivative model at a point, sample, or finite model. +51. `calculusComputeDerivativeModel(value)` - Compute the central numerical or symbolic data of a derivative model. +52. `calculusEstimateDerivativeModel(value, samples=None)` - Estimate a derivative model property from finite samples or approximations. +53. `calculusApproximateDerivativeModel(value, tolerance=1e-9)` - Approximate a derivative model with explicit tolerance controls. +54. `calculusTransformDerivativeModel(value, mapping)` - Transform a derivative model through a map, operator, or representation change. +55. `calculusSimplifyDerivativeModel(value)` - Simplify a derivative model without changing its mathematical meaning. +56. `calculusEnumerateDerivativeModel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a derivative model. +57. `calculusClassifyDerivativeModel(value)` - Classify a derivative model by its standard Calculus invariants. +58. `calculusTestEquivalenceDerivativeModel(left, right)` - Test whether two derivative model values are equivalent in Calculus. +59. `calculusGenerateExampleDerivativeModel(size=3)` - Generate a small documented example of a derivative model. +60. `calculusDocumentDerivativeModel(value)` - Return a structured explanation of a derivative model and related assumptions. +61. `calculusValidateIntegralModel(value)` - Validate the integral model representation and domain rules for Calculus. +62. `calculusConstructIntegralModel(*args)` - Construct a integral model from explicit inputs for Calculus. +63. `calculusNormalizeIntegralModel(value)` - Normalize a integral model into the standard Calculus representation. +64. `calculusCanonicalizeIntegralModel(value)` - Canonicalize a integral model so equivalent inputs share one form. +65. `calculusParseIntegralModel(text)` - Parse a text or structured value into a integral model. +66. `calculusFormatIntegralModel(value)` - Format a integral model for deterministic user-facing output. +67. `calculusCompareIntegralModel(left, right)` - Compare two integral model values under the conventions of Calculus. +68. `calculusCombineIntegralModel(left, right)` - Combine two integral model values with the natural operation for Calculus. +69. `calculusDecomposeIntegralModel(value)` - Decompose a integral model into simpler or canonical components. +70. `calculusEvaluateIntegralModel(value, point=None)` - Evaluate a integral model at a point, sample, or finite model. +71. `calculusComputeIntegralModel(value)` - Compute the central numerical or symbolic data of a integral model. +72. `calculusEstimateIntegralModel(value, samples=None)` - Estimate a integral model property from finite samples or approximations. +73. `calculusApproximateIntegralModel(value, tolerance=1e-9)` - Approximate a integral model with explicit tolerance controls. +74. `calculusTransformIntegralModel(value, mapping)` - Transform a integral model through a map, operator, or representation change. +75. `calculusSimplifyIntegralModel(value)` - Simplify a integral model without changing its mathematical meaning. +76. `calculusEnumerateIntegralModel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a integral model. +77. `calculusClassifyIntegralModel(value)` - Classify a integral model by its standard Calculus invariants. +78. `calculusTestEquivalenceIntegralModel(left, right)` - Test whether two integral model values are equivalent in Calculus. +79. `calculusGenerateExampleIntegralModel(size=3)` - Generate a small documented example of a integral model. +80. `calculusDocumentIntegralModel(value)` - Return a structured explanation of a integral model and related assumptions. +81. `calculusValidateContinuityProfile(value)` - Validate the continuity profile representation and domain rules for Calculus. +82. `calculusConstructContinuityProfile(*args)` - Construct a continuity profile from explicit inputs for Calculus. +83. `calculusNormalizeContinuityProfile(value)` - Normalize a continuity profile into the standard Calculus representation. +84. `calculusCanonicalizeContinuityProfile(value)` - Canonicalize a continuity profile so equivalent inputs share one form. +85. `calculusParseContinuityProfile(text)` - Parse a text or structured value into a continuity profile. +86. `calculusFormatContinuityProfile(value)` - Format a continuity profile for deterministic user-facing output. +87. `calculusCompareContinuityProfile(left, right)` - Compare two continuity profile values under the conventions of Calculus. +88. `calculusCombineContinuityProfile(left, right)` - Combine two continuity profile values with the natural operation for Calculus. +89. `calculusDecomposeContinuityProfile(value)` - Decompose a continuity profile into simpler or canonical components. +90. `calculusEvaluateContinuityProfile(value, point=None)` - Evaluate a continuity profile at a point, sample, or finite model. +91. `calculusComputeContinuityProfile(value)` - Compute the central numerical or symbolic data of a continuity profile. +92. `calculusEstimateContinuityProfile(value, samples=None)` - Estimate a continuity profile property from finite samples or approximations. +93. `calculusApproximateContinuityProfile(value, tolerance=1e-9)` - Approximate a continuity profile with explicit tolerance controls. +94. `calculusTransformContinuityProfile(value, mapping)` - Transform a continuity profile through a map, operator, or representation change. +95. `calculusSimplifyContinuityProfile(value)` - Simplify a continuity profile without changing its mathematical meaning. +96. `calculusEnumerateContinuityProfile(value, limit=None)` - Enumerate finite members, cases, or derived objects for a continuity profile. +97. `calculusClassifyContinuityProfile(value)` - Classify a continuity profile by its standard Calculus invariants. +98. `calculusTestEquivalenceContinuityProfile(left, right)` - Test whether two continuity profile values are equivalent in Calculus. +99. `calculusGenerateExampleContinuityProfile(size=3)` - Generate a small documented example of a continuity profile. +100. `calculusDocumentContinuityProfile(value)` - Return a structured explanation of a continuity profile and related assumptions. + +### Complex Analysis + +Core object families: + +- complex function +- analytic check +- contour +- singularity +- complex transform + +Candidate functions: + +1. `complexAnalysisValidateComplexFunction(value)` - Validate the complex function representation and domain rules for Complex Analysis. +2. `complexAnalysisConstructComplexFunction(*args)` - Construct a complex function from explicit inputs for Complex Analysis. +3. `complexAnalysisNormalizeComplexFunction(value)` - Normalize a complex function into the standard Complex Analysis representation. +4. `complexAnalysisCanonicalizeComplexFunction(value)` - Canonicalize a complex function so equivalent inputs share one form. +5. `complexAnalysisParseComplexFunction(text)` - Parse a text or structured value into a complex function. +6. `complexAnalysisFormatComplexFunction(value)` - Format a complex function for deterministic user-facing output. +7. `complexAnalysisCompareComplexFunction(left, right)` - Compare two complex function values under the conventions of Complex Analysis. +8. `complexAnalysisCombineComplexFunction(left, right)` - Combine two complex function values with the natural operation for Complex Analysis. +9. `complexAnalysisDecomposeComplexFunction(value)` - Decompose a complex function into simpler or canonical components. +10. `complexAnalysisEvaluateComplexFunction(value, point=None)` - Evaluate a complex function at a point, sample, or finite model. +11. `complexAnalysisComputeComplexFunction(value)` - Compute the central numerical or symbolic data of a complex function. +12. `complexAnalysisEstimateComplexFunction(value, samples=None)` - Estimate a complex function property from finite samples or approximations. +13. `complexAnalysisApproximateComplexFunction(value, tolerance=1e-9)` - Approximate a complex function with explicit tolerance controls. +14. `complexAnalysisTransformComplexFunction(value, mapping)` - Transform a complex function through a map, operator, or representation change. +15. `complexAnalysisSimplifyComplexFunction(value)` - Simplify a complex function without changing its mathematical meaning. +16. `complexAnalysisEnumerateComplexFunction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a complex function. +17. `complexAnalysisClassifyComplexFunction(value)` - Classify a complex function by its standard Complex Analysis invariants. +18. `complexAnalysisTestEquivalenceComplexFunction(left, right)` - Test whether two complex function values are equivalent in Complex Analysis. +19. `complexAnalysisGenerateExampleComplexFunction(size=3)` - Generate a small documented example of a complex function. +20. `complexAnalysisDocumentComplexFunction(value)` - Return a structured explanation of a complex function and related assumptions. +21. `complexAnalysisValidateAnalyticCheck(value)` - Validate the analytic check representation and domain rules for Complex Analysis. +22. `complexAnalysisConstructAnalyticCheck(*args)` - Construct a analytic check from explicit inputs for Complex Analysis. +23. `complexAnalysisNormalizeAnalyticCheck(value)` - Normalize a analytic check into the standard Complex Analysis representation. +24. `complexAnalysisCanonicalizeAnalyticCheck(value)` - Canonicalize a analytic check so equivalent inputs share one form. +25. `complexAnalysisParseAnalyticCheck(text)` - Parse a text or structured value into a analytic check. +26. `complexAnalysisFormatAnalyticCheck(value)` - Format a analytic check for deterministic user-facing output. +27. `complexAnalysisCompareAnalyticCheck(left, right)` - Compare two analytic check values under the conventions of Complex Analysis. +28. `complexAnalysisCombineAnalyticCheck(left, right)` - Combine two analytic check values with the natural operation for Complex Analysis. +29. `complexAnalysisDecomposeAnalyticCheck(value)` - Decompose a analytic check into simpler or canonical components. +30. `complexAnalysisEvaluateAnalyticCheck(value, point=None)` - Evaluate a analytic check at a point, sample, or finite model. +31. `complexAnalysisComputeAnalyticCheck(value)` - Compute the central numerical or symbolic data of a analytic check. +32. `complexAnalysisEstimateAnalyticCheck(value, samples=None)` - Estimate a analytic check property from finite samples or approximations. +33. `complexAnalysisApproximateAnalyticCheck(value, tolerance=1e-9)` - Approximate a analytic check with explicit tolerance controls. +34. `complexAnalysisTransformAnalyticCheck(value, mapping)` - Transform a analytic check through a map, operator, or representation change. +35. `complexAnalysisSimplifyAnalyticCheck(value)` - Simplify a analytic check without changing its mathematical meaning. +36. `complexAnalysisEnumerateAnalyticCheck(value, limit=None)` - Enumerate finite members, cases, or derived objects for a analytic check. +37. `complexAnalysisClassifyAnalyticCheck(value)` - Classify a analytic check by its standard Complex Analysis invariants. +38. `complexAnalysisTestEquivalenceAnalyticCheck(left, right)` - Test whether two analytic check values are equivalent in Complex Analysis. +39. `complexAnalysisGenerateExampleAnalyticCheck(size=3)` - Generate a small documented example of a analytic check. +40. `complexAnalysisDocumentAnalyticCheck(value)` - Return a structured explanation of a analytic check and related assumptions. +41. `complexAnalysisValidateContour(value)` - Validate the contour representation and domain rules for Complex Analysis. +42. `complexAnalysisConstructContour(*args)` - Construct a contour from explicit inputs for Complex Analysis. +43. `complexAnalysisNormalizeContour(value)` - Normalize a contour into the standard Complex Analysis representation. +44. `complexAnalysisCanonicalizeContour(value)` - Canonicalize a contour so equivalent inputs share one form. +45. `complexAnalysisParseContour(text)` - Parse a text or structured value into a contour. +46. `complexAnalysisFormatContour(value)` - Format a contour for deterministic user-facing output. +47. `complexAnalysisCompareContour(left, right)` - Compare two contour values under the conventions of Complex Analysis. +48. `complexAnalysisCombineContour(left, right)` - Combine two contour values with the natural operation for Complex Analysis. +49. `complexAnalysisDecomposeContour(value)` - Decompose a contour into simpler or canonical components. +50. `complexAnalysisEvaluateContour(value, point=None)` - Evaluate a contour at a point, sample, or finite model. +51. `complexAnalysisComputeContour(value)` - Compute the central numerical or symbolic data of a contour. +52. `complexAnalysisEstimateContour(value, samples=None)` - Estimate a contour property from finite samples or approximations. +53. `complexAnalysisApproximateContour(value, tolerance=1e-9)` - Approximate a contour with explicit tolerance controls. +54. `complexAnalysisTransformContour(value, mapping)` - Transform a contour through a map, operator, or representation change. +55. `complexAnalysisSimplifyContour(value)` - Simplify a contour without changing its mathematical meaning. +56. `complexAnalysisEnumerateContour(value, limit=None)` - Enumerate finite members, cases, or derived objects for a contour. +57. `complexAnalysisClassifyContour(value)` - Classify a contour by its standard Complex Analysis invariants. +58. `complexAnalysisTestEquivalenceContour(left, right)` - Test whether two contour values are equivalent in Complex Analysis. +59. `complexAnalysisGenerateExampleContour(size=3)` - Generate a small documented example of a contour. +60. `complexAnalysisDocumentContour(value)` - Return a structured explanation of a contour and related assumptions. +61. `complexAnalysisValidateSingularity(value)` - Validate the singularity representation and domain rules for Complex Analysis. +62. `complexAnalysisConstructSingularity(*args)` - Construct a singularity from explicit inputs for Complex Analysis. +63. `complexAnalysisNormalizeSingularity(value)` - Normalize a singularity into the standard Complex Analysis representation. +64. `complexAnalysisCanonicalizeSingularity(value)` - Canonicalize a singularity so equivalent inputs share one form. +65. `complexAnalysisParseSingularity(text)` - Parse a text or structured value into a singularity. +66. `complexAnalysisFormatSingularity(value)` - Format a singularity for deterministic user-facing output. +67. `complexAnalysisCompareSingularity(left, right)` - Compare two singularity values under the conventions of Complex Analysis. +68. `complexAnalysisCombineSingularity(left, right)` - Combine two singularity values with the natural operation for Complex Analysis. +69. `complexAnalysisDecomposeSingularity(value)` - Decompose a singularity into simpler or canonical components. +70. `complexAnalysisEvaluateSingularity(value, point=None)` - Evaluate a singularity at a point, sample, or finite model. +71. `complexAnalysisComputeSingularity(value)` - Compute the central numerical or symbolic data of a singularity. +72. `complexAnalysisEstimateSingularity(value, samples=None)` - Estimate a singularity property from finite samples or approximations. +73. `complexAnalysisApproximateSingularity(value, tolerance=1e-9)` - Approximate a singularity with explicit tolerance controls. +74. `complexAnalysisTransformSingularity(value, mapping)` - Transform a singularity through a map, operator, or representation change. +75. `complexAnalysisSimplifySingularity(value)` - Simplify a singularity without changing its mathematical meaning. +76. `complexAnalysisEnumerateSingularity(value, limit=None)` - Enumerate finite members, cases, or derived objects for a singularity. +77. `complexAnalysisClassifySingularity(value)` - Classify a singularity by its standard Complex Analysis invariants. +78. `complexAnalysisTestEquivalenceSingularity(left, right)` - Test whether two singularity values are equivalent in Complex Analysis. +79. `complexAnalysisGenerateExampleSingularity(size=3)` - Generate a small documented example of a singularity. +80. `complexAnalysisDocumentSingularity(value)` - Return a structured explanation of a singularity and related assumptions. +81. `complexAnalysisValidateComplexTransform(value)` - Validate the complex transform representation and domain rules for Complex Analysis. +82. `complexAnalysisConstructComplexTransform(*args)` - Construct a complex transform from explicit inputs for Complex Analysis. +83. `complexAnalysisNormalizeComplexTransform(value)` - Normalize a complex transform into the standard Complex Analysis representation. +84. `complexAnalysisCanonicalizeComplexTransform(value)` - Canonicalize a complex transform so equivalent inputs share one form. +85. `complexAnalysisParseComplexTransform(text)` - Parse a text or structured value into a complex transform. +86. `complexAnalysisFormatComplexTransform(value)` - Format a complex transform for deterministic user-facing output. +87. `complexAnalysisCompareComplexTransform(left, right)` - Compare two complex transform values under the conventions of Complex Analysis. +88. `complexAnalysisCombineComplexTransform(left, right)` - Combine two complex transform values with the natural operation for Complex Analysis. +89. `complexAnalysisDecomposeComplexTransform(value)` - Decompose a complex transform into simpler or canonical components. +90. `complexAnalysisEvaluateComplexTransform(value, point=None)` - Evaluate a complex transform at a point, sample, or finite model. +91. `complexAnalysisComputeComplexTransform(value)` - Compute the central numerical or symbolic data of a complex transform. +92. `complexAnalysisEstimateComplexTransform(value, samples=None)` - Estimate a complex transform property from finite samples or approximations. +93. `complexAnalysisApproximateComplexTransform(value, tolerance=1e-9)` - Approximate a complex transform with explicit tolerance controls. +94. `complexAnalysisTransformComplexTransform(value, mapping)` - Transform a complex transform through a map, operator, or representation change. +95. `complexAnalysisSimplifyComplexTransform(value)` - Simplify a complex transform without changing its mathematical meaning. +96. `complexAnalysisEnumerateComplexTransform(value, limit=None)` - Enumerate finite members, cases, or derived objects for a complex transform. +97. `complexAnalysisClassifyComplexTransform(value)` - Classify a complex transform by its standard Complex Analysis invariants. +98. `complexAnalysisTestEquivalenceComplexTransform(left, right)` - Test whether two complex transform values are equivalent in Complex Analysis. +99. `complexAnalysisGenerateExampleComplexTransform(size=3)` - Generate a small documented example of a complex transform. +100. `complexAnalysisDocumentComplexTransform(value)` - Return a structured explanation of a complex transform and related assumptions. + +### Number Theory + +Core object families: + +- integer +- modular system +- prime structure +- divisor set +- arithmetic function + +Candidate functions: + +1. `numberTheoryValidateInteger(value)` - Validate the integer representation and domain rules for Number Theory. +2. `numberTheoryConstructInteger(*args)` - Construct a integer from explicit inputs for Number Theory. +3. `numberTheoryNormalizeInteger(value)` - Normalize a integer into the standard Number Theory representation. +4. `numberTheoryCanonicalizeInteger(value)` - Canonicalize a integer so equivalent inputs share one form. +5. `numberTheoryParseInteger(text)` - Parse a text or structured value into a integer. +6. `numberTheoryFormatInteger(value)` - Format a integer for deterministic user-facing output. +7. `numberTheoryCompareInteger(left, right)` - Compare two integer values under the conventions of Number Theory. +8. `numberTheoryCombineInteger(left, right)` - Combine two integer values with the natural operation for Number Theory. +9. `numberTheoryDecomposeInteger(value)` - Decompose a integer into simpler or canonical components. +10. `numberTheoryEvaluateInteger(value, point=None)` - Evaluate a integer at a point, sample, or finite model. +11. `numberTheoryComputeInteger(value)` - Compute the central numerical or symbolic data of a integer. +12. `numberTheoryEstimateInteger(value, samples=None)` - Estimate a integer property from finite samples or approximations. +13. `numberTheoryApproximateInteger(value, tolerance=1e-9)` - Approximate a integer with explicit tolerance controls. +14. `numberTheoryTransformInteger(value, mapping)` - Transform a integer through a map, operator, or representation change. +15. `numberTheorySimplifyInteger(value)` - Simplify a integer without changing its mathematical meaning. +16. `numberTheoryEnumerateInteger(value, limit=None)` - Enumerate finite members, cases, or derived objects for a integer. +17. `numberTheoryClassifyInteger(value)` - Classify a integer by its standard Number Theory invariants. +18. `numberTheoryTestEquivalenceInteger(left, right)` - Test whether two integer values are equivalent in Number Theory. +19. `numberTheoryGenerateExampleInteger(size=3)` - Generate a small documented example of a integer. +20. `numberTheoryDocumentInteger(value)` - Return a structured explanation of a integer and related assumptions. +21. `numberTheoryValidateModularSystem(value)` - Validate the modular system representation and domain rules for Number Theory. +22. `numberTheoryConstructModularSystem(*args)` - Construct a modular system from explicit inputs for Number Theory. +23. `numberTheoryNormalizeModularSystem(value)` - Normalize a modular system into the standard Number Theory representation. +24. `numberTheoryCanonicalizeModularSystem(value)` - Canonicalize a modular system so equivalent inputs share one form. +25. `numberTheoryParseModularSystem(text)` - Parse a text or structured value into a modular system. +26. `numberTheoryFormatModularSystem(value)` - Format a modular system for deterministic user-facing output. +27. `numberTheoryCompareModularSystem(left, right)` - Compare two modular system values under the conventions of Number Theory. +28. `numberTheoryCombineModularSystem(left, right)` - Combine two modular system values with the natural operation for Number Theory. +29. `numberTheoryDecomposeModularSystem(value)` - Decompose a modular system into simpler or canonical components. +30. `numberTheoryEvaluateModularSystem(value, point=None)` - Evaluate a modular system at a point, sample, or finite model. +31. `numberTheoryComputeModularSystem(value)` - Compute the central numerical or symbolic data of a modular system. +32. `numberTheoryEstimateModularSystem(value, samples=None)` - Estimate a modular system property from finite samples or approximations. +33. `numberTheoryApproximateModularSystem(value, tolerance=1e-9)` - Approximate a modular system with explicit tolerance controls. +34. `numberTheoryTransformModularSystem(value, mapping)` - Transform a modular system through a map, operator, or representation change. +35. `numberTheorySimplifyModularSystem(value)` - Simplify a modular system without changing its mathematical meaning. +36. `numberTheoryEnumerateModularSystem(value, limit=None)` - Enumerate finite members, cases, or derived objects for a modular system. +37. `numberTheoryClassifyModularSystem(value)` - Classify a modular system by its standard Number Theory invariants. +38. `numberTheoryTestEquivalenceModularSystem(left, right)` - Test whether two modular system values are equivalent in Number Theory. +39. `numberTheoryGenerateExampleModularSystem(size=3)` - Generate a small documented example of a modular system. +40. `numberTheoryDocumentModularSystem(value)` - Return a structured explanation of a modular system and related assumptions. +41. `numberTheoryValidatePrimeStructure(value)` - Validate the prime structure representation and domain rules for Number Theory. +42. `numberTheoryConstructPrimeStructure(*args)` - Construct a prime structure from explicit inputs for Number Theory. +43. `numberTheoryNormalizePrimeStructure(value)` - Normalize a prime structure into the standard Number Theory representation. +44. `numberTheoryCanonicalizePrimeStructure(value)` - Canonicalize a prime structure so equivalent inputs share one form. +45. `numberTheoryParsePrimeStructure(text)` - Parse a text or structured value into a prime structure. +46. `numberTheoryFormatPrimeStructure(value)` - Format a prime structure for deterministic user-facing output. +47. `numberTheoryComparePrimeStructure(left, right)` - Compare two prime structure values under the conventions of Number Theory. +48. `numberTheoryCombinePrimeStructure(left, right)` - Combine two prime structure values with the natural operation for Number Theory. +49. `numberTheoryDecomposePrimeStructure(value)` - Decompose a prime structure into simpler or canonical components. +50. `numberTheoryEvaluatePrimeStructure(value, point=None)` - Evaluate a prime structure at a point, sample, or finite model. +51. `numberTheoryComputePrimeStructure(value)` - Compute the central numerical or symbolic data of a prime structure. +52. `numberTheoryEstimatePrimeStructure(value, samples=None)` - Estimate a prime structure property from finite samples or approximations. +53. `numberTheoryApproximatePrimeStructure(value, tolerance=1e-9)` - Approximate a prime structure with explicit tolerance controls. +54. `numberTheoryTransformPrimeStructure(value, mapping)` - Transform a prime structure through a map, operator, or representation change. +55. `numberTheorySimplifyPrimeStructure(value)` - Simplify a prime structure without changing its mathematical meaning. +56. `numberTheoryEnumeratePrimeStructure(value, limit=None)` - Enumerate finite members, cases, or derived objects for a prime structure. +57. `numberTheoryClassifyPrimeStructure(value)` - Classify a prime structure by its standard Number Theory invariants. +58. `numberTheoryTestEquivalencePrimeStructure(left, right)` - Test whether two prime structure values are equivalent in Number Theory. +59. `numberTheoryGenerateExamplePrimeStructure(size=3)` - Generate a small documented example of a prime structure. +60. `numberTheoryDocumentPrimeStructure(value)` - Return a structured explanation of a prime structure and related assumptions. +61. `numberTheoryValidateDivisorSet(value)` - Validate the divisor set representation and domain rules for Number Theory. +62. `numberTheoryConstructDivisorSet(*args)` - Construct a divisor set from explicit inputs for Number Theory. +63. `numberTheoryNormalizeDivisorSet(value)` - Normalize a divisor set into the standard Number Theory representation. +64. `numberTheoryCanonicalizeDivisorSet(value)` - Canonicalize a divisor set so equivalent inputs share one form. +65. `numberTheoryParseDivisorSet(text)` - Parse a text or structured value into a divisor set. +66. `numberTheoryFormatDivisorSet(value)` - Format a divisor set for deterministic user-facing output. +67. `numberTheoryCompareDivisorSet(left, right)` - Compare two divisor set values under the conventions of Number Theory. +68. `numberTheoryCombineDivisorSet(left, right)` - Combine two divisor set values with the natural operation for Number Theory. +69. `numberTheoryDecomposeDivisorSet(value)` - Decompose a divisor set into simpler or canonical components. +70. `numberTheoryEvaluateDivisorSet(value, point=None)` - Evaluate a divisor set at a point, sample, or finite model. +71. `numberTheoryComputeDivisorSet(value)` - Compute the central numerical or symbolic data of a divisor set. +72. `numberTheoryEstimateDivisorSet(value, samples=None)` - Estimate a divisor set property from finite samples or approximations. +73. `numberTheoryApproximateDivisorSet(value, tolerance=1e-9)` - Approximate a divisor set with explicit tolerance controls. +74. `numberTheoryTransformDivisorSet(value, mapping)` - Transform a divisor set through a map, operator, or representation change. +75. `numberTheorySimplifyDivisorSet(value)` - Simplify a divisor set without changing its mathematical meaning. +76. `numberTheoryEnumerateDivisorSet(value, limit=None)` - Enumerate finite members, cases, or derived objects for a divisor set. +77. `numberTheoryClassifyDivisorSet(value)` - Classify a divisor set by its standard Number Theory invariants. +78. `numberTheoryTestEquivalenceDivisorSet(left, right)` - Test whether two divisor set values are equivalent in Number Theory. +79. `numberTheoryGenerateExampleDivisorSet(size=3)` - Generate a small documented example of a divisor set. +80. `numberTheoryDocumentDivisorSet(value)` - Return a structured explanation of a divisor set and related assumptions. +81. `numberTheoryValidateArithmeticFunction(value)` - Validate the arithmetic function representation and domain rules for Number Theory. +82. `numberTheoryConstructArithmeticFunction(*args)` - Construct a arithmetic function from explicit inputs for Number Theory. +83. `numberTheoryNormalizeArithmeticFunction(value)` - Normalize a arithmetic function into the standard Number Theory representation. +84. `numberTheoryCanonicalizeArithmeticFunction(value)` - Canonicalize a arithmetic function so equivalent inputs share one form. +85. `numberTheoryParseArithmeticFunction(text)` - Parse a text or structured value into a arithmetic function. +86. `numberTheoryFormatArithmeticFunction(value)` - Format a arithmetic function for deterministic user-facing output. +87. `numberTheoryCompareArithmeticFunction(left, right)` - Compare two arithmetic function values under the conventions of Number Theory. +88. `numberTheoryCombineArithmeticFunction(left, right)` - Combine two arithmetic function values with the natural operation for Number Theory. +89. `numberTheoryDecomposeArithmeticFunction(value)` - Decompose a arithmetic function into simpler or canonical components. +90. `numberTheoryEvaluateArithmeticFunction(value, point=None)` - Evaluate a arithmetic function at a point, sample, or finite model. +91. `numberTheoryComputeArithmeticFunction(value)` - Compute the central numerical or symbolic data of a arithmetic function. +92. `numberTheoryEstimateArithmeticFunction(value, samples=None)` - Estimate a arithmetic function property from finite samples or approximations. +93. `numberTheoryApproximateArithmeticFunction(value, tolerance=1e-9)` - Approximate a arithmetic function with explicit tolerance controls. +94. `numberTheoryTransformArithmeticFunction(value, mapping)` - Transform a arithmetic function through a map, operator, or representation change. +95. `numberTheorySimplifyArithmeticFunction(value)` - Simplify a arithmetic function without changing its mathematical meaning. +96. `numberTheoryEnumerateArithmeticFunction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a arithmetic function. +97. `numberTheoryClassifyArithmeticFunction(value)` - Classify a arithmetic function by its standard Number Theory invariants. +98. `numberTheoryTestEquivalenceArithmeticFunction(left, right)` - Test whether two arithmetic function values are equivalent in Number Theory. +99. `numberTheoryGenerateExampleArithmeticFunction(size=3)` - Generate a small documented example of a arithmetic function. +100. `numberTheoryDocumentArithmeticFunction(value)` - Return a structured explanation of a arithmetic function and related assumptions. + +### Topology + +Core object families: + +- topological space +- open set +- closed set +- continuous map +- finite cover + +Candidate functions: + +1. `topologyValidateTopologicalSpace(value)` - Validate the topological space representation and domain rules for Topology. +2. `topologyConstructTopologicalSpace(*args)` - Construct a topological space from explicit inputs for Topology. +3. `topologyNormalizeTopologicalSpace(value)` - Normalize a topological space into the standard Topology representation. +4. `topologyCanonicalizeTopologicalSpace(value)` - Canonicalize a topological space so equivalent inputs share one form. +5. `topologyParseTopologicalSpace(text)` - Parse a text or structured value into a topological space. +6. `topologyFormatTopologicalSpace(value)` - Format a topological space for deterministic user-facing output. +7. `topologyCompareTopologicalSpace(left, right)` - Compare two topological space values under the conventions of Topology. +8. `topologyCombineTopologicalSpace(left, right)` - Combine two topological space values with the natural operation for Topology. +9. `topologyDecomposeTopologicalSpace(value)` - Decompose a topological space into simpler or canonical components. +10. `topologyEvaluateTopologicalSpace(value, point=None)` - Evaluate a topological space at a point, sample, or finite model. +11. `topologyComputeTopologicalSpace(value)` - Compute the central numerical or symbolic data of a topological space. +12. `topologyEstimateTopologicalSpace(value, samples=None)` - Estimate a topological space property from finite samples or approximations. +13. `topologyApproximateTopologicalSpace(value, tolerance=1e-9)` - Approximate a topological space with explicit tolerance controls. +14. `topologyTransformTopologicalSpace(value, mapping)` - Transform a topological space through a map, operator, or representation change. +15. `topologySimplifyTopologicalSpace(value)` - Simplify a topological space without changing its mathematical meaning. +16. `topologyEnumerateTopologicalSpace(value, limit=None)` - Enumerate finite members, cases, or derived objects for a topological space. +17. `topologyClassifyTopologicalSpace(value)` - Classify a topological space by its standard Topology invariants. +18. `topologyTestEquivalenceTopologicalSpace(left, right)` - Test whether two topological space values are equivalent in Topology. +19. `topologyGenerateExampleTopologicalSpace(size=3)` - Generate a small documented example of a topological space. +20. `topologyDocumentTopologicalSpace(value)` - Return a structured explanation of a topological space and related assumptions. +21. `topologyValidateOpenSet(value)` - Validate the open set representation and domain rules for Topology. +22. `topologyConstructOpenSet(*args)` - Construct a open set from explicit inputs for Topology. +23. `topologyNormalizeOpenSet(value)` - Normalize a open set into the standard Topology representation. +24. `topologyCanonicalizeOpenSet(value)` - Canonicalize a open set so equivalent inputs share one form. +25. `topologyParseOpenSet(text)` - Parse a text or structured value into a open set. +26. `topologyFormatOpenSet(value)` - Format a open set for deterministic user-facing output. +27. `topologyCompareOpenSet(left, right)` - Compare two open set values under the conventions of Topology. +28. `topologyCombineOpenSet(left, right)` - Combine two open set values with the natural operation for Topology. +29. `topologyDecomposeOpenSet(value)` - Decompose a open set into simpler or canonical components. +30. `topologyEvaluateOpenSet(value, point=None)` - Evaluate a open set at a point, sample, or finite model. +31. `topologyComputeOpenSet(value)` - Compute the central numerical or symbolic data of a open set. +32. `topologyEstimateOpenSet(value, samples=None)` - Estimate a open set property from finite samples or approximations. +33. `topologyApproximateOpenSet(value, tolerance=1e-9)` - Approximate a open set with explicit tolerance controls. +34. `topologyTransformOpenSet(value, mapping)` - Transform a open set through a map, operator, or representation change. +35. `topologySimplifyOpenSet(value)` - Simplify a open set without changing its mathematical meaning. +36. `topologyEnumerateOpenSet(value, limit=None)` - Enumerate finite members, cases, or derived objects for a open set. +37. `topologyClassifyOpenSet(value)` - Classify a open set by its standard Topology invariants. +38. `topologyTestEquivalenceOpenSet(left, right)` - Test whether two open set values are equivalent in Topology. +39. `topologyGenerateExampleOpenSet(size=3)` - Generate a small documented example of a open set. +40. `topologyDocumentOpenSet(value)` - Return a structured explanation of a open set and related assumptions. +41. `topologyValidateClosedSet(value)` - Validate the closed set representation and domain rules for Topology. +42. `topologyConstructClosedSet(*args)` - Construct a closed set from explicit inputs for Topology. +43. `topologyNormalizeClosedSet(value)` - Normalize a closed set into the standard Topology representation. +44. `topologyCanonicalizeClosedSet(value)` - Canonicalize a closed set so equivalent inputs share one form. +45. `topologyParseClosedSet(text)` - Parse a text or structured value into a closed set. +46. `topologyFormatClosedSet(value)` - Format a closed set for deterministic user-facing output. +47. `topologyCompareClosedSet(left, right)` - Compare two closed set values under the conventions of Topology. +48. `topologyCombineClosedSet(left, right)` - Combine two closed set values with the natural operation for Topology. +49. `topologyDecomposeClosedSet(value)` - Decompose a closed set into simpler or canonical components. +50. `topologyEvaluateClosedSet(value, point=None)` - Evaluate a closed set at a point, sample, or finite model. +51. `topologyComputeClosedSet(value)` - Compute the central numerical or symbolic data of a closed set. +52. `topologyEstimateClosedSet(value, samples=None)` - Estimate a closed set property from finite samples or approximations. +53. `topologyApproximateClosedSet(value, tolerance=1e-9)` - Approximate a closed set with explicit tolerance controls. +54. `topologyTransformClosedSet(value, mapping)` - Transform a closed set through a map, operator, or representation change. +55. `topologySimplifyClosedSet(value)` - Simplify a closed set without changing its mathematical meaning. +56. `topologyEnumerateClosedSet(value, limit=None)` - Enumerate finite members, cases, or derived objects for a closed set. +57. `topologyClassifyClosedSet(value)` - Classify a closed set by its standard Topology invariants. +58. `topologyTestEquivalenceClosedSet(left, right)` - Test whether two closed set values are equivalent in Topology. +59. `topologyGenerateExampleClosedSet(size=3)` - Generate a small documented example of a closed set. +60. `topologyDocumentClosedSet(value)` - Return a structured explanation of a closed set and related assumptions. +61. `topologyValidateContinuousMap(value)` - Validate the continuous map representation and domain rules for Topology. +62. `topologyConstructContinuousMap(*args)` - Construct a continuous map from explicit inputs for Topology. +63. `topologyNormalizeContinuousMap(value)` - Normalize a continuous map into the standard Topology representation. +64. `topologyCanonicalizeContinuousMap(value)` - Canonicalize a continuous map so equivalent inputs share one form. +65. `topologyParseContinuousMap(text)` - Parse a text or structured value into a continuous map. +66. `topologyFormatContinuousMap(value)` - Format a continuous map for deterministic user-facing output. +67. `topologyCompareContinuousMap(left, right)` - Compare two continuous map values under the conventions of Topology. +68. `topologyCombineContinuousMap(left, right)` - Combine two continuous map values with the natural operation for Topology. +69. `topologyDecomposeContinuousMap(value)` - Decompose a continuous map into simpler or canonical components. +70. `topologyEvaluateContinuousMap(value, point=None)` - Evaluate a continuous map at a point, sample, or finite model. +71. `topologyComputeContinuousMap(value)` - Compute the central numerical or symbolic data of a continuous map. +72. `topologyEstimateContinuousMap(value, samples=None)` - Estimate a continuous map property from finite samples or approximations. +73. `topologyApproximateContinuousMap(value, tolerance=1e-9)` - Approximate a continuous map with explicit tolerance controls. +74. `topologyTransformContinuousMap(value, mapping)` - Transform a continuous map through a map, operator, or representation change. +75. `topologySimplifyContinuousMap(value)` - Simplify a continuous map without changing its mathematical meaning. +76. `topologyEnumerateContinuousMap(value, limit=None)` - Enumerate finite members, cases, or derived objects for a continuous map. +77. `topologyClassifyContinuousMap(value)` - Classify a continuous map by its standard Topology invariants. +78. `topologyTestEquivalenceContinuousMap(left, right)` - Test whether two continuous map values are equivalent in Topology. +79. `topologyGenerateExampleContinuousMap(size=3)` - Generate a small documented example of a continuous map. +80. `topologyDocumentContinuousMap(value)` - Return a structured explanation of a continuous map and related assumptions. +81. `topologyValidateFiniteCover(value)` - Validate the finite cover representation and domain rules for Topology. +82. `topologyConstructFiniteCover(*args)` - Construct a finite cover from explicit inputs for Topology. +83. `topologyNormalizeFiniteCover(value)` - Normalize a finite cover into the standard Topology representation. +84. `topologyCanonicalizeFiniteCover(value)` - Canonicalize a finite cover so equivalent inputs share one form. +85. `topologyParseFiniteCover(text)` - Parse a text or structured value into a finite cover. +86. `topologyFormatFiniteCover(value)` - Format a finite cover for deterministic user-facing output. +87. `topologyCompareFiniteCover(left, right)` - Compare two finite cover values under the conventions of Topology. +88. `topologyCombineFiniteCover(left, right)` - Combine two finite cover values with the natural operation for Topology. +89. `topologyDecomposeFiniteCover(value)` - Decompose a finite cover into simpler or canonical components. +90. `topologyEvaluateFiniteCover(value, point=None)` - Evaluate a finite cover at a point, sample, or finite model. +91. `topologyComputeFiniteCover(value)` - Compute the central numerical or symbolic data of a finite cover. +92. `topologyEstimateFiniteCover(value, samples=None)` - Estimate a finite cover property from finite samples or approximations. +93. `topologyApproximateFiniteCover(value, tolerance=1e-9)` - Approximate a finite cover with explicit tolerance controls. +94. `topologyTransformFiniteCover(value, mapping)` - Transform a finite cover through a map, operator, or representation change. +95. `topologySimplifyFiniteCover(value)` - Simplify a finite cover without changing its mathematical meaning. +96. `topologyEnumerateFiniteCover(value, limit=None)` - Enumerate finite members, cases, or derived objects for a finite cover. +97. `topologyClassifyFiniteCover(value)` - Classify a finite cover by its standard Topology invariants. +98. `topologyTestEquivalenceFiniteCover(left, right)` - Test whether two finite cover values are equivalent in Topology. +99. `topologyGenerateExampleFiniteCover(size=3)` - Generate a small documented example of a finite cover. +100. `topologyDocumentFiniteCover(value)` - Return a structured explanation of a finite cover and related assumptions. + +### Polynomials + +Core object families: + +- polynomial +- coefficient list +- root set +- factorization +- polynomial quotient + +Candidate functions: + +1. `polynomialsValidatePolynomial(value)` - Validate the polynomial representation and domain rules for Polynomials. +2. `polynomialsConstructPolynomial(*args)` - Construct a polynomial from explicit inputs for Polynomials. +3. `polynomialsNormalizePolynomial(value)` - Normalize a polynomial into the standard Polynomials representation. +4. `polynomialsCanonicalizePolynomial(value)` - Canonicalize a polynomial so equivalent inputs share one form. +5. `polynomialsParsePolynomial(text)` - Parse a text or structured value into a polynomial. +6. `polynomialsFormatPolynomial(value)` - Format a polynomial for deterministic user-facing output. +7. `polynomialsComparePolynomial(left, right)` - Compare two polynomial values under the conventions of Polynomials. +8. `polynomialsCombinePolynomial(left, right)` - Combine two polynomial values with the natural operation for Polynomials. +9. `polynomialsDecomposePolynomial(value)` - Decompose a polynomial into simpler or canonical components. +10. `polynomialsEvaluatePolynomial(value, point=None)` - Evaluate a polynomial at a point, sample, or finite model. +11. `polynomialsComputePolynomial(value)` - Compute the central numerical or symbolic data of a polynomial. +12. `polynomialsEstimatePolynomial(value, samples=None)` - Estimate a polynomial property from finite samples or approximations. +13. `polynomialsApproximatePolynomial(value, tolerance=1e-9)` - Approximate a polynomial with explicit tolerance controls. +14. `polynomialsTransformPolynomial(value, mapping)` - Transform a polynomial through a map, operator, or representation change. +15. `polynomialsSimplifyPolynomial(value)` - Simplify a polynomial without changing its mathematical meaning. +16. `polynomialsEnumeratePolynomial(value, limit=None)` - Enumerate finite members, cases, or derived objects for a polynomial. +17. `polynomialsClassifyPolynomial(value)` - Classify a polynomial by its standard Polynomials invariants. +18. `polynomialsTestEquivalencePolynomial(left, right)` - Test whether two polynomial values are equivalent in Polynomials. +19. `polynomialsGenerateExamplePolynomial(size=3)` - Generate a small documented example of a polynomial. +20. `polynomialsDocumentPolynomial(value)` - Return a structured explanation of a polynomial and related assumptions. +21. `polynomialsValidateCoefficientList(value)` - Validate the coefficient list representation and domain rules for Polynomials. +22. `polynomialsConstructCoefficientList(*args)` - Construct a coefficient list from explicit inputs for Polynomials. +23. `polynomialsNormalizeCoefficientList(value)` - Normalize a coefficient list into the standard Polynomials representation. +24. `polynomialsCanonicalizeCoefficientList(value)` - Canonicalize a coefficient list so equivalent inputs share one form. +25. `polynomialsParseCoefficientList(text)` - Parse a text or structured value into a coefficient list. +26. `polynomialsFormatCoefficientList(value)` - Format a coefficient list for deterministic user-facing output. +27. `polynomialsCompareCoefficientList(left, right)` - Compare two coefficient list values under the conventions of Polynomials. +28. `polynomialsCombineCoefficientList(left, right)` - Combine two coefficient list values with the natural operation for Polynomials. +29. `polynomialsDecomposeCoefficientList(value)` - Decompose a coefficient list into simpler or canonical components. +30. `polynomialsEvaluateCoefficientList(value, point=None)` - Evaluate a coefficient list at a point, sample, or finite model. +31. `polynomialsComputeCoefficientList(value)` - Compute the central numerical or symbolic data of a coefficient list. +32. `polynomialsEstimateCoefficientList(value, samples=None)` - Estimate a coefficient list property from finite samples or approximations. +33. `polynomialsApproximateCoefficientList(value, tolerance=1e-9)` - Approximate a coefficient list with explicit tolerance controls. +34. `polynomialsTransformCoefficientList(value, mapping)` - Transform a coefficient list through a map, operator, or representation change. +35. `polynomialsSimplifyCoefficientList(value)` - Simplify a coefficient list without changing its mathematical meaning. +36. `polynomialsEnumerateCoefficientList(value, limit=None)` - Enumerate finite members, cases, or derived objects for a coefficient list. +37. `polynomialsClassifyCoefficientList(value)` - Classify a coefficient list by its standard Polynomials invariants. +38. `polynomialsTestEquivalenceCoefficientList(left, right)` - Test whether two coefficient list values are equivalent in Polynomials. +39. `polynomialsGenerateExampleCoefficientList(size=3)` - Generate a small documented example of a coefficient list. +40. `polynomialsDocumentCoefficientList(value)` - Return a structured explanation of a coefficient list and related assumptions. +41. `polynomialsValidateRootSet(value)` - Validate the root set representation and domain rules for Polynomials. +42. `polynomialsConstructRootSet(*args)` - Construct a root set from explicit inputs for Polynomials. +43. `polynomialsNormalizeRootSet(value)` - Normalize a root set into the standard Polynomials representation. +44. `polynomialsCanonicalizeRootSet(value)` - Canonicalize a root set so equivalent inputs share one form. +45. `polynomialsParseRootSet(text)` - Parse a text or structured value into a root set. +46. `polynomialsFormatRootSet(value)` - Format a root set for deterministic user-facing output. +47. `polynomialsCompareRootSet(left, right)` - Compare two root set values under the conventions of Polynomials. +48. `polynomialsCombineRootSet(left, right)` - Combine two root set values with the natural operation for Polynomials. +49. `polynomialsDecomposeRootSet(value)` - Decompose a root set into simpler or canonical components. +50. `polynomialsEvaluateRootSet(value, point=None)` - Evaluate a root set at a point, sample, or finite model. +51. `polynomialsComputeRootSet(value)` - Compute the central numerical or symbolic data of a root set. +52. `polynomialsEstimateRootSet(value, samples=None)` - Estimate a root set property from finite samples or approximations. +53. `polynomialsApproximateRootSet(value, tolerance=1e-9)` - Approximate a root set with explicit tolerance controls. +54. `polynomialsTransformRootSet(value, mapping)` - Transform a root set through a map, operator, or representation change. +55. `polynomialsSimplifyRootSet(value)` - Simplify a root set without changing its mathematical meaning. +56. `polynomialsEnumerateRootSet(value, limit=None)` - Enumerate finite members, cases, or derived objects for a root set. +57. `polynomialsClassifyRootSet(value)` - Classify a root set by its standard Polynomials invariants. +58. `polynomialsTestEquivalenceRootSet(left, right)` - Test whether two root set values are equivalent in Polynomials. +59. `polynomialsGenerateExampleRootSet(size=3)` - Generate a small documented example of a root set. +60. `polynomialsDocumentRootSet(value)` - Return a structured explanation of a root set and related assumptions. +61. `polynomialsValidateFactorization(value)` - Validate the factorization representation and domain rules for Polynomials. +62. `polynomialsConstructFactorization(*args)` - Construct a factorization from explicit inputs for Polynomials. +63. `polynomialsNormalizeFactorization(value)` - Normalize a factorization into the standard Polynomials representation. +64. `polynomialsCanonicalizeFactorization(value)` - Canonicalize a factorization so equivalent inputs share one form. +65. `polynomialsParseFactorization(text)` - Parse a text or structured value into a factorization. +66. `polynomialsFormatFactorization(value)` - Format a factorization for deterministic user-facing output. +67. `polynomialsCompareFactorization(left, right)` - Compare two factorization values under the conventions of Polynomials. +68. `polynomialsCombineFactorization(left, right)` - Combine two factorization values with the natural operation for Polynomials. +69. `polynomialsDecomposeFactorization(value)` - Decompose a factorization into simpler or canonical components. +70. `polynomialsEvaluateFactorization(value, point=None)` - Evaluate a factorization at a point, sample, or finite model. +71. `polynomialsComputeFactorization(value)` - Compute the central numerical or symbolic data of a factorization. +72. `polynomialsEstimateFactorization(value, samples=None)` - Estimate a factorization property from finite samples or approximations. +73. `polynomialsApproximateFactorization(value, tolerance=1e-9)` - Approximate a factorization with explicit tolerance controls. +74. `polynomialsTransformFactorization(value, mapping)` - Transform a factorization through a map, operator, or representation change. +75. `polynomialsSimplifyFactorization(value)` - Simplify a factorization without changing its mathematical meaning. +76. `polynomialsEnumerateFactorization(value, limit=None)` - Enumerate finite members, cases, or derived objects for a factorization. +77. `polynomialsClassifyFactorization(value)` - Classify a factorization by its standard Polynomials invariants. +78. `polynomialsTestEquivalenceFactorization(left, right)` - Test whether two factorization values are equivalent in Polynomials. +79. `polynomialsGenerateExampleFactorization(size=3)` - Generate a small documented example of a factorization. +80. `polynomialsDocumentFactorization(value)` - Return a structured explanation of a factorization and related assumptions. +81. `polynomialsValidatePolynomialQuotient(value)` - Validate the polynomial quotient representation and domain rules for Polynomials. +82. `polynomialsConstructPolynomialQuotient(*args)` - Construct a polynomial quotient from explicit inputs for Polynomials. +83. `polynomialsNormalizePolynomialQuotient(value)` - Normalize a polynomial quotient into the standard Polynomials representation. +84. `polynomialsCanonicalizePolynomialQuotient(value)` - Canonicalize a polynomial quotient so equivalent inputs share one form. +85. `polynomialsParsePolynomialQuotient(text)` - Parse a text or structured value into a polynomial quotient. +86. `polynomialsFormatPolynomialQuotient(value)` - Format a polynomial quotient for deterministic user-facing output. +87. `polynomialsComparePolynomialQuotient(left, right)` - Compare two polynomial quotient values under the conventions of Polynomials. +88. `polynomialsCombinePolynomialQuotient(left, right)` - Combine two polynomial quotient values with the natural operation for Polynomials. +89. `polynomialsDecomposePolynomialQuotient(value)` - Decompose a polynomial quotient into simpler or canonical components. +90. `polynomialsEvaluatePolynomialQuotient(value, point=None)` - Evaluate a polynomial quotient at a point, sample, or finite model. +91. `polynomialsComputePolynomialQuotient(value)` - Compute the central numerical or symbolic data of a polynomial quotient. +92. `polynomialsEstimatePolynomialQuotient(value, samples=None)` - Estimate a polynomial quotient property from finite samples or approximations. +93. `polynomialsApproximatePolynomialQuotient(value, tolerance=1e-9)` - Approximate a polynomial quotient with explicit tolerance controls. +94. `polynomialsTransformPolynomialQuotient(value, mapping)` - Transform a polynomial quotient through a map, operator, or representation change. +95. `polynomialsSimplifyPolynomialQuotient(value)` - Simplify a polynomial quotient without changing its mathematical meaning. +96. `polynomialsEnumeratePolynomialQuotient(value, limit=None)` - Enumerate finite members, cases, or derived objects for a polynomial quotient. +97. `polynomialsClassifyPolynomialQuotient(value)` - Classify a polynomial quotient by its standard Polynomials invariants. +98. `polynomialsTestEquivalencePolynomialQuotient(left, right)` - Test whether two polynomial quotient values are equivalent in Polynomials. +99. `polynomialsGenerateExamplePolynomialQuotient(size=3)` - Generate a small documented example of a polynomial quotient. +100. `polynomialsDocumentPolynomialQuotient(value)` - Return a structured explanation of a polynomial quotient and related assumptions. + +### Real Analysis + +Core object families: + +- sequence +- series +- real function +- epsilon delta proof +- bounded set + +Candidate functions: + +1. `realAnalysisValidateSequence(value)` - Validate the sequence representation and domain rules for Real Analysis. +2. `realAnalysisConstructSequence(*args)` - Construct a sequence from explicit inputs for Real Analysis. +3. `realAnalysisNormalizeSequence(value)` - Normalize a sequence into the standard Real Analysis representation. +4. `realAnalysisCanonicalizeSequence(value)` - Canonicalize a sequence so equivalent inputs share one form. +5. `realAnalysisParseSequence(text)` - Parse a text or structured value into a sequence. +6. `realAnalysisFormatSequence(value)` - Format a sequence for deterministic user-facing output. +7. `realAnalysisCompareSequence(left, right)` - Compare two sequence values under the conventions of Real Analysis. +8. `realAnalysisCombineSequence(left, right)` - Combine two sequence values with the natural operation for Real Analysis. +9. `realAnalysisDecomposeSequence(value)` - Decompose a sequence into simpler or canonical components. +10. `realAnalysisEvaluateSequence(value, point=None)` - Evaluate a sequence at a point, sample, or finite model. +11. `realAnalysisComputeSequence(value)` - Compute the central numerical or symbolic data of a sequence. +12. `realAnalysisEstimateSequence(value, samples=None)` - Estimate a sequence property from finite samples or approximations. +13. `realAnalysisApproximateSequence(value, tolerance=1e-9)` - Approximate a sequence with explicit tolerance controls. +14. `realAnalysisTransformSequence(value, mapping)` - Transform a sequence through a map, operator, or representation change. +15. `realAnalysisSimplifySequence(value)` - Simplify a sequence without changing its mathematical meaning. +16. `realAnalysisEnumerateSequence(value, limit=None)` - Enumerate finite members, cases, or derived objects for a sequence. +17. `realAnalysisClassifySequence(value)` - Classify a sequence by its standard Real Analysis invariants. +18. `realAnalysisTestEquivalenceSequence(left, right)` - Test whether two sequence values are equivalent in Real Analysis. +19. `realAnalysisGenerateExampleSequence(size=3)` - Generate a small documented example of a sequence. +20. `realAnalysisDocumentSequence(value)` - Return a structured explanation of a sequence and related assumptions. +21. `realAnalysisValidateSeries(value)` - Validate the series representation and domain rules for Real Analysis. +22. `realAnalysisConstructSeries(*args)` - Construct a series from explicit inputs for Real Analysis. +23. `realAnalysisNormalizeSeries(value)` - Normalize a series into the standard Real Analysis representation. +24. `realAnalysisCanonicalizeSeries(value)` - Canonicalize a series so equivalent inputs share one form. +25. `realAnalysisParseSeries(text)` - Parse a text or structured value into a series. +26. `realAnalysisFormatSeries(value)` - Format a series for deterministic user-facing output. +27. `realAnalysisCompareSeries(left, right)` - Compare two series values under the conventions of Real Analysis. +28. `realAnalysisCombineSeries(left, right)` - Combine two series values with the natural operation for Real Analysis. +29. `realAnalysisDecomposeSeries(value)` - Decompose a series into simpler or canonical components. +30. `realAnalysisEvaluateSeries(value, point=None)` - Evaluate a series at a point, sample, or finite model. +31. `realAnalysisComputeSeries(value)` - Compute the central numerical or symbolic data of a series. +32. `realAnalysisEstimateSeries(value, samples=None)` - Estimate a series property from finite samples or approximations. +33. `realAnalysisApproximateSeries(value, tolerance=1e-9)` - Approximate a series with explicit tolerance controls. +34. `realAnalysisTransformSeries(value, mapping)` - Transform a series through a map, operator, or representation change. +35. `realAnalysisSimplifySeries(value)` - Simplify a series without changing its mathematical meaning. +36. `realAnalysisEnumerateSeries(value, limit=None)` - Enumerate finite members, cases, or derived objects for a series. +37. `realAnalysisClassifySeries(value)` - Classify a series by its standard Real Analysis invariants. +38. `realAnalysisTestEquivalenceSeries(left, right)` - Test whether two series values are equivalent in Real Analysis. +39. `realAnalysisGenerateExampleSeries(size=3)` - Generate a small documented example of a series. +40. `realAnalysisDocumentSeries(value)` - Return a structured explanation of a series and related assumptions. +41. `realAnalysisValidateRealFunction(value)` - Validate the real function representation and domain rules for Real Analysis. +42. `realAnalysisConstructRealFunction(*args)` - Construct a real function from explicit inputs for Real Analysis. +43. `realAnalysisNormalizeRealFunction(value)` - Normalize a real function into the standard Real Analysis representation. +44. `realAnalysisCanonicalizeRealFunction(value)` - Canonicalize a real function so equivalent inputs share one form. +45. `realAnalysisParseRealFunction(text)` - Parse a text or structured value into a real function. +46. `realAnalysisFormatRealFunction(value)` - Format a real function for deterministic user-facing output. +47. `realAnalysisCompareRealFunction(left, right)` - Compare two real function values under the conventions of Real Analysis. +48. `realAnalysisCombineRealFunction(left, right)` - Combine two real function values with the natural operation for Real Analysis. +49. `realAnalysisDecomposeRealFunction(value)` - Decompose a real function into simpler or canonical components. +50. `realAnalysisEvaluateRealFunction(value, point=None)` - Evaluate a real function at a point, sample, or finite model. +51. `realAnalysisComputeRealFunction(value)` - Compute the central numerical or symbolic data of a real function. +52. `realAnalysisEstimateRealFunction(value, samples=None)` - Estimate a real function property from finite samples or approximations. +53. `realAnalysisApproximateRealFunction(value, tolerance=1e-9)` - Approximate a real function with explicit tolerance controls. +54. `realAnalysisTransformRealFunction(value, mapping)` - Transform a real function through a map, operator, or representation change. +55. `realAnalysisSimplifyRealFunction(value)` - Simplify a real function without changing its mathematical meaning. +56. `realAnalysisEnumerateRealFunction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a real function. +57. `realAnalysisClassifyRealFunction(value)` - Classify a real function by its standard Real Analysis invariants. +58. `realAnalysisTestEquivalenceRealFunction(left, right)` - Test whether two real function values are equivalent in Real Analysis. +59. `realAnalysisGenerateExampleRealFunction(size=3)` - Generate a small documented example of a real function. +60. `realAnalysisDocumentRealFunction(value)` - Return a structured explanation of a real function and related assumptions. +61. `realAnalysisValidateEpsilonDeltaProof(value)` - Validate the epsilon delta proof representation and domain rules for Real Analysis. +62. `realAnalysisConstructEpsilonDeltaProof(*args)` - Construct a epsilon delta proof from explicit inputs for Real Analysis. +63. `realAnalysisNormalizeEpsilonDeltaProof(value)` - Normalize a epsilon delta proof into the standard Real Analysis representation. +64. `realAnalysisCanonicalizeEpsilonDeltaProof(value)` - Canonicalize a epsilon delta proof so equivalent inputs share one form. +65. `realAnalysisParseEpsilonDeltaProof(text)` - Parse a text or structured value into a epsilon delta proof. +66. `realAnalysisFormatEpsilonDeltaProof(value)` - Format a epsilon delta proof for deterministic user-facing output. +67. `realAnalysisCompareEpsilonDeltaProof(left, right)` - Compare two epsilon delta proof values under the conventions of Real Analysis. +68. `realAnalysisCombineEpsilonDeltaProof(left, right)` - Combine two epsilon delta proof values with the natural operation for Real Analysis. +69. `realAnalysisDecomposeEpsilonDeltaProof(value)` - Decompose a epsilon delta proof into simpler or canonical components. +70. `realAnalysisEvaluateEpsilonDeltaProof(value, point=None)` - Evaluate a epsilon delta proof at a point, sample, or finite model. +71. `realAnalysisComputeEpsilonDeltaProof(value)` - Compute the central numerical or symbolic data of a epsilon delta proof. +72. `realAnalysisEstimateEpsilonDeltaProof(value, samples=None)` - Estimate a epsilon delta proof property from finite samples or approximations. +73. `realAnalysisApproximateEpsilonDeltaProof(value, tolerance=1e-9)` - Approximate a epsilon delta proof with explicit tolerance controls. +74. `realAnalysisTransformEpsilonDeltaProof(value, mapping)` - Transform a epsilon delta proof through a map, operator, or representation change. +75. `realAnalysisSimplifyEpsilonDeltaProof(value)` - Simplify a epsilon delta proof without changing its mathematical meaning. +76. `realAnalysisEnumerateEpsilonDeltaProof(value, limit=None)` - Enumerate finite members, cases, or derived objects for a epsilon delta proof. +77. `realAnalysisClassifyEpsilonDeltaProof(value)` - Classify a epsilon delta proof by its standard Real Analysis invariants. +78. `realAnalysisTestEquivalenceEpsilonDeltaProof(left, right)` - Test whether two epsilon delta proof values are equivalent in Real Analysis. +79. `realAnalysisGenerateExampleEpsilonDeltaProof(size=3)` - Generate a small documented example of a epsilon delta proof. +80. `realAnalysisDocumentEpsilonDeltaProof(value)` - Return a structured explanation of a epsilon delta proof and related assumptions. +81. `realAnalysisValidateBoundedSet(value)` - Validate the bounded set representation and domain rules for Real Analysis. +82. `realAnalysisConstructBoundedSet(*args)` - Construct a bounded set from explicit inputs for Real Analysis. +83. `realAnalysisNormalizeBoundedSet(value)` - Normalize a bounded set into the standard Real Analysis representation. +84. `realAnalysisCanonicalizeBoundedSet(value)` - Canonicalize a bounded set so equivalent inputs share one form. +85. `realAnalysisParseBoundedSet(text)` - Parse a text or structured value into a bounded set. +86. `realAnalysisFormatBoundedSet(value)` - Format a bounded set for deterministic user-facing output. +87. `realAnalysisCompareBoundedSet(left, right)` - Compare two bounded set values under the conventions of Real Analysis. +88. `realAnalysisCombineBoundedSet(left, right)` - Combine two bounded set values with the natural operation for Real Analysis. +89. `realAnalysisDecomposeBoundedSet(value)` - Decompose a bounded set into simpler or canonical components. +90. `realAnalysisEvaluateBoundedSet(value, point=None)` - Evaluate a bounded set at a point, sample, or finite model. +91. `realAnalysisComputeBoundedSet(value)` - Compute the central numerical or symbolic data of a bounded set. +92. `realAnalysisEstimateBoundedSet(value, samples=None)` - Estimate a bounded set property from finite samples or approximations. +93. `realAnalysisApproximateBoundedSet(value, tolerance=1e-9)` - Approximate a bounded set with explicit tolerance controls. +94. `realAnalysisTransformBoundedSet(value, mapping)` - Transform a bounded set through a map, operator, or representation change. +95. `realAnalysisSimplifyBoundedSet(value)` - Simplify a bounded set without changing its mathematical meaning. +96. `realAnalysisEnumerateBoundedSet(value, limit=None)` - Enumerate finite members, cases, or derived objects for a bounded set. +97. `realAnalysisClassifyBoundedSet(value)` - Classify a bounded set by its standard Real Analysis invariants. +98. `realAnalysisTestEquivalenceBoundedSet(left, right)` - Test whether two bounded set values are equivalent in Real Analysis. +99. `realAnalysisGenerateExampleBoundedSet(size=3)` - Generate a small documented example of a bounded set. +100. `realAnalysisDocumentBoundedSet(value)` - Return a structured explanation of a bounded set and related assumptions. + +### Knot Theory + +Core object families: + +- knot diagram +- crossing +- link diagram +- Reidemeister move +- knot invariant + +Candidate functions: + +1. `knotTheoryValidateKnotDiagram(value)` - Validate the knot diagram representation and domain rules for Knot Theory. +2. `knotTheoryConstructKnotDiagram(*args)` - Construct a knot diagram from explicit inputs for Knot Theory. +3. `knotTheoryNormalizeKnotDiagram(value)` - Normalize a knot diagram into the standard Knot Theory representation. +4. `knotTheoryCanonicalizeKnotDiagram(value)` - Canonicalize a knot diagram so equivalent inputs share one form. +5. `knotTheoryParseKnotDiagram(text)` - Parse a text or structured value into a knot diagram. +6. `knotTheoryFormatKnotDiagram(value)` - Format a knot diagram for deterministic user-facing output. +7. `knotTheoryCompareKnotDiagram(left, right)` - Compare two knot diagram values under the conventions of Knot Theory. +8. `knotTheoryCombineKnotDiagram(left, right)` - Combine two knot diagram values with the natural operation for Knot Theory. +9. `knotTheoryDecomposeKnotDiagram(value)` - Decompose a knot diagram into simpler or canonical components. +10. `knotTheoryEvaluateKnotDiagram(value, point=None)` - Evaluate a knot diagram at a point, sample, or finite model. +11. `knotTheoryComputeKnotDiagram(value)` - Compute the central numerical or symbolic data of a knot diagram. +12. `knotTheoryEstimateKnotDiagram(value, samples=None)` - Estimate a knot diagram property from finite samples or approximations. +13. `knotTheoryApproximateKnotDiagram(value, tolerance=1e-9)` - Approximate a knot diagram with explicit tolerance controls. +14. `knotTheoryTransformKnotDiagram(value, mapping)` - Transform a knot diagram through a map, operator, or representation change. +15. `knotTheorySimplifyKnotDiagram(value)` - Simplify a knot diagram without changing its mathematical meaning. +16. `knotTheoryEnumerateKnotDiagram(value, limit=None)` - Enumerate finite members, cases, or derived objects for a knot diagram. +17. `knotTheoryClassifyKnotDiagram(value)` - Classify a knot diagram by its standard Knot Theory invariants. +18. `knotTheoryTestEquivalenceKnotDiagram(left, right)` - Test whether two knot diagram values are equivalent in Knot Theory. +19. `knotTheoryGenerateExampleKnotDiagram(size=3)` - Generate a small documented example of a knot diagram. +20. `knotTheoryDocumentKnotDiagram(value)` - Return a structured explanation of a knot diagram and related assumptions. +21. `knotTheoryValidateCrossing(value)` - Validate the crossing representation and domain rules for Knot Theory. +22. `knotTheoryConstructCrossing(*args)` - Construct a crossing from explicit inputs for Knot Theory. +23. `knotTheoryNormalizeCrossing(value)` - Normalize a crossing into the standard Knot Theory representation. +24. `knotTheoryCanonicalizeCrossing(value)` - Canonicalize a crossing so equivalent inputs share one form. +25. `knotTheoryParseCrossing(text)` - Parse a text or structured value into a crossing. +26. `knotTheoryFormatCrossing(value)` - Format a crossing for deterministic user-facing output. +27. `knotTheoryCompareCrossing(left, right)` - Compare two crossing values under the conventions of Knot Theory. +28. `knotTheoryCombineCrossing(left, right)` - Combine two crossing values with the natural operation for Knot Theory. +29. `knotTheoryDecomposeCrossing(value)` - Decompose a crossing into simpler or canonical components. +30. `knotTheoryEvaluateCrossing(value, point=None)` - Evaluate a crossing at a point, sample, or finite model. +31. `knotTheoryComputeCrossing(value)` - Compute the central numerical or symbolic data of a crossing. +32. `knotTheoryEstimateCrossing(value, samples=None)` - Estimate a crossing property from finite samples or approximations. +33. `knotTheoryApproximateCrossing(value, tolerance=1e-9)` - Approximate a crossing with explicit tolerance controls. +34. `knotTheoryTransformCrossing(value, mapping)` - Transform a crossing through a map, operator, or representation change. +35. `knotTheorySimplifyCrossing(value)` - Simplify a crossing without changing its mathematical meaning. +36. `knotTheoryEnumerateCrossing(value, limit=None)` - Enumerate finite members, cases, or derived objects for a crossing. +37. `knotTheoryClassifyCrossing(value)` - Classify a crossing by its standard Knot Theory invariants. +38. `knotTheoryTestEquivalenceCrossing(left, right)` - Test whether two crossing values are equivalent in Knot Theory. +39. `knotTheoryGenerateExampleCrossing(size=3)` - Generate a small documented example of a crossing. +40. `knotTheoryDocumentCrossing(value)` - Return a structured explanation of a crossing and related assumptions. +41. `knotTheoryValidateLinkDiagram(value)` - Validate the link diagram representation and domain rules for Knot Theory. +42. `knotTheoryConstructLinkDiagram(*args)` - Construct a link diagram from explicit inputs for Knot Theory. +43. `knotTheoryNormalizeLinkDiagram(value)` - Normalize a link diagram into the standard Knot Theory representation. +44. `knotTheoryCanonicalizeLinkDiagram(value)` - Canonicalize a link diagram so equivalent inputs share one form. +45. `knotTheoryParseLinkDiagram(text)` - Parse a text or structured value into a link diagram. +46. `knotTheoryFormatLinkDiagram(value)` - Format a link diagram for deterministic user-facing output. +47. `knotTheoryCompareLinkDiagram(left, right)` - Compare two link diagram values under the conventions of Knot Theory. +48. `knotTheoryCombineLinkDiagram(left, right)` - Combine two link diagram values with the natural operation for Knot Theory. +49. `knotTheoryDecomposeLinkDiagram(value)` - Decompose a link diagram into simpler or canonical components. +50. `knotTheoryEvaluateLinkDiagram(value, point=None)` - Evaluate a link diagram at a point, sample, or finite model. +51. `knotTheoryComputeLinkDiagram(value)` - Compute the central numerical or symbolic data of a link diagram. +52. `knotTheoryEstimateLinkDiagram(value, samples=None)` - Estimate a link diagram property from finite samples or approximations. +53. `knotTheoryApproximateLinkDiagram(value, tolerance=1e-9)` - Approximate a link diagram with explicit tolerance controls. +54. `knotTheoryTransformLinkDiagram(value, mapping)` - Transform a link diagram through a map, operator, or representation change. +55. `knotTheorySimplifyLinkDiagram(value)` - Simplify a link diagram without changing its mathematical meaning. +56. `knotTheoryEnumerateLinkDiagram(value, limit=None)` - Enumerate finite members, cases, or derived objects for a link diagram. +57. `knotTheoryClassifyLinkDiagram(value)` - Classify a link diagram by its standard Knot Theory invariants. +58. `knotTheoryTestEquivalenceLinkDiagram(left, right)` - Test whether two link diagram values are equivalent in Knot Theory. +59. `knotTheoryGenerateExampleLinkDiagram(size=3)` - Generate a small documented example of a link diagram. +60. `knotTheoryDocumentLinkDiagram(value)` - Return a structured explanation of a link diagram and related assumptions. +61. `knotTheoryValidateReidemeisterMove(value)` - Validate the Reidemeister move representation and domain rules for Knot Theory. +62. `knotTheoryConstructReidemeisterMove(*args)` - Construct a Reidemeister move from explicit inputs for Knot Theory. +63. `knotTheoryNormalizeReidemeisterMove(value)` - Normalize a Reidemeister move into the standard Knot Theory representation. +64. `knotTheoryCanonicalizeReidemeisterMove(value)` - Canonicalize a Reidemeister move so equivalent inputs share one form. +65. `knotTheoryParseReidemeisterMove(text)` - Parse a text or structured value into a Reidemeister move. +66. `knotTheoryFormatReidemeisterMove(value)` - Format a Reidemeister move for deterministic user-facing output. +67. `knotTheoryCompareReidemeisterMove(left, right)` - Compare two Reidemeister move values under the conventions of Knot Theory. +68. `knotTheoryCombineReidemeisterMove(left, right)` - Combine two Reidemeister move values with the natural operation for Knot Theory. +69. `knotTheoryDecomposeReidemeisterMove(value)` - Decompose a Reidemeister move into simpler or canonical components. +70. `knotTheoryEvaluateReidemeisterMove(value, point=None)` - Evaluate a Reidemeister move at a point, sample, or finite model. +71. `knotTheoryComputeReidemeisterMove(value)` - Compute the central numerical or symbolic data of a Reidemeister move. +72. `knotTheoryEstimateReidemeisterMove(value, samples=None)` - Estimate a Reidemeister move property from finite samples or approximations. +73. `knotTheoryApproximateReidemeisterMove(value, tolerance=1e-9)` - Approximate a Reidemeister move with explicit tolerance controls. +74. `knotTheoryTransformReidemeisterMove(value, mapping)` - Transform a Reidemeister move through a map, operator, or representation change. +75. `knotTheorySimplifyReidemeisterMove(value)` - Simplify a Reidemeister move without changing its mathematical meaning. +76. `knotTheoryEnumerateReidemeisterMove(value, limit=None)` - Enumerate finite members, cases, or derived objects for a Reidemeister move. +77. `knotTheoryClassifyReidemeisterMove(value)` - Classify a Reidemeister move by its standard Knot Theory invariants. +78. `knotTheoryTestEquivalenceReidemeisterMove(left, right)` - Test whether two Reidemeister move values are equivalent in Knot Theory. +79. `knotTheoryGenerateExampleReidemeisterMove(size=3)` - Generate a small documented example of a Reidemeister move. +80. `knotTheoryDocumentReidemeisterMove(value)` - Return a structured explanation of a Reidemeister move and related assumptions. +81. `knotTheoryValidateKnotInvariant(value)` - Validate the knot invariant representation and domain rules for Knot Theory. +82. `knotTheoryConstructKnotInvariant(*args)` - Construct a knot invariant from explicit inputs for Knot Theory. +83. `knotTheoryNormalizeKnotInvariant(value)` - Normalize a knot invariant into the standard Knot Theory representation. +84. `knotTheoryCanonicalizeKnotInvariant(value)` - Canonicalize a knot invariant so equivalent inputs share one form. +85. `knotTheoryParseKnotInvariant(text)` - Parse a text or structured value into a knot invariant. +86. `knotTheoryFormatKnotInvariant(value)` - Format a knot invariant for deterministic user-facing output. +87. `knotTheoryCompareKnotInvariant(left, right)` - Compare two knot invariant values under the conventions of Knot Theory. +88. `knotTheoryCombineKnotInvariant(left, right)` - Combine two knot invariant values with the natural operation for Knot Theory. +89. `knotTheoryDecomposeKnotInvariant(value)` - Decompose a knot invariant into simpler or canonical components. +90. `knotTheoryEvaluateKnotInvariant(value, point=None)` - Evaluate a knot invariant at a point, sample, or finite model. +91. `knotTheoryComputeKnotInvariant(value)` - Compute the central numerical or symbolic data of a knot invariant. +92. `knotTheoryEstimateKnotInvariant(value, samples=None)` - Estimate a knot invariant property from finite samples or approximations. +93. `knotTheoryApproximateKnotInvariant(value, tolerance=1e-9)` - Approximate a knot invariant with explicit tolerance controls. +94. `knotTheoryTransformKnotInvariant(value, mapping)` - Transform a knot invariant through a map, operator, or representation change. +95. `knotTheorySimplifyKnotInvariant(value)` - Simplify a knot invariant without changing its mathematical meaning. +96. `knotTheoryEnumerateKnotInvariant(value, limit=None)` - Enumerate finite members, cases, or derived objects for a knot invariant. +97. `knotTheoryClassifyKnotInvariant(value)` - Classify a knot invariant by its standard Knot Theory invariants. +98. `knotTheoryTestEquivalenceKnotInvariant(left, right)` - Test whether two knot invariant values are equivalent in Knot Theory. +99. `knotTheoryGenerateExampleKnotInvariant(size=3)` - Generate a small documented example of a knot invariant. +100. `knotTheoryDocumentKnotInvariant(value)` - Return a structured explanation of a knot invariant and related assumptions. + +### Type Theory + +Core object families: + +- type expression +- term +- context +- lambda expression +- typing judgment + +Candidate functions: + +1. `typeTheoryValidateTypeExpression(value)` - Validate the type expression representation and domain rules for Type Theory. +2. `typeTheoryConstructTypeExpression(*args)` - Construct a type expression from explicit inputs for Type Theory. +3. `typeTheoryNormalizeTypeExpression(value)` - Normalize a type expression into the standard Type Theory representation. +4. `typeTheoryCanonicalizeTypeExpression(value)` - Canonicalize a type expression so equivalent inputs share one form. +5. `typeTheoryParseTypeExpression(text)` - Parse a text or structured value into a type expression. +6. `typeTheoryFormatTypeExpression(value)` - Format a type expression for deterministic user-facing output. +7. `typeTheoryCompareTypeExpression(left, right)` - Compare two type expression values under the conventions of Type Theory. +8. `typeTheoryCombineTypeExpression(left, right)` - Combine two type expression values with the natural operation for Type Theory. +9. `typeTheoryDecomposeTypeExpression(value)` - Decompose a type expression into simpler or canonical components. +10. `typeTheoryEvaluateTypeExpression(value, point=None)` - Evaluate a type expression at a point, sample, or finite model. +11. `typeTheoryComputeTypeExpression(value)` - Compute the central numerical or symbolic data of a type expression. +12. `typeTheoryEstimateTypeExpression(value, samples=None)` - Estimate a type expression property from finite samples or approximations. +13. `typeTheoryApproximateTypeExpression(value, tolerance=1e-9)` - Approximate a type expression with explicit tolerance controls. +14. `typeTheoryTransformTypeExpression(value, mapping)` - Transform a type expression through a map, operator, or representation change. +15. `typeTheorySimplifyTypeExpression(value)` - Simplify a type expression without changing its mathematical meaning. +16. `typeTheoryEnumerateTypeExpression(value, limit=None)` - Enumerate finite members, cases, or derived objects for a type expression. +17. `typeTheoryClassifyTypeExpression(value)` - Classify a type expression by its standard Type Theory invariants. +18. `typeTheoryTestEquivalenceTypeExpression(left, right)` - Test whether two type expression values are equivalent in Type Theory. +19. `typeTheoryGenerateExampleTypeExpression(size=3)` - Generate a small documented example of a type expression. +20. `typeTheoryDocumentTypeExpression(value)` - Return a structured explanation of a type expression and related assumptions. +21. `typeTheoryValidateTerm(value)` - Validate the term representation and domain rules for Type Theory. +22. `typeTheoryConstructTerm(*args)` - Construct a term from explicit inputs for Type Theory. +23. `typeTheoryNormalizeTerm(value)` - Normalize a term into the standard Type Theory representation. +24. `typeTheoryCanonicalizeTerm(value)` - Canonicalize a term so equivalent inputs share one form. +25. `typeTheoryParseTerm(text)` - Parse a text or structured value into a term. +26. `typeTheoryFormatTerm(value)` - Format a term for deterministic user-facing output. +27. `typeTheoryCompareTerm(left, right)` - Compare two term values under the conventions of Type Theory. +28. `typeTheoryCombineTerm(left, right)` - Combine two term values with the natural operation for Type Theory. +29. `typeTheoryDecomposeTerm(value)` - Decompose a term into simpler or canonical components. +30. `typeTheoryEvaluateTerm(value, point=None)` - Evaluate a term at a point, sample, or finite model. +31. `typeTheoryComputeTerm(value)` - Compute the central numerical or symbolic data of a term. +32. `typeTheoryEstimateTerm(value, samples=None)` - Estimate a term property from finite samples or approximations. +33. `typeTheoryApproximateTerm(value, tolerance=1e-9)` - Approximate a term with explicit tolerance controls. +34. `typeTheoryTransformTerm(value, mapping)` - Transform a term through a map, operator, or representation change. +35. `typeTheorySimplifyTerm(value)` - Simplify a term without changing its mathematical meaning. +36. `typeTheoryEnumerateTerm(value, limit=None)` - Enumerate finite members, cases, or derived objects for a term. +37. `typeTheoryClassifyTerm(value)` - Classify a term by its standard Type Theory invariants. +38. `typeTheoryTestEquivalenceTerm(left, right)` - Test whether two term values are equivalent in Type Theory. +39. `typeTheoryGenerateExampleTerm(size=3)` - Generate a small documented example of a term. +40. `typeTheoryDocumentTerm(value)` - Return a structured explanation of a term and related assumptions. +41. `typeTheoryValidateContext(value)` - Validate the context representation and domain rules for Type Theory. +42. `typeTheoryConstructContext(*args)` - Construct a context from explicit inputs for Type Theory. +43. `typeTheoryNormalizeContext(value)` - Normalize a context into the standard Type Theory representation. +44. `typeTheoryCanonicalizeContext(value)` - Canonicalize a context so equivalent inputs share one form. +45. `typeTheoryParseContext(text)` - Parse a text or structured value into a context. +46. `typeTheoryFormatContext(value)` - Format a context for deterministic user-facing output. +47. `typeTheoryCompareContext(left, right)` - Compare two context values under the conventions of Type Theory. +48. `typeTheoryCombineContext(left, right)` - Combine two context values with the natural operation for Type Theory. +49. `typeTheoryDecomposeContext(value)` - Decompose a context into simpler or canonical components. +50. `typeTheoryEvaluateContext(value, point=None)` - Evaluate a context at a point, sample, or finite model. +51. `typeTheoryComputeContext(value)` - Compute the central numerical or symbolic data of a context. +52. `typeTheoryEstimateContext(value, samples=None)` - Estimate a context property from finite samples or approximations. +53. `typeTheoryApproximateContext(value, tolerance=1e-9)` - Approximate a context with explicit tolerance controls. +54. `typeTheoryTransformContext(value, mapping)` - Transform a context through a map, operator, or representation change. +55. `typeTheorySimplifyContext(value)` - Simplify a context without changing its mathematical meaning. +56. `typeTheoryEnumerateContext(value, limit=None)` - Enumerate finite members, cases, or derived objects for a context. +57. `typeTheoryClassifyContext(value)` - Classify a context by its standard Type Theory invariants. +58. `typeTheoryTestEquivalenceContext(left, right)` - Test whether two context values are equivalent in Type Theory. +59. `typeTheoryGenerateExampleContext(size=3)` - Generate a small documented example of a context. +60. `typeTheoryDocumentContext(value)` - Return a structured explanation of a context and related assumptions. +61. `typeTheoryValidateLambdaExpression(value)` - Validate the lambda expression representation and domain rules for Type Theory. +62. `typeTheoryConstructLambdaExpression(*args)` - Construct a lambda expression from explicit inputs for Type Theory. +63. `typeTheoryNormalizeLambdaExpression(value)` - Normalize a lambda expression into the standard Type Theory representation. +64. `typeTheoryCanonicalizeLambdaExpression(value)` - Canonicalize a lambda expression so equivalent inputs share one form. +65. `typeTheoryParseLambdaExpression(text)` - Parse a text or structured value into a lambda expression. +66. `typeTheoryFormatLambdaExpression(value)` - Format a lambda expression for deterministic user-facing output. +67. `typeTheoryCompareLambdaExpression(left, right)` - Compare two lambda expression values under the conventions of Type Theory. +68. `typeTheoryCombineLambdaExpression(left, right)` - Combine two lambda expression values with the natural operation for Type Theory. +69. `typeTheoryDecomposeLambdaExpression(value)` - Decompose a lambda expression into simpler or canonical components. +70. `typeTheoryEvaluateLambdaExpression(value, point=None)` - Evaluate a lambda expression at a point, sample, or finite model. +71. `typeTheoryComputeLambdaExpression(value)` - Compute the central numerical or symbolic data of a lambda expression. +72. `typeTheoryEstimateLambdaExpression(value, samples=None)` - Estimate a lambda expression property from finite samples or approximations. +73. `typeTheoryApproximateLambdaExpression(value, tolerance=1e-9)` - Approximate a lambda expression with explicit tolerance controls. +74. `typeTheoryTransformLambdaExpression(value, mapping)` - Transform a lambda expression through a map, operator, or representation change. +75. `typeTheorySimplifyLambdaExpression(value)` - Simplify a lambda expression without changing its mathematical meaning. +76. `typeTheoryEnumerateLambdaExpression(value, limit=None)` - Enumerate finite members, cases, or derived objects for a lambda expression. +77. `typeTheoryClassifyLambdaExpression(value)` - Classify a lambda expression by its standard Type Theory invariants. +78. `typeTheoryTestEquivalenceLambdaExpression(left, right)` - Test whether two lambda expression values are equivalent in Type Theory. +79. `typeTheoryGenerateExampleLambdaExpression(size=3)` - Generate a small documented example of a lambda expression. +80. `typeTheoryDocumentLambdaExpression(value)` - Return a structured explanation of a lambda expression and related assumptions. +81. `typeTheoryValidateTypingJudgment(value)` - Validate the typing judgment representation and domain rules for Type Theory. +82. `typeTheoryConstructTypingJudgment(*args)` - Construct a typing judgment from explicit inputs for Type Theory. +83. `typeTheoryNormalizeTypingJudgment(value)` - Normalize a typing judgment into the standard Type Theory representation. +84. `typeTheoryCanonicalizeTypingJudgment(value)` - Canonicalize a typing judgment so equivalent inputs share one form. +85. `typeTheoryParseTypingJudgment(text)` - Parse a text or structured value into a typing judgment. +86. `typeTheoryFormatTypingJudgment(value)` - Format a typing judgment for deterministic user-facing output. +87. `typeTheoryCompareTypingJudgment(left, right)` - Compare two typing judgment values under the conventions of Type Theory. +88. `typeTheoryCombineTypingJudgment(left, right)` - Combine two typing judgment values with the natural operation for Type Theory. +89. `typeTheoryDecomposeTypingJudgment(value)` - Decompose a typing judgment into simpler or canonical components. +90. `typeTheoryEvaluateTypingJudgment(value, point=None)` - Evaluate a typing judgment at a point, sample, or finite model. +91. `typeTheoryComputeTypingJudgment(value)` - Compute the central numerical or symbolic data of a typing judgment. +92. `typeTheoryEstimateTypingJudgment(value, samples=None)` - Estimate a typing judgment property from finite samples or approximations. +93. `typeTheoryApproximateTypingJudgment(value, tolerance=1e-9)` - Approximate a typing judgment with explicit tolerance controls. +94. `typeTheoryTransformTypingJudgment(value, mapping)` - Transform a typing judgment through a map, operator, or representation change. +95. `typeTheorySimplifyTypingJudgment(value)` - Simplify a typing judgment without changing its mathematical meaning. +96. `typeTheoryEnumerateTypingJudgment(value, limit=None)` - Enumerate finite members, cases, or derived objects for a typing judgment. +97. `typeTheoryClassifyTypingJudgment(value)` - Classify a typing judgment by its standard Type Theory invariants. +98. `typeTheoryTestEquivalenceTypingJudgment(left, right)` - Test whether two typing judgment values are equivalent in Type Theory. +99. `typeTheoryGenerateExampleTypingJudgment(size=3)` - Generate a small documented example of a typing judgment. +100. `typeTheoryDocumentTypingJudgment(value)` - Return a structured explanation of a typing judgment and related assumptions. + +### Homotopy Theory + +Core object families: + +- path +- homotopy +- simplicial complex +- loop space +- homotopy invariant + +Candidate functions: + +1. `homotopyTheoryValidatePath(value)` - Validate the path representation and domain rules for Homotopy Theory. +2. `homotopyTheoryConstructPath(*args)` - Construct a path from explicit inputs for Homotopy Theory. +3. `homotopyTheoryNormalizePath(value)` - Normalize a path into the standard Homotopy Theory representation. +4. `homotopyTheoryCanonicalizePath(value)` - Canonicalize a path so equivalent inputs share one form. +5. `homotopyTheoryParsePath(text)` - Parse a text or structured value into a path. +6. `homotopyTheoryFormatPath(value)` - Format a path for deterministic user-facing output. +7. `homotopyTheoryComparePath(left, right)` - Compare two path values under the conventions of Homotopy Theory. +8. `homotopyTheoryCombinePath(left, right)` - Combine two path values with the natural operation for Homotopy Theory. +9. `homotopyTheoryDecomposePath(value)` - Decompose a path into simpler or canonical components. +10. `homotopyTheoryEvaluatePath(value, point=None)` - Evaluate a path at a point, sample, or finite model. +11. `homotopyTheoryComputePath(value)` - Compute the central numerical or symbolic data of a path. +12. `homotopyTheoryEstimatePath(value, samples=None)` - Estimate a path property from finite samples or approximations. +13. `homotopyTheoryApproximatePath(value, tolerance=1e-9)` - Approximate a path with explicit tolerance controls. +14. `homotopyTheoryTransformPath(value, mapping)` - Transform a path through a map, operator, or representation change. +15. `homotopyTheorySimplifyPath(value)` - Simplify a path without changing its mathematical meaning. +16. `homotopyTheoryEnumeratePath(value, limit=None)` - Enumerate finite members, cases, or derived objects for a path. +17. `homotopyTheoryClassifyPath(value)` - Classify a path by its standard Homotopy Theory invariants. +18. `homotopyTheoryTestEquivalencePath(left, right)` - Test whether two path values are equivalent in Homotopy Theory. +19. `homotopyTheoryGenerateExamplePath(size=3)` - Generate a small documented example of a path. +20. `homotopyTheoryDocumentPath(value)` - Return a structured explanation of a path and related assumptions. +21. `homotopyTheoryValidateHomotopy(value)` - Validate the homotopy representation and domain rules for Homotopy Theory. +22. `homotopyTheoryConstructHomotopy(*args)` - Construct a homotopy from explicit inputs for Homotopy Theory. +23. `homotopyTheoryNormalizeHomotopy(value)` - Normalize a homotopy into the standard Homotopy Theory representation. +24. `homotopyTheoryCanonicalizeHomotopy(value)` - Canonicalize a homotopy so equivalent inputs share one form. +25. `homotopyTheoryParseHomotopy(text)` - Parse a text or structured value into a homotopy. +26. `homotopyTheoryFormatHomotopy(value)` - Format a homotopy for deterministic user-facing output. +27. `homotopyTheoryCompareHomotopy(left, right)` - Compare two homotopy values under the conventions of Homotopy Theory. +28. `homotopyTheoryCombineHomotopy(left, right)` - Combine two homotopy values with the natural operation for Homotopy Theory. +29. `homotopyTheoryDecomposeHomotopy(value)` - Decompose a homotopy into simpler or canonical components. +30. `homotopyTheoryEvaluateHomotopy(value, point=None)` - Evaluate a homotopy at a point, sample, or finite model. +31. `homotopyTheoryComputeHomotopy(value)` - Compute the central numerical or symbolic data of a homotopy. +32. `homotopyTheoryEstimateHomotopy(value, samples=None)` - Estimate a homotopy property from finite samples or approximations. +33. `homotopyTheoryApproximateHomotopy(value, tolerance=1e-9)` - Approximate a homotopy with explicit tolerance controls. +34. `homotopyTheoryTransformHomotopy(value, mapping)` - Transform a homotopy through a map, operator, or representation change. +35. `homotopyTheorySimplifyHomotopy(value)` - Simplify a homotopy without changing its mathematical meaning. +36. `homotopyTheoryEnumerateHomotopy(value, limit=None)` - Enumerate finite members, cases, or derived objects for a homotopy. +37. `homotopyTheoryClassifyHomotopy(value)` - Classify a homotopy by its standard Homotopy Theory invariants. +38. `homotopyTheoryTestEquivalenceHomotopy(left, right)` - Test whether two homotopy values are equivalent in Homotopy Theory. +39. `homotopyTheoryGenerateExampleHomotopy(size=3)` - Generate a small documented example of a homotopy. +40. `homotopyTheoryDocumentHomotopy(value)` - Return a structured explanation of a homotopy and related assumptions. +41. `homotopyTheoryValidateSimplicialComplex(value)` - Validate the simplicial complex representation and domain rules for Homotopy Theory. +42. `homotopyTheoryConstructSimplicialComplex(*args)` - Construct a simplicial complex from explicit inputs for Homotopy Theory. +43. `homotopyTheoryNormalizeSimplicialComplex(value)` - Normalize a simplicial complex into the standard Homotopy Theory representation. +44. `homotopyTheoryCanonicalizeSimplicialComplex(value)` - Canonicalize a simplicial complex so equivalent inputs share one form. +45. `homotopyTheoryParseSimplicialComplex(text)` - Parse a text or structured value into a simplicial complex. +46. `homotopyTheoryFormatSimplicialComplex(value)` - Format a simplicial complex for deterministic user-facing output. +47. `homotopyTheoryCompareSimplicialComplex(left, right)` - Compare two simplicial complex values under the conventions of Homotopy Theory. +48. `homotopyTheoryCombineSimplicialComplex(left, right)` - Combine two simplicial complex values with the natural operation for Homotopy Theory. +49. `homotopyTheoryDecomposeSimplicialComplex(value)` - Decompose a simplicial complex into simpler or canonical components. +50. `homotopyTheoryEvaluateSimplicialComplex(value, point=None)` - Evaluate a simplicial complex at a point, sample, or finite model. +51. `homotopyTheoryComputeSimplicialComplex(value)` - Compute the central numerical or symbolic data of a simplicial complex. +52. `homotopyTheoryEstimateSimplicialComplex(value, samples=None)` - Estimate a simplicial complex property from finite samples or approximations. +53. `homotopyTheoryApproximateSimplicialComplex(value, tolerance=1e-9)` - Approximate a simplicial complex with explicit tolerance controls. +54. `homotopyTheoryTransformSimplicialComplex(value, mapping)` - Transform a simplicial complex through a map, operator, or representation change. +55. `homotopyTheorySimplifySimplicialComplex(value)` - Simplify a simplicial complex without changing its mathematical meaning. +56. `homotopyTheoryEnumerateSimplicialComplex(value, limit=None)` - Enumerate finite members, cases, or derived objects for a simplicial complex. +57. `homotopyTheoryClassifySimplicialComplex(value)` - Classify a simplicial complex by its standard Homotopy Theory invariants. +58. `homotopyTheoryTestEquivalenceSimplicialComplex(left, right)` - Test whether two simplicial complex values are equivalent in Homotopy Theory. +59. `homotopyTheoryGenerateExampleSimplicialComplex(size=3)` - Generate a small documented example of a simplicial complex. +60. `homotopyTheoryDocumentSimplicialComplex(value)` - Return a structured explanation of a simplicial complex and related assumptions. +61. `homotopyTheoryValidateLoopSpace(value)` - Validate the loop space representation and domain rules for Homotopy Theory. +62. `homotopyTheoryConstructLoopSpace(*args)` - Construct a loop space from explicit inputs for Homotopy Theory. +63. `homotopyTheoryNormalizeLoopSpace(value)` - Normalize a loop space into the standard Homotopy Theory representation. +64. `homotopyTheoryCanonicalizeLoopSpace(value)` - Canonicalize a loop space so equivalent inputs share one form. +65. `homotopyTheoryParseLoopSpace(text)` - Parse a text or structured value into a loop space. +66. `homotopyTheoryFormatLoopSpace(value)` - Format a loop space for deterministic user-facing output. +67. `homotopyTheoryCompareLoopSpace(left, right)` - Compare two loop space values under the conventions of Homotopy Theory. +68. `homotopyTheoryCombineLoopSpace(left, right)` - Combine two loop space values with the natural operation for Homotopy Theory. +69. `homotopyTheoryDecomposeLoopSpace(value)` - Decompose a loop space into simpler or canonical components. +70. `homotopyTheoryEvaluateLoopSpace(value, point=None)` - Evaluate a loop space at a point, sample, or finite model. +71. `homotopyTheoryComputeLoopSpace(value)` - Compute the central numerical or symbolic data of a loop space. +72. `homotopyTheoryEstimateLoopSpace(value, samples=None)` - Estimate a loop space property from finite samples or approximations. +73. `homotopyTheoryApproximateLoopSpace(value, tolerance=1e-9)` - Approximate a loop space with explicit tolerance controls. +74. `homotopyTheoryTransformLoopSpace(value, mapping)` - Transform a loop space through a map, operator, or representation change. +75. `homotopyTheorySimplifyLoopSpace(value)` - Simplify a loop space without changing its mathematical meaning. +76. `homotopyTheoryEnumerateLoopSpace(value, limit=None)` - Enumerate finite members, cases, or derived objects for a loop space. +77. `homotopyTheoryClassifyLoopSpace(value)` - Classify a loop space by its standard Homotopy Theory invariants. +78. `homotopyTheoryTestEquivalenceLoopSpace(left, right)` - Test whether two loop space values are equivalent in Homotopy Theory. +79. `homotopyTheoryGenerateExampleLoopSpace(size=3)` - Generate a small documented example of a loop space. +80. `homotopyTheoryDocumentLoopSpace(value)` - Return a structured explanation of a loop space and related assumptions. +81. `homotopyTheoryValidateHomotopyInvariant(value)` - Validate the homotopy invariant representation and domain rules for Homotopy Theory. +82. `homotopyTheoryConstructHomotopyInvariant(*args)` - Construct a homotopy invariant from explicit inputs for Homotopy Theory. +83. `homotopyTheoryNormalizeHomotopyInvariant(value)` - Normalize a homotopy invariant into the standard Homotopy Theory representation. +84. `homotopyTheoryCanonicalizeHomotopyInvariant(value)` - Canonicalize a homotopy invariant so equivalent inputs share one form. +85. `homotopyTheoryParseHomotopyInvariant(text)` - Parse a text or structured value into a homotopy invariant. +86. `homotopyTheoryFormatHomotopyInvariant(value)` - Format a homotopy invariant for deterministic user-facing output. +87. `homotopyTheoryCompareHomotopyInvariant(left, right)` - Compare two homotopy invariant values under the conventions of Homotopy Theory. +88. `homotopyTheoryCombineHomotopyInvariant(left, right)` - Combine two homotopy invariant values with the natural operation for Homotopy Theory. +89. `homotopyTheoryDecomposeHomotopyInvariant(value)` - Decompose a homotopy invariant into simpler or canonical components. +90. `homotopyTheoryEvaluateHomotopyInvariant(value, point=None)` - Evaluate a homotopy invariant at a point, sample, or finite model. +91. `homotopyTheoryComputeHomotopyInvariant(value)` - Compute the central numerical or symbolic data of a homotopy invariant. +92. `homotopyTheoryEstimateHomotopyInvariant(value, samples=None)` - Estimate a homotopy invariant property from finite samples or approximations. +93. `homotopyTheoryApproximateHomotopyInvariant(value, tolerance=1e-9)` - Approximate a homotopy invariant with explicit tolerance controls. +94. `homotopyTheoryTransformHomotopyInvariant(value, mapping)` - Transform a homotopy invariant through a map, operator, or representation change. +95. `homotopyTheorySimplifyHomotopyInvariant(value)` - Simplify a homotopy invariant without changing its mathematical meaning. +96. `homotopyTheoryEnumerateHomotopyInvariant(value, limit=None)` - Enumerate finite members, cases, or derived objects for a homotopy invariant. +97. `homotopyTheoryClassifyHomotopyInvariant(value)` - Classify a homotopy invariant by its standard Homotopy Theory invariants. +98. `homotopyTheoryTestEquivalenceHomotopyInvariant(left, right)` - Test whether two homotopy invariant values are equivalent in Homotopy Theory. +99. `homotopyTheoryGenerateExampleHomotopyInvariant(size=3)` - Generate a small documented example of a homotopy invariant. +100. `homotopyTheoryDocumentHomotopyInvariant(value)` - Return a structured explanation of a homotopy invariant and related assumptions. + +### Abstract Algebra + +Core object families: + +- group +- ring +- field +- module +- homomorphism + +Candidate functions: + +1. `abstractAlgebraValidateGroup(value)` - Validate the group representation and domain rules for Abstract Algebra. +2. `abstractAlgebraConstructGroup(*args)` - Construct a group from explicit inputs for Abstract Algebra. +3. `abstractAlgebraNormalizeGroup(value)` - Normalize a group into the standard Abstract Algebra representation. +4. `abstractAlgebraCanonicalizeGroup(value)` - Canonicalize a group so equivalent inputs share one form. +5. `abstractAlgebraParseGroup(text)` - Parse a text or structured value into a group. +6. `abstractAlgebraFormatGroup(value)` - Format a group for deterministic user-facing output. +7. `abstractAlgebraCompareGroup(left, right)` - Compare two group values under the conventions of Abstract Algebra. +8. `abstractAlgebraCombineGroup(left, right)` - Combine two group values with the natural operation for Abstract Algebra. +9. `abstractAlgebraDecomposeGroup(value)` - Decompose a group into simpler or canonical components. +10. `abstractAlgebraEvaluateGroup(value, point=None)` - Evaluate a group at a point, sample, or finite model. +11. `abstractAlgebraComputeGroup(value)` - Compute the central numerical or symbolic data of a group. +12. `abstractAlgebraEstimateGroup(value, samples=None)` - Estimate a group property from finite samples or approximations. +13. `abstractAlgebraApproximateGroup(value, tolerance=1e-9)` - Approximate a group with explicit tolerance controls. +14. `abstractAlgebraTransformGroup(value, mapping)` - Transform a group through a map, operator, or representation change. +15. `abstractAlgebraSimplifyGroup(value)` - Simplify a group without changing its mathematical meaning. +16. `abstractAlgebraEnumerateGroup(value, limit=None)` - Enumerate finite members, cases, or derived objects for a group. +17. `abstractAlgebraClassifyGroup(value)` - Classify a group by its standard Abstract Algebra invariants. +18. `abstractAlgebraTestEquivalenceGroup(left, right)` - Test whether two group values are equivalent in Abstract Algebra. +19. `abstractAlgebraGenerateExampleGroup(size=3)` - Generate a small documented example of a group. +20. `abstractAlgebraDocumentGroup(value)` - Return a structured explanation of a group and related assumptions. +21. `abstractAlgebraValidateRing(value)` - Validate the ring representation and domain rules for Abstract Algebra. +22. `abstractAlgebraConstructRing(*args)` - Construct a ring from explicit inputs for Abstract Algebra. +23. `abstractAlgebraNormalizeRing(value)` - Normalize a ring into the standard Abstract Algebra representation. +24. `abstractAlgebraCanonicalizeRing(value)` - Canonicalize a ring so equivalent inputs share one form. +25. `abstractAlgebraParseRing(text)` - Parse a text or structured value into a ring. +26. `abstractAlgebraFormatRing(value)` - Format a ring for deterministic user-facing output. +27. `abstractAlgebraCompareRing(left, right)` - Compare two ring values under the conventions of Abstract Algebra. +28. `abstractAlgebraCombineRing(left, right)` - Combine two ring values with the natural operation for Abstract Algebra. +29. `abstractAlgebraDecomposeRing(value)` - Decompose a ring into simpler or canonical components. +30. `abstractAlgebraEvaluateRing(value, point=None)` - Evaluate a ring at a point, sample, or finite model. +31. `abstractAlgebraComputeRing(value)` - Compute the central numerical or symbolic data of a ring. +32. `abstractAlgebraEstimateRing(value, samples=None)` - Estimate a ring property from finite samples or approximations. +33. `abstractAlgebraApproximateRing(value, tolerance=1e-9)` - Approximate a ring with explicit tolerance controls. +34. `abstractAlgebraTransformRing(value, mapping)` - Transform a ring through a map, operator, or representation change. +35. `abstractAlgebraSimplifyRing(value)` - Simplify a ring without changing its mathematical meaning. +36. `abstractAlgebraEnumerateRing(value, limit=None)` - Enumerate finite members, cases, or derived objects for a ring. +37. `abstractAlgebraClassifyRing(value)` - Classify a ring by its standard Abstract Algebra invariants. +38. `abstractAlgebraTestEquivalenceRing(left, right)` - Test whether two ring values are equivalent in Abstract Algebra. +39. `abstractAlgebraGenerateExampleRing(size=3)` - Generate a small documented example of a ring. +40. `abstractAlgebraDocumentRing(value)` - Return a structured explanation of a ring and related assumptions. +41. `abstractAlgebraValidateField(value)` - Validate the field representation and domain rules for Abstract Algebra. +42. `abstractAlgebraConstructField(*args)` - Construct a field from explicit inputs for Abstract Algebra. +43. `abstractAlgebraNormalizeField(value)` - Normalize a field into the standard Abstract Algebra representation. +44. `abstractAlgebraCanonicalizeField(value)` - Canonicalize a field so equivalent inputs share one form. +45. `abstractAlgebraParseField(text)` - Parse a text or structured value into a field. +46. `abstractAlgebraFormatField(value)` - Format a field for deterministic user-facing output. +47. `abstractAlgebraCompareField(left, right)` - Compare two field values under the conventions of Abstract Algebra. +48. `abstractAlgebraCombineField(left, right)` - Combine two field values with the natural operation for Abstract Algebra. +49. `abstractAlgebraDecomposeField(value)` - Decompose a field into simpler or canonical components. +50. `abstractAlgebraEvaluateField(value, point=None)` - Evaluate a field at a point, sample, or finite model. +51. `abstractAlgebraComputeField(value)` - Compute the central numerical or symbolic data of a field. +52. `abstractAlgebraEstimateField(value, samples=None)` - Estimate a field property from finite samples or approximations. +53. `abstractAlgebraApproximateField(value, tolerance=1e-9)` - Approximate a field with explicit tolerance controls. +54. `abstractAlgebraTransformField(value, mapping)` - Transform a field through a map, operator, or representation change. +55. `abstractAlgebraSimplifyField(value)` - Simplify a field without changing its mathematical meaning. +56. `abstractAlgebraEnumerateField(value, limit=None)` - Enumerate finite members, cases, or derived objects for a field. +57. `abstractAlgebraClassifyField(value)` - Classify a field by its standard Abstract Algebra invariants. +58. `abstractAlgebraTestEquivalenceField(left, right)` - Test whether two field values are equivalent in Abstract Algebra. +59. `abstractAlgebraGenerateExampleField(size=3)` - Generate a small documented example of a field. +60. `abstractAlgebraDocumentField(value)` - Return a structured explanation of a field and related assumptions. +61. `abstractAlgebraValidateModule(value)` - Validate the module representation and domain rules for Abstract Algebra. +62. `abstractAlgebraConstructModule(*args)` - Construct a module from explicit inputs for Abstract Algebra. +63. `abstractAlgebraNormalizeModule(value)` - Normalize a module into the standard Abstract Algebra representation. +64. `abstractAlgebraCanonicalizeModule(value)` - Canonicalize a module so equivalent inputs share one form. +65. `abstractAlgebraParseModule(text)` - Parse a text or structured value into a module. +66. `abstractAlgebraFormatModule(value)` - Format a module for deterministic user-facing output. +67. `abstractAlgebraCompareModule(left, right)` - Compare two module values under the conventions of Abstract Algebra. +68. `abstractAlgebraCombineModule(left, right)` - Combine two module values with the natural operation for Abstract Algebra. +69. `abstractAlgebraDecomposeModule(value)` - Decompose a module into simpler or canonical components. +70. `abstractAlgebraEvaluateModule(value, point=None)` - Evaluate a module at a point, sample, or finite model. +71. `abstractAlgebraComputeModule(value)` - Compute the central numerical or symbolic data of a module. +72. `abstractAlgebraEstimateModule(value, samples=None)` - Estimate a module property from finite samples or approximations. +73. `abstractAlgebraApproximateModule(value, tolerance=1e-9)` - Approximate a module with explicit tolerance controls. +74. `abstractAlgebraTransformModule(value, mapping)` - Transform a module through a map, operator, or representation change. +75. `abstractAlgebraSimplifyModule(value)` - Simplify a module without changing its mathematical meaning. +76. `abstractAlgebraEnumerateModule(value, limit=None)` - Enumerate finite members, cases, or derived objects for a module. +77. `abstractAlgebraClassifyModule(value)` - Classify a module by its standard Abstract Algebra invariants. +78. `abstractAlgebraTestEquivalenceModule(left, right)` - Test whether two module values are equivalent in Abstract Algebra. +79. `abstractAlgebraGenerateExampleModule(size=3)` - Generate a small documented example of a module. +80. `abstractAlgebraDocumentModule(value)` - Return a structured explanation of a module and related assumptions. +81. `abstractAlgebraValidateHomomorphism(value)` - Validate the homomorphism representation and domain rules for Abstract Algebra. +82. `abstractAlgebraConstructHomomorphism(*args)` - Construct a homomorphism from explicit inputs for Abstract Algebra. +83. `abstractAlgebraNormalizeHomomorphism(value)` - Normalize a homomorphism into the standard Abstract Algebra representation. +84. `abstractAlgebraCanonicalizeHomomorphism(value)` - Canonicalize a homomorphism so equivalent inputs share one form. +85. `abstractAlgebraParseHomomorphism(text)` - Parse a text or structured value into a homomorphism. +86. `abstractAlgebraFormatHomomorphism(value)` - Format a homomorphism for deterministic user-facing output. +87. `abstractAlgebraCompareHomomorphism(left, right)` - Compare two homomorphism values under the conventions of Abstract Algebra. +88. `abstractAlgebraCombineHomomorphism(left, right)` - Combine two homomorphism values with the natural operation for Abstract Algebra. +89. `abstractAlgebraDecomposeHomomorphism(value)` - Decompose a homomorphism into simpler or canonical components. +90. `abstractAlgebraEvaluateHomomorphism(value, point=None)` - Evaluate a homomorphism at a point, sample, or finite model. +91. `abstractAlgebraComputeHomomorphism(value)` - Compute the central numerical or symbolic data of a homomorphism. +92. `abstractAlgebraEstimateHomomorphism(value, samples=None)` - Estimate a homomorphism property from finite samples or approximations. +93. `abstractAlgebraApproximateHomomorphism(value, tolerance=1e-9)` - Approximate a homomorphism with explicit tolerance controls. +94. `abstractAlgebraTransformHomomorphism(value, mapping)` - Transform a homomorphism through a map, operator, or representation change. +95. `abstractAlgebraSimplifyHomomorphism(value)` - Simplify a homomorphism without changing its mathematical meaning. +96. `abstractAlgebraEnumerateHomomorphism(value, limit=None)` - Enumerate finite members, cases, or derived objects for a homomorphism. +97. `abstractAlgebraClassifyHomomorphism(value)` - Classify a homomorphism by its standard Abstract Algebra invariants. +98. `abstractAlgebraTestEquivalenceHomomorphism(left, right)` - Test whether two homomorphism values are equivalent in Abstract Algebra. +99. `abstractAlgebraGenerateExampleHomomorphism(size=3)` - Generate a small documented example of a homomorphism. +100. `abstractAlgebraDocumentHomomorphism(value)` - Return a structured explanation of a homomorphism and related assumptions. + +### Graph Theory and Discrete Math + +Core object families: + +- graph +- vertex set +- edge set +- walk +- graph invariant + +Candidate functions: + +1. `graphTheoryAndDiscreteMathValidateGraph(value)` - Validate the graph representation and domain rules for Graph Theory and Discrete Math. +2. `graphTheoryAndDiscreteMathConstructGraph(*args)` - Construct a graph from explicit inputs for Graph Theory and Discrete Math. +3. `graphTheoryAndDiscreteMathNormalizeGraph(value)` - Normalize a graph into the standard Graph Theory and Discrete Math representation. +4. `graphTheoryAndDiscreteMathCanonicalizeGraph(value)` - Canonicalize a graph so equivalent inputs share one form. +5. `graphTheoryAndDiscreteMathParseGraph(text)` - Parse a text or structured value into a graph. +6. `graphTheoryAndDiscreteMathFormatGraph(value)` - Format a graph for deterministic user-facing output. +7. `graphTheoryAndDiscreteMathCompareGraph(left, right)` - Compare two graph values under the conventions of Graph Theory and Discrete Math. +8. `graphTheoryAndDiscreteMathCombineGraph(left, right)` - Combine two graph values with the natural operation for Graph Theory and Discrete Math. +9. `graphTheoryAndDiscreteMathDecomposeGraph(value)` - Decompose a graph into simpler or canonical components. +10. `graphTheoryAndDiscreteMathEvaluateGraph(value, point=None)` - Evaluate a graph at a point, sample, or finite model. +11. `graphTheoryAndDiscreteMathComputeGraph(value)` - Compute the central numerical or symbolic data of a graph. +12. `graphTheoryAndDiscreteMathEstimateGraph(value, samples=None)` - Estimate a graph property from finite samples or approximations. +13. `graphTheoryAndDiscreteMathApproximateGraph(value, tolerance=1e-9)` - Approximate a graph with explicit tolerance controls. +14. `graphTheoryAndDiscreteMathTransformGraph(value, mapping)` - Transform a graph through a map, operator, or representation change. +15. `graphTheoryAndDiscreteMathSimplifyGraph(value)` - Simplify a graph without changing its mathematical meaning. +16. `graphTheoryAndDiscreteMathEnumerateGraph(value, limit=None)` - Enumerate finite members, cases, or derived objects for a graph. +17. `graphTheoryAndDiscreteMathClassifyGraph(value)` - Classify a graph by its standard Graph Theory and Discrete Math invariants. +18. `graphTheoryAndDiscreteMathTestEquivalenceGraph(left, right)` - Test whether two graph values are equivalent in Graph Theory and Discrete Math. +19. `graphTheoryAndDiscreteMathGenerateExampleGraph(size=3)` - Generate a small documented example of a graph. +20. `graphTheoryAndDiscreteMathDocumentGraph(value)` - Return a structured explanation of a graph and related assumptions. +21. `graphTheoryAndDiscreteMathValidateVertexSet(value)` - Validate the vertex set representation and domain rules for Graph Theory and Discrete Math. +22. `graphTheoryAndDiscreteMathConstructVertexSet(*args)` - Construct a vertex set from explicit inputs for Graph Theory and Discrete Math. +23. `graphTheoryAndDiscreteMathNormalizeVertexSet(value)` - Normalize a vertex set into the standard Graph Theory and Discrete Math representation. +24. `graphTheoryAndDiscreteMathCanonicalizeVertexSet(value)` - Canonicalize a vertex set so equivalent inputs share one form. +25. `graphTheoryAndDiscreteMathParseVertexSet(text)` - Parse a text or structured value into a vertex set. +26. `graphTheoryAndDiscreteMathFormatVertexSet(value)` - Format a vertex set for deterministic user-facing output. +27. `graphTheoryAndDiscreteMathCompareVertexSet(left, right)` - Compare two vertex set values under the conventions of Graph Theory and Discrete Math. +28. `graphTheoryAndDiscreteMathCombineVertexSet(left, right)` - Combine two vertex set values with the natural operation for Graph Theory and Discrete Math. +29. `graphTheoryAndDiscreteMathDecomposeVertexSet(value)` - Decompose a vertex set into simpler or canonical components. +30. `graphTheoryAndDiscreteMathEvaluateVertexSet(value, point=None)` - Evaluate a vertex set at a point, sample, or finite model. +31. `graphTheoryAndDiscreteMathComputeVertexSet(value)` - Compute the central numerical or symbolic data of a vertex set. +32. `graphTheoryAndDiscreteMathEstimateVertexSet(value, samples=None)` - Estimate a vertex set property from finite samples or approximations. +33. `graphTheoryAndDiscreteMathApproximateVertexSet(value, tolerance=1e-9)` - Approximate a vertex set with explicit tolerance controls. +34. `graphTheoryAndDiscreteMathTransformVertexSet(value, mapping)` - Transform a vertex set through a map, operator, or representation change. +35. `graphTheoryAndDiscreteMathSimplifyVertexSet(value)` - Simplify a vertex set without changing its mathematical meaning. +36. `graphTheoryAndDiscreteMathEnumerateVertexSet(value, limit=None)` - Enumerate finite members, cases, or derived objects for a vertex set. +37. `graphTheoryAndDiscreteMathClassifyVertexSet(value)` - Classify a vertex set by its standard Graph Theory and Discrete Math invariants. +38. `graphTheoryAndDiscreteMathTestEquivalenceVertexSet(left, right)` - Test whether two vertex set values are equivalent in Graph Theory and Discrete Math. +39. `graphTheoryAndDiscreteMathGenerateExampleVertexSet(size=3)` - Generate a small documented example of a vertex set. +40. `graphTheoryAndDiscreteMathDocumentVertexSet(value)` - Return a structured explanation of a vertex set and related assumptions. +41. `graphTheoryAndDiscreteMathValidateEdgeSet(value)` - Validate the edge set representation and domain rules for Graph Theory and Discrete Math. +42. `graphTheoryAndDiscreteMathConstructEdgeSet(*args)` - Construct a edge set from explicit inputs for Graph Theory and Discrete Math. +43. `graphTheoryAndDiscreteMathNormalizeEdgeSet(value)` - Normalize a edge set into the standard Graph Theory and Discrete Math representation. +44. `graphTheoryAndDiscreteMathCanonicalizeEdgeSet(value)` - Canonicalize a edge set so equivalent inputs share one form. +45. `graphTheoryAndDiscreteMathParseEdgeSet(text)` - Parse a text or structured value into a edge set. +46. `graphTheoryAndDiscreteMathFormatEdgeSet(value)` - Format a edge set for deterministic user-facing output. +47. `graphTheoryAndDiscreteMathCompareEdgeSet(left, right)` - Compare two edge set values under the conventions of Graph Theory and Discrete Math. +48. `graphTheoryAndDiscreteMathCombineEdgeSet(left, right)` - Combine two edge set values with the natural operation for Graph Theory and Discrete Math. +49. `graphTheoryAndDiscreteMathDecomposeEdgeSet(value)` - Decompose a edge set into simpler or canonical components. +50. `graphTheoryAndDiscreteMathEvaluateEdgeSet(value, point=None)` - Evaluate a edge set at a point, sample, or finite model. +51. `graphTheoryAndDiscreteMathComputeEdgeSet(value)` - Compute the central numerical or symbolic data of a edge set. +52. `graphTheoryAndDiscreteMathEstimateEdgeSet(value, samples=None)` - Estimate a edge set property from finite samples or approximations. +53. `graphTheoryAndDiscreteMathApproximateEdgeSet(value, tolerance=1e-9)` - Approximate a edge set with explicit tolerance controls. +54. `graphTheoryAndDiscreteMathTransformEdgeSet(value, mapping)` - Transform a edge set through a map, operator, or representation change. +55. `graphTheoryAndDiscreteMathSimplifyEdgeSet(value)` - Simplify a edge set without changing its mathematical meaning. +56. `graphTheoryAndDiscreteMathEnumerateEdgeSet(value, limit=None)` - Enumerate finite members, cases, or derived objects for a edge set. +57. `graphTheoryAndDiscreteMathClassifyEdgeSet(value)` - Classify a edge set by its standard Graph Theory and Discrete Math invariants. +58. `graphTheoryAndDiscreteMathTestEquivalenceEdgeSet(left, right)` - Test whether two edge set values are equivalent in Graph Theory and Discrete Math. +59. `graphTheoryAndDiscreteMathGenerateExampleEdgeSet(size=3)` - Generate a small documented example of a edge set. +60. `graphTheoryAndDiscreteMathDocumentEdgeSet(value)` - Return a structured explanation of a edge set and related assumptions. +61. `graphTheoryAndDiscreteMathValidateWalk(value)` - Validate the walk representation and domain rules for Graph Theory and Discrete Math. +62. `graphTheoryAndDiscreteMathConstructWalk(*args)` - Construct a walk from explicit inputs for Graph Theory and Discrete Math. +63. `graphTheoryAndDiscreteMathNormalizeWalk(value)` - Normalize a walk into the standard Graph Theory and Discrete Math representation. +64. `graphTheoryAndDiscreteMathCanonicalizeWalk(value)` - Canonicalize a walk so equivalent inputs share one form. +65. `graphTheoryAndDiscreteMathParseWalk(text)` - Parse a text or structured value into a walk. +66. `graphTheoryAndDiscreteMathFormatWalk(value)` - Format a walk for deterministic user-facing output. +67. `graphTheoryAndDiscreteMathCompareWalk(left, right)` - Compare two walk values under the conventions of Graph Theory and Discrete Math. +68. `graphTheoryAndDiscreteMathCombineWalk(left, right)` - Combine two walk values with the natural operation for Graph Theory and Discrete Math. +69. `graphTheoryAndDiscreteMathDecomposeWalk(value)` - Decompose a walk into simpler or canonical components. +70. `graphTheoryAndDiscreteMathEvaluateWalk(value, point=None)` - Evaluate a walk at a point, sample, or finite model. +71. `graphTheoryAndDiscreteMathComputeWalk(value)` - Compute the central numerical or symbolic data of a walk. +72. `graphTheoryAndDiscreteMathEstimateWalk(value, samples=None)` - Estimate a walk property from finite samples or approximations. +73. `graphTheoryAndDiscreteMathApproximateWalk(value, tolerance=1e-9)` - Approximate a walk with explicit tolerance controls. +74. `graphTheoryAndDiscreteMathTransformWalk(value, mapping)` - Transform a walk through a map, operator, or representation change. +75. `graphTheoryAndDiscreteMathSimplifyWalk(value)` - Simplify a walk without changing its mathematical meaning. +76. `graphTheoryAndDiscreteMathEnumerateWalk(value, limit=None)` - Enumerate finite members, cases, or derived objects for a walk. +77. `graphTheoryAndDiscreteMathClassifyWalk(value)` - Classify a walk by its standard Graph Theory and Discrete Math invariants. +78. `graphTheoryAndDiscreteMathTestEquivalenceWalk(left, right)` - Test whether two walk values are equivalent in Graph Theory and Discrete Math. +79. `graphTheoryAndDiscreteMathGenerateExampleWalk(size=3)` - Generate a small documented example of a walk. +80. `graphTheoryAndDiscreteMathDocumentWalk(value)` - Return a structured explanation of a walk and related assumptions. +81. `graphTheoryAndDiscreteMathValidateGraphInvariant(value)` - Validate the graph invariant representation and domain rules for Graph Theory and Discrete Math. +82. `graphTheoryAndDiscreteMathConstructGraphInvariant(*args)` - Construct a graph invariant from explicit inputs for Graph Theory and Discrete Math. +83. `graphTheoryAndDiscreteMathNormalizeGraphInvariant(value)` - Normalize a graph invariant into the standard Graph Theory and Discrete Math representation. +84. `graphTheoryAndDiscreteMathCanonicalizeGraphInvariant(value)` - Canonicalize a graph invariant so equivalent inputs share one form. +85. `graphTheoryAndDiscreteMathParseGraphInvariant(text)` - Parse a text or structured value into a graph invariant. +86. `graphTheoryAndDiscreteMathFormatGraphInvariant(value)` - Format a graph invariant for deterministic user-facing output. +87. `graphTheoryAndDiscreteMathCompareGraphInvariant(left, right)` - Compare two graph invariant values under the conventions of Graph Theory and Discrete Math. +88. `graphTheoryAndDiscreteMathCombineGraphInvariant(left, right)` - Combine two graph invariant values with the natural operation for Graph Theory and Discrete Math. +89. `graphTheoryAndDiscreteMathDecomposeGraphInvariant(value)` - Decompose a graph invariant into simpler or canonical components. +90. `graphTheoryAndDiscreteMathEvaluateGraphInvariant(value, point=None)` - Evaluate a graph invariant at a point, sample, or finite model. +91. `graphTheoryAndDiscreteMathComputeGraphInvariant(value)` - Compute the central numerical or symbolic data of a graph invariant. +92. `graphTheoryAndDiscreteMathEstimateGraphInvariant(value, samples=None)` - Estimate a graph invariant property from finite samples or approximations. +93. `graphTheoryAndDiscreteMathApproximateGraphInvariant(value, tolerance=1e-9)` - Approximate a graph invariant with explicit tolerance controls. +94. `graphTheoryAndDiscreteMathTransformGraphInvariant(value, mapping)` - Transform a graph invariant through a map, operator, or representation change. +95. `graphTheoryAndDiscreteMathSimplifyGraphInvariant(value)` - Simplify a graph invariant without changing its mathematical meaning. +96. `graphTheoryAndDiscreteMathEnumerateGraphInvariant(value, limit=None)` - Enumerate finite members, cases, or derived objects for a graph invariant. +97. `graphTheoryAndDiscreteMathClassifyGraphInvariant(value)` - Classify a graph invariant by its standard Graph Theory and Discrete Math invariants. +98. `graphTheoryAndDiscreteMathTestEquivalenceGraphInvariant(left, right)` - Test whether two graph invariant values are equivalent in Graph Theory and Discrete Math. +99. `graphTheoryAndDiscreteMathGenerateExampleGraphInvariant(size=3)` - Generate a small documented example of a graph invariant. +100. `graphTheoryAndDiscreteMathDocumentGraphInvariant(value)` - Return a structured explanation of a graph invariant and related assumptions. + +### Numerical Analysis + +Core object families: + +- root finder +- interpolation model +- quadrature rule +- iterative method +- error estimate + +Candidate functions: + +1. `numericalAnalysisValidateRootFinder(value)` - Validate the root finder representation and domain rules for Numerical Analysis. +2. `numericalAnalysisConstructRootFinder(*args)` - Construct a root finder from explicit inputs for Numerical Analysis. +3. `numericalAnalysisNormalizeRootFinder(value)` - Normalize a root finder into the standard Numerical Analysis representation. +4. `numericalAnalysisCanonicalizeRootFinder(value)` - Canonicalize a root finder so equivalent inputs share one form. +5. `numericalAnalysisParseRootFinder(text)` - Parse a text or structured value into a root finder. +6. `numericalAnalysisFormatRootFinder(value)` - Format a root finder for deterministic user-facing output. +7. `numericalAnalysisCompareRootFinder(left, right)` - Compare two root finder values under the conventions of Numerical Analysis. +8. `numericalAnalysisCombineRootFinder(left, right)` - Combine two root finder values with the natural operation for Numerical Analysis. +9. `numericalAnalysisDecomposeRootFinder(value)` - Decompose a root finder into simpler or canonical components. +10. `numericalAnalysisEvaluateRootFinder(value, point=None)` - Evaluate a root finder at a point, sample, or finite model. +11. `numericalAnalysisComputeRootFinder(value)` - Compute the central numerical or symbolic data of a root finder. +12. `numericalAnalysisEstimateRootFinder(value, samples=None)` - Estimate a root finder property from finite samples or approximations. +13. `numericalAnalysisApproximateRootFinder(value, tolerance=1e-9)` - Approximate a root finder with explicit tolerance controls. +14. `numericalAnalysisTransformRootFinder(value, mapping)` - Transform a root finder through a map, operator, or representation change. +15. `numericalAnalysisSimplifyRootFinder(value)` - Simplify a root finder without changing its mathematical meaning. +16. `numericalAnalysisEnumerateRootFinder(value, limit=None)` - Enumerate finite members, cases, or derived objects for a root finder. +17. `numericalAnalysisClassifyRootFinder(value)` - Classify a root finder by its standard Numerical Analysis invariants. +18. `numericalAnalysisTestEquivalenceRootFinder(left, right)` - Test whether two root finder values are equivalent in Numerical Analysis. +19. `numericalAnalysisGenerateExampleRootFinder(size=3)` - Generate a small documented example of a root finder. +20. `numericalAnalysisDocumentRootFinder(value)` - Return a structured explanation of a root finder and related assumptions. +21. `numericalAnalysisValidateInterpolationModel(value)` - Validate the interpolation model representation and domain rules for Numerical Analysis. +22. `numericalAnalysisConstructInterpolationModel(*args)` - Construct a interpolation model from explicit inputs for Numerical Analysis. +23. `numericalAnalysisNormalizeInterpolationModel(value)` - Normalize a interpolation model into the standard Numerical Analysis representation. +24. `numericalAnalysisCanonicalizeInterpolationModel(value)` - Canonicalize a interpolation model so equivalent inputs share one form. +25. `numericalAnalysisParseInterpolationModel(text)` - Parse a text or structured value into a interpolation model. +26. `numericalAnalysisFormatInterpolationModel(value)` - Format a interpolation model for deterministic user-facing output. +27. `numericalAnalysisCompareInterpolationModel(left, right)` - Compare two interpolation model values under the conventions of Numerical Analysis. +28. `numericalAnalysisCombineInterpolationModel(left, right)` - Combine two interpolation model values with the natural operation for Numerical Analysis. +29. `numericalAnalysisDecomposeInterpolationModel(value)` - Decompose a interpolation model into simpler or canonical components. +30. `numericalAnalysisEvaluateInterpolationModel(value, point=None)` - Evaluate a interpolation model at a point, sample, or finite model. +31. `numericalAnalysisComputeInterpolationModel(value)` - Compute the central numerical or symbolic data of a interpolation model. +32. `numericalAnalysisEstimateInterpolationModel(value, samples=None)` - Estimate a interpolation model property from finite samples or approximations. +33. `numericalAnalysisApproximateInterpolationModel(value, tolerance=1e-9)` - Approximate a interpolation model with explicit tolerance controls. +34. `numericalAnalysisTransformInterpolationModel(value, mapping)` - Transform a interpolation model through a map, operator, or representation change. +35. `numericalAnalysisSimplifyInterpolationModel(value)` - Simplify a interpolation model without changing its mathematical meaning. +36. `numericalAnalysisEnumerateInterpolationModel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a interpolation model. +37. `numericalAnalysisClassifyInterpolationModel(value)` - Classify a interpolation model by its standard Numerical Analysis invariants. +38. `numericalAnalysisTestEquivalenceInterpolationModel(left, right)` - Test whether two interpolation model values are equivalent in Numerical Analysis. +39. `numericalAnalysisGenerateExampleInterpolationModel(size=3)` - Generate a small documented example of a interpolation model. +40. `numericalAnalysisDocumentInterpolationModel(value)` - Return a structured explanation of a interpolation model and related assumptions. +41. `numericalAnalysisValidateQuadratureRule(value)` - Validate the quadrature rule representation and domain rules for Numerical Analysis. +42. `numericalAnalysisConstructQuadratureRule(*args)` - Construct a quadrature rule from explicit inputs for Numerical Analysis. +43. `numericalAnalysisNormalizeQuadratureRule(value)` - Normalize a quadrature rule into the standard Numerical Analysis representation. +44. `numericalAnalysisCanonicalizeQuadratureRule(value)` - Canonicalize a quadrature rule so equivalent inputs share one form. +45. `numericalAnalysisParseQuadratureRule(text)` - Parse a text or structured value into a quadrature rule. +46. `numericalAnalysisFormatQuadratureRule(value)` - Format a quadrature rule for deterministic user-facing output. +47. `numericalAnalysisCompareQuadratureRule(left, right)` - Compare two quadrature rule values under the conventions of Numerical Analysis. +48. `numericalAnalysisCombineQuadratureRule(left, right)` - Combine two quadrature rule values with the natural operation for Numerical Analysis. +49. `numericalAnalysisDecomposeQuadratureRule(value)` - Decompose a quadrature rule into simpler or canonical components. +50. `numericalAnalysisEvaluateQuadratureRule(value, point=None)` - Evaluate a quadrature rule at a point, sample, or finite model. +51. `numericalAnalysisComputeQuadratureRule(value)` - Compute the central numerical or symbolic data of a quadrature rule. +52. `numericalAnalysisEstimateQuadratureRule(value, samples=None)` - Estimate a quadrature rule property from finite samples or approximations. +53. `numericalAnalysisApproximateQuadratureRule(value, tolerance=1e-9)` - Approximate a quadrature rule with explicit tolerance controls. +54. `numericalAnalysisTransformQuadratureRule(value, mapping)` - Transform a quadrature rule through a map, operator, or representation change. +55. `numericalAnalysisSimplifyQuadratureRule(value)` - Simplify a quadrature rule without changing its mathematical meaning. +56. `numericalAnalysisEnumerateQuadratureRule(value, limit=None)` - Enumerate finite members, cases, or derived objects for a quadrature rule. +57. `numericalAnalysisClassifyQuadratureRule(value)` - Classify a quadrature rule by its standard Numerical Analysis invariants. +58. `numericalAnalysisTestEquivalenceQuadratureRule(left, right)` - Test whether two quadrature rule values are equivalent in Numerical Analysis. +59. `numericalAnalysisGenerateExampleQuadratureRule(size=3)` - Generate a small documented example of a quadrature rule. +60. `numericalAnalysisDocumentQuadratureRule(value)` - Return a structured explanation of a quadrature rule and related assumptions. +61. `numericalAnalysisValidateIterativeMethod(value)` - Validate the iterative method representation and domain rules for Numerical Analysis. +62. `numericalAnalysisConstructIterativeMethod(*args)` - Construct a iterative method from explicit inputs for Numerical Analysis. +63. `numericalAnalysisNormalizeIterativeMethod(value)` - Normalize a iterative method into the standard Numerical Analysis representation. +64. `numericalAnalysisCanonicalizeIterativeMethod(value)` - Canonicalize a iterative method so equivalent inputs share one form. +65. `numericalAnalysisParseIterativeMethod(text)` - Parse a text or structured value into a iterative method. +66. `numericalAnalysisFormatIterativeMethod(value)` - Format a iterative method for deterministic user-facing output. +67. `numericalAnalysisCompareIterativeMethod(left, right)` - Compare two iterative method values under the conventions of Numerical Analysis. +68. `numericalAnalysisCombineIterativeMethod(left, right)` - Combine two iterative method values with the natural operation for Numerical Analysis. +69. `numericalAnalysisDecomposeIterativeMethod(value)` - Decompose a iterative method into simpler or canonical components. +70. `numericalAnalysisEvaluateIterativeMethod(value, point=None)` - Evaluate a iterative method at a point, sample, or finite model. +71. `numericalAnalysisComputeIterativeMethod(value)` - Compute the central numerical or symbolic data of a iterative method. +72. `numericalAnalysisEstimateIterativeMethod(value, samples=None)` - Estimate a iterative method property from finite samples or approximations. +73. `numericalAnalysisApproximateIterativeMethod(value, tolerance=1e-9)` - Approximate a iterative method with explicit tolerance controls. +74. `numericalAnalysisTransformIterativeMethod(value, mapping)` - Transform a iterative method through a map, operator, or representation change. +75. `numericalAnalysisSimplifyIterativeMethod(value)` - Simplify a iterative method without changing its mathematical meaning. +76. `numericalAnalysisEnumerateIterativeMethod(value, limit=None)` - Enumerate finite members, cases, or derived objects for a iterative method. +77. `numericalAnalysisClassifyIterativeMethod(value)` - Classify a iterative method by its standard Numerical Analysis invariants. +78. `numericalAnalysisTestEquivalenceIterativeMethod(left, right)` - Test whether two iterative method values are equivalent in Numerical Analysis. +79. `numericalAnalysisGenerateExampleIterativeMethod(size=3)` - Generate a small documented example of a iterative method. +80. `numericalAnalysisDocumentIterativeMethod(value)` - Return a structured explanation of a iterative method and related assumptions. +81. `numericalAnalysisValidateErrorEstimate(value)` - Validate the error estimate representation and domain rules for Numerical Analysis. +82. `numericalAnalysisConstructErrorEstimate(*args)` - Construct a error estimate from explicit inputs for Numerical Analysis. +83. `numericalAnalysisNormalizeErrorEstimate(value)` - Normalize a error estimate into the standard Numerical Analysis representation. +84. `numericalAnalysisCanonicalizeErrorEstimate(value)` - Canonicalize a error estimate so equivalent inputs share one form. +85. `numericalAnalysisParseErrorEstimate(text)` - Parse a text or structured value into a error estimate. +86. `numericalAnalysisFormatErrorEstimate(value)` - Format a error estimate for deterministic user-facing output. +87. `numericalAnalysisCompareErrorEstimate(left, right)` - Compare two error estimate values under the conventions of Numerical Analysis. +88. `numericalAnalysisCombineErrorEstimate(left, right)` - Combine two error estimate values with the natural operation for Numerical Analysis. +89. `numericalAnalysisDecomposeErrorEstimate(value)` - Decompose a error estimate into simpler or canonical components. +90. `numericalAnalysisEvaluateErrorEstimate(value, point=None)` - Evaluate a error estimate at a point, sample, or finite model. +91. `numericalAnalysisComputeErrorEstimate(value)` - Compute the central numerical or symbolic data of a error estimate. +92. `numericalAnalysisEstimateErrorEstimate(value, samples=None)` - Estimate a error estimate property from finite samples or approximations. +93. `numericalAnalysisApproximateErrorEstimate(value, tolerance=1e-9)` - Approximate a error estimate with explicit tolerance controls. +94. `numericalAnalysisTransformErrorEstimate(value, mapping)` - Transform a error estimate through a map, operator, or representation change. +95. `numericalAnalysisSimplifyErrorEstimate(value)` - Simplify a error estimate without changing its mathematical meaning. +96. `numericalAnalysisEnumerateErrorEstimate(value, limit=None)` - Enumerate finite members, cases, or derived objects for a error estimate. +97. `numericalAnalysisClassifyErrorEstimate(value)` - Classify a error estimate by its standard Numerical Analysis invariants. +98. `numericalAnalysisTestEquivalenceErrorEstimate(left, right)` - Test whether two error estimate values are equivalent in Numerical Analysis. +99. `numericalAnalysisGenerateExampleErrorEstimate(size=3)` - Generate a small documented example of a error estimate. +100. `numericalAnalysisDocumentErrorEstimate(value)` - Return a structured explanation of a error estimate and related assumptions. + +### Ordinary Differential Equations + +Core object families: + +- ode model +- initial value problem +- solution curve +- equilibrium +- solver step + +Candidate functions: + +1. `ordinaryDifferentialEquationsValidateOdeModel(value)` - Validate the ode model representation and domain rules for Ordinary Differential Equations. +2. `ordinaryDifferentialEquationsConstructOdeModel(*args)` - Construct a ode model from explicit inputs for Ordinary Differential Equations. +3. `ordinaryDifferentialEquationsNormalizeOdeModel(value)` - Normalize a ode model into the standard Ordinary Differential Equations representation. +4. `ordinaryDifferentialEquationsCanonicalizeOdeModel(value)` - Canonicalize a ode model so equivalent inputs share one form. +5. `ordinaryDifferentialEquationsParseOdeModel(text)` - Parse a text or structured value into a ode model. +6. `ordinaryDifferentialEquationsFormatOdeModel(value)` - Format a ode model for deterministic user-facing output. +7. `ordinaryDifferentialEquationsCompareOdeModel(left, right)` - Compare two ode model values under the conventions of Ordinary Differential Equations. +8. `ordinaryDifferentialEquationsCombineOdeModel(left, right)` - Combine two ode model values with the natural operation for Ordinary Differential Equations. +9. `ordinaryDifferentialEquationsDecomposeOdeModel(value)` - Decompose a ode model into simpler or canonical components. +10. `ordinaryDifferentialEquationsEvaluateOdeModel(value, point=None)` - Evaluate a ode model at a point, sample, or finite model. +11. `ordinaryDifferentialEquationsComputeOdeModel(value)` - Compute the central numerical or symbolic data of a ode model. +12. `ordinaryDifferentialEquationsEstimateOdeModel(value, samples=None)` - Estimate a ode model property from finite samples or approximations. +13. `ordinaryDifferentialEquationsApproximateOdeModel(value, tolerance=1e-9)` - Approximate a ode model with explicit tolerance controls. +14. `ordinaryDifferentialEquationsTransformOdeModel(value, mapping)` - Transform a ode model through a map, operator, or representation change. +15. `ordinaryDifferentialEquationsSimplifyOdeModel(value)` - Simplify a ode model without changing its mathematical meaning. +16. `ordinaryDifferentialEquationsEnumerateOdeModel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a ode model. +17. `ordinaryDifferentialEquationsClassifyOdeModel(value)` - Classify a ode model by its standard Ordinary Differential Equations invariants. +18. `ordinaryDifferentialEquationsTestEquivalenceOdeModel(left, right)` - Test whether two ode model values are equivalent in Ordinary Differential Equations. +19. `ordinaryDifferentialEquationsGenerateExampleOdeModel(size=3)` - Generate a small documented example of a ode model. +20. `ordinaryDifferentialEquationsDocumentOdeModel(value)` - Return a structured explanation of a ode model and related assumptions. +21. `ordinaryDifferentialEquationsValidateInitialValueProblem(value)` - Validate the initial value problem representation and domain rules for Ordinary Differential Equations. +22. `ordinaryDifferentialEquationsConstructInitialValueProblem(*args)` - Construct a initial value problem from explicit inputs for Ordinary Differential Equations. +23. `ordinaryDifferentialEquationsNormalizeInitialValueProblem(value)` - Normalize a initial value problem into the standard Ordinary Differential Equations representation. +24. `ordinaryDifferentialEquationsCanonicalizeInitialValueProblem(value)` - Canonicalize a initial value problem so equivalent inputs share one form. +25. `ordinaryDifferentialEquationsParseInitialValueProblem(text)` - Parse a text or structured value into a initial value problem. +26. `ordinaryDifferentialEquationsFormatInitialValueProblem(value)` - Format a initial value problem for deterministic user-facing output. +27. `ordinaryDifferentialEquationsCompareInitialValueProblem(left, right)` - Compare two initial value problem values under the conventions of Ordinary Differential Equations. +28. `ordinaryDifferentialEquationsCombineInitialValueProblem(left, right)` - Combine two initial value problem values with the natural operation for Ordinary Differential Equations. +29. `ordinaryDifferentialEquationsDecomposeInitialValueProblem(value)` - Decompose a initial value problem into simpler or canonical components. +30. `ordinaryDifferentialEquationsEvaluateInitialValueProblem(value, point=None)` - Evaluate a initial value problem at a point, sample, or finite model. +31. `ordinaryDifferentialEquationsComputeInitialValueProblem(value)` - Compute the central numerical or symbolic data of a initial value problem. +32. `ordinaryDifferentialEquationsEstimateInitialValueProblem(value, samples=None)` - Estimate a initial value problem property from finite samples or approximations. +33. `ordinaryDifferentialEquationsApproximateInitialValueProblem(value, tolerance=1e-9)` - Approximate a initial value problem with explicit tolerance controls. +34. `ordinaryDifferentialEquationsTransformInitialValueProblem(value, mapping)` - Transform a initial value problem through a map, operator, or representation change. +35. `ordinaryDifferentialEquationsSimplifyInitialValueProblem(value)` - Simplify a initial value problem without changing its mathematical meaning. +36. `ordinaryDifferentialEquationsEnumerateInitialValueProblem(value, limit=None)` - Enumerate finite members, cases, or derived objects for a initial value problem. +37. `ordinaryDifferentialEquationsClassifyInitialValueProblem(value)` - Classify a initial value problem by its standard Ordinary Differential Equations invariants. +38. `ordinaryDifferentialEquationsTestEquivalenceInitialValueProblem(left, right)` - Test whether two initial value problem values are equivalent in Ordinary Differential Equations. +39. `ordinaryDifferentialEquationsGenerateExampleInitialValueProblem(size=3)` - Generate a small documented example of a initial value problem. +40. `ordinaryDifferentialEquationsDocumentInitialValueProblem(value)` - Return a structured explanation of a initial value problem and related assumptions. +41. `ordinaryDifferentialEquationsValidateSolutionCurve(value)` - Validate the solution curve representation and domain rules for Ordinary Differential Equations. +42. `ordinaryDifferentialEquationsConstructSolutionCurve(*args)` - Construct a solution curve from explicit inputs for Ordinary Differential Equations. +43. `ordinaryDifferentialEquationsNormalizeSolutionCurve(value)` - Normalize a solution curve into the standard Ordinary Differential Equations representation. +44. `ordinaryDifferentialEquationsCanonicalizeSolutionCurve(value)` - Canonicalize a solution curve so equivalent inputs share one form. +45. `ordinaryDifferentialEquationsParseSolutionCurve(text)` - Parse a text or structured value into a solution curve. +46. `ordinaryDifferentialEquationsFormatSolutionCurve(value)` - Format a solution curve for deterministic user-facing output. +47. `ordinaryDifferentialEquationsCompareSolutionCurve(left, right)` - Compare two solution curve values under the conventions of Ordinary Differential Equations. +48. `ordinaryDifferentialEquationsCombineSolutionCurve(left, right)` - Combine two solution curve values with the natural operation for Ordinary Differential Equations. +49. `ordinaryDifferentialEquationsDecomposeSolutionCurve(value)` - Decompose a solution curve into simpler or canonical components. +50. `ordinaryDifferentialEquationsEvaluateSolutionCurve(value, point=None)` - Evaluate a solution curve at a point, sample, or finite model. +51. `ordinaryDifferentialEquationsComputeSolutionCurve(value)` - Compute the central numerical or symbolic data of a solution curve. +52. `ordinaryDifferentialEquationsEstimateSolutionCurve(value, samples=None)` - Estimate a solution curve property from finite samples or approximations. +53. `ordinaryDifferentialEquationsApproximateSolutionCurve(value, tolerance=1e-9)` - Approximate a solution curve with explicit tolerance controls. +54. `ordinaryDifferentialEquationsTransformSolutionCurve(value, mapping)` - Transform a solution curve through a map, operator, or representation change. +55. `ordinaryDifferentialEquationsSimplifySolutionCurve(value)` - Simplify a solution curve without changing its mathematical meaning. +56. `ordinaryDifferentialEquationsEnumerateSolutionCurve(value, limit=None)` - Enumerate finite members, cases, or derived objects for a solution curve. +57. `ordinaryDifferentialEquationsClassifySolutionCurve(value)` - Classify a solution curve by its standard Ordinary Differential Equations invariants. +58. `ordinaryDifferentialEquationsTestEquivalenceSolutionCurve(left, right)` - Test whether two solution curve values are equivalent in Ordinary Differential Equations. +59. `ordinaryDifferentialEquationsGenerateExampleSolutionCurve(size=3)` - Generate a small documented example of a solution curve. +60. `ordinaryDifferentialEquationsDocumentSolutionCurve(value)` - Return a structured explanation of a solution curve and related assumptions. +61. `ordinaryDifferentialEquationsValidateEquilibrium(value)` - Validate the equilibrium representation and domain rules for Ordinary Differential Equations. +62. `ordinaryDifferentialEquationsConstructEquilibrium(*args)` - Construct a equilibrium from explicit inputs for Ordinary Differential Equations. +63. `ordinaryDifferentialEquationsNormalizeEquilibrium(value)` - Normalize a equilibrium into the standard Ordinary Differential Equations representation. +64. `ordinaryDifferentialEquationsCanonicalizeEquilibrium(value)` - Canonicalize a equilibrium so equivalent inputs share one form. +65. `ordinaryDifferentialEquationsParseEquilibrium(text)` - Parse a text or structured value into a equilibrium. +66. `ordinaryDifferentialEquationsFormatEquilibrium(value)` - Format a equilibrium for deterministic user-facing output. +67. `ordinaryDifferentialEquationsCompareEquilibrium(left, right)` - Compare two equilibrium values under the conventions of Ordinary Differential Equations. +68. `ordinaryDifferentialEquationsCombineEquilibrium(left, right)` - Combine two equilibrium values with the natural operation for Ordinary Differential Equations. +69. `ordinaryDifferentialEquationsDecomposeEquilibrium(value)` - Decompose a equilibrium into simpler or canonical components. +70. `ordinaryDifferentialEquationsEvaluateEquilibrium(value, point=None)` - Evaluate a equilibrium at a point, sample, or finite model. +71. `ordinaryDifferentialEquationsComputeEquilibrium(value)` - Compute the central numerical or symbolic data of a equilibrium. +72. `ordinaryDifferentialEquationsEstimateEquilibrium(value, samples=None)` - Estimate a equilibrium property from finite samples or approximations. +73. `ordinaryDifferentialEquationsApproximateEquilibrium(value, tolerance=1e-9)` - Approximate a equilibrium with explicit tolerance controls. +74. `ordinaryDifferentialEquationsTransformEquilibrium(value, mapping)` - Transform a equilibrium through a map, operator, or representation change. +75. `ordinaryDifferentialEquationsSimplifyEquilibrium(value)` - Simplify a equilibrium without changing its mathematical meaning. +76. `ordinaryDifferentialEquationsEnumerateEquilibrium(value, limit=None)` - Enumerate finite members, cases, or derived objects for a equilibrium. +77. `ordinaryDifferentialEquationsClassifyEquilibrium(value)` - Classify a equilibrium by its standard Ordinary Differential Equations invariants. +78. `ordinaryDifferentialEquationsTestEquivalenceEquilibrium(left, right)` - Test whether two equilibrium values are equivalent in Ordinary Differential Equations. +79. `ordinaryDifferentialEquationsGenerateExampleEquilibrium(size=3)` - Generate a small documented example of a equilibrium. +80. `ordinaryDifferentialEquationsDocumentEquilibrium(value)` - Return a structured explanation of a equilibrium and related assumptions. +81. `ordinaryDifferentialEquationsValidateSolverStep(value)` - Validate the solver step representation and domain rules for Ordinary Differential Equations. +82. `ordinaryDifferentialEquationsConstructSolverStep(*args)` - Construct a solver step from explicit inputs for Ordinary Differential Equations. +83. `ordinaryDifferentialEquationsNormalizeSolverStep(value)` - Normalize a solver step into the standard Ordinary Differential Equations representation. +84. `ordinaryDifferentialEquationsCanonicalizeSolverStep(value)` - Canonicalize a solver step so equivalent inputs share one form. +85. `ordinaryDifferentialEquationsParseSolverStep(text)` - Parse a text or structured value into a solver step. +86. `ordinaryDifferentialEquationsFormatSolverStep(value)` - Format a solver step for deterministic user-facing output. +87. `ordinaryDifferentialEquationsCompareSolverStep(left, right)` - Compare two solver step values under the conventions of Ordinary Differential Equations. +88. `ordinaryDifferentialEquationsCombineSolverStep(left, right)` - Combine two solver step values with the natural operation for Ordinary Differential Equations. +89. `ordinaryDifferentialEquationsDecomposeSolverStep(value)` - Decompose a solver step into simpler or canonical components. +90. `ordinaryDifferentialEquationsEvaluateSolverStep(value, point=None)` - Evaluate a solver step at a point, sample, or finite model. +91. `ordinaryDifferentialEquationsComputeSolverStep(value)` - Compute the central numerical or symbolic data of a solver step. +92. `ordinaryDifferentialEquationsEstimateSolverStep(value, samples=None)` - Estimate a solver step property from finite samples or approximations. +93. `ordinaryDifferentialEquationsApproximateSolverStep(value, tolerance=1e-9)` - Approximate a solver step with explicit tolerance controls. +94. `ordinaryDifferentialEquationsTransformSolverStep(value, mapping)` - Transform a solver step through a map, operator, or representation change. +95. `ordinaryDifferentialEquationsSimplifySolverStep(value)` - Simplify a solver step without changing its mathematical meaning. +96. `ordinaryDifferentialEquationsEnumerateSolverStep(value, limit=None)` - Enumerate finite members, cases, or derived objects for a solver step. +97. `ordinaryDifferentialEquationsClassifySolverStep(value)` - Classify a solver step by its standard Ordinary Differential Equations invariants. +98. `ordinaryDifferentialEquationsTestEquivalenceSolverStep(left, right)` - Test whether two solver step values are equivalent in Ordinary Differential Equations. +99. `ordinaryDifferentialEquationsGenerateExampleSolverStep(size=3)` - Generate a small documented example of a solver step. +100. `ordinaryDifferentialEquationsDocumentSolverStep(value)` - Return a structured explanation of a solver step and related assumptions. + +### Multivariable and Vector Calculus + +Core object families: + +- multivariable function +- vector field +- gradient model +- jacobian +- surface integral + +Candidate functions: + +1. `multivariableAndVectorCalculusValidateMultivariableFunction(value)` - Validate the multivariable function representation and domain rules for Multivariable and Vector Calculus. +2. `multivariableAndVectorCalculusConstructMultivariableFunction(*args)` - Construct a multivariable function from explicit inputs for Multivariable and Vector Calculus. +3. `multivariableAndVectorCalculusNormalizeMultivariableFunction(value)` - Normalize a multivariable function into the standard Multivariable and Vector Calculus representation. +4. `multivariableAndVectorCalculusCanonicalizeMultivariableFunction(value)` - Canonicalize a multivariable function so equivalent inputs share one form. +5. `multivariableAndVectorCalculusParseMultivariableFunction(text)` - Parse a text or structured value into a multivariable function. +6. `multivariableAndVectorCalculusFormatMultivariableFunction(value)` - Format a multivariable function for deterministic user-facing output. +7. `multivariableAndVectorCalculusCompareMultivariableFunction(left, right)` - Compare two multivariable function values under the conventions of Multivariable and Vector Calculus. +8. `multivariableAndVectorCalculusCombineMultivariableFunction(left, right)` - Combine two multivariable function values with the natural operation for Multivariable and Vector Calculus. +9. `multivariableAndVectorCalculusDecomposeMultivariableFunction(value)` - Decompose a multivariable function into simpler or canonical components. +10. `multivariableAndVectorCalculusEvaluateMultivariableFunction(value, point=None)` - Evaluate a multivariable function at a point, sample, or finite model. +11. `multivariableAndVectorCalculusComputeMultivariableFunction(value)` - Compute the central numerical or symbolic data of a multivariable function. +12. `multivariableAndVectorCalculusEstimateMultivariableFunction(value, samples=None)` - Estimate a multivariable function property from finite samples or approximations. +13. `multivariableAndVectorCalculusApproximateMultivariableFunction(value, tolerance=1e-9)` - Approximate a multivariable function with explicit tolerance controls. +14. `multivariableAndVectorCalculusTransformMultivariableFunction(value, mapping)` - Transform a multivariable function through a map, operator, or representation change. +15. `multivariableAndVectorCalculusSimplifyMultivariableFunction(value)` - Simplify a multivariable function without changing its mathematical meaning. +16. `multivariableAndVectorCalculusEnumerateMultivariableFunction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a multivariable function. +17. `multivariableAndVectorCalculusClassifyMultivariableFunction(value)` - Classify a multivariable function by its standard Multivariable and Vector Calculus invariants. +18. `multivariableAndVectorCalculusTestEquivalenceMultivariableFunction(left, right)` - Test whether two multivariable function values are equivalent in Multivariable and Vector Calculus. +19. `multivariableAndVectorCalculusGenerateExampleMultivariableFunction(size=3)` - Generate a small documented example of a multivariable function. +20. `multivariableAndVectorCalculusDocumentMultivariableFunction(value)` - Return a structured explanation of a multivariable function and related assumptions. +21. `multivariableAndVectorCalculusValidateVectorField(value)` - Validate the vector field representation and domain rules for Multivariable and Vector Calculus. +22. `multivariableAndVectorCalculusConstructVectorField(*args)` - Construct a vector field from explicit inputs for Multivariable and Vector Calculus. +23. `multivariableAndVectorCalculusNormalizeVectorField(value)` - Normalize a vector field into the standard Multivariable and Vector Calculus representation. +24. `multivariableAndVectorCalculusCanonicalizeVectorField(value)` - Canonicalize a vector field so equivalent inputs share one form. +25. `multivariableAndVectorCalculusParseVectorField(text)` - Parse a text or structured value into a vector field. +26. `multivariableAndVectorCalculusFormatVectorField(value)` - Format a vector field for deterministic user-facing output. +27. `multivariableAndVectorCalculusCompareVectorField(left, right)` - Compare two vector field values under the conventions of Multivariable and Vector Calculus. +28. `multivariableAndVectorCalculusCombineVectorField(left, right)` - Combine two vector field values with the natural operation for Multivariable and Vector Calculus. +29. `multivariableAndVectorCalculusDecomposeVectorField(value)` - Decompose a vector field into simpler or canonical components. +30. `multivariableAndVectorCalculusEvaluateVectorField(value, point=None)` - Evaluate a vector field at a point, sample, or finite model. +31. `multivariableAndVectorCalculusComputeVectorField(value)` - Compute the central numerical or symbolic data of a vector field. +32. `multivariableAndVectorCalculusEstimateVectorField(value, samples=None)` - Estimate a vector field property from finite samples or approximations. +33. `multivariableAndVectorCalculusApproximateVectorField(value, tolerance=1e-9)` - Approximate a vector field with explicit tolerance controls. +34. `multivariableAndVectorCalculusTransformVectorField(value, mapping)` - Transform a vector field through a map, operator, or representation change. +35. `multivariableAndVectorCalculusSimplifyVectorField(value)` - Simplify a vector field without changing its mathematical meaning. +36. `multivariableAndVectorCalculusEnumerateVectorField(value, limit=None)` - Enumerate finite members, cases, or derived objects for a vector field. +37. `multivariableAndVectorCalculusClassifyVectorField(value)` - Classify a vector field by its standard Multivariable and Vector Calculus invariants. +38. `multivariableAndVectorCalculusTestEquivalenceVectorField(left, right)` - Test whether two vector field values are equivalent in Multivariable and Vector Calculus. +39. `multivariableAndVectorCalculusGenerateExampleVectorField(size=3)` - Generate a small documented example of a vector field. +40. `multivariableAndVectorCalculusDocumentVectorField(value)` - Return a structured explanation of a vector field and related assumptions. +41. `multivariableAndVectorCalculusValidateGradientModel(value)` - Validate the gradient model representation and domain rules for Multivariable and Vector Calculus. +42. `multivariableAndVectorCalculusConstructGradientModel(*args)` - Construct a gradient model from explicit inputs for Multivariable and Vector Calculus. +43. `multivariableAndVectorCalculusNormalizeGradientModel(value)` - Normalize a gradient model into the standard Multivariable and Vector Calculus representation. +44. `multivariableAndVectorCalculusCanonicalizeGradientModel(value)` - Canonicalize a gradient model so equivalent inputs share one form. +45. `multivariableAndVectorCalculusParseGradientModel(text)` - Parse a text or structured value into a gradient model. +46. `multivariableAndVectorCalculusFormatGradientModel(value)` - Format a gradient model for deterministic user-facing output. +47. `multivariableAndVectorCalculusCompareGradientModel(left, right)` - Compare two gradient model values under the conventions of Multivariable and Vector Calculus. +48. `multivariableAndVectorCalculusCombineGradientModel(left, right)` - Combine two gradient model values with the natural operation for Multivariable and Vector Calculus. +49. `multivariableAndVectorCalculusDecomposeGradientModel(value)` - Decompose a gradient model into simpler or canonical components. +50. `multivariableAndVectorCalculusEvaluateGradientModel(value, point=None)` - Evaluate a gradient model at a point, sample, or finite model. +51. `multivariableAndVectorCalculusComputeGradientModel(value)` - Compute the central numerical or symbolic data of a gradient model. +52. `multivariableAndVectorCalculusEstimateGradientModel(value, samples=None)` - Estimate a gradient model property from finite samples or approximations. +53. `multivariableAndVectorCalculusApproximateGradientModel(value, tolerance=1e-9)` - Approximate a gradient model with explicit tolerance controls. +54. `multivariableAndVectorCalculusTransformGradientModel(value, mapping)` - Transform a gradient model through a map, operator, or representation change. +55. `multivariableAndVectorCalculusSimplifyGradientModel(value)` - Simplify a gradient model without changing its mathematical meaning. +56. `multivariableAndVectorCalculusEnumerateGradientModel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a gradient model. +57. `multivariableAndVectorCalculusClassifyGradientModel(value)` - Classify a gradient model by its standard Multivariable and Vector Calculus invariants. +58. `multivariableAndVectorCalculusTestEquivalenceGradientModel(left, right)` - Test whether two gradient model values are equivalent in Multivariable and Vector Calculus. +59. `multivariableAndVectorCalculusGenerateExampleGradientModel(size=3)` - Generate a small documented example of a gradient model. +60. `multivariableAndVectorCalculusDocumentGradientModel(value)` - Return a structured explanation of a gradient model and related assumptions. +61. `multivariableAndVectorCalculusValidateJacobian(value)` - Validate the jacobian representation and domain rules for Multivariable and Vector Calculus. +62. `multivariableAndVectorCalculusConstructJacobian(*args)` - Construct a jacobian from explicit inputs for Multivariable and Vector Calculus. +63. `multivariableAndVectorCalculusNormalizeJacobian(value)` - Normalize a jacobian into the standard Multivariable and Vector Calculus representation. +64. `multivariableAndVectorCalculusCanonicalizeJacobian(value)` - Canonicalize a jacobian so equivalent inputs share one form. +65. `multivariableAndVectorCalculusParseJacobian(text)` - Parse a text or structured value into a jacobian. +66. `multivariableAndVectorCalculusFormatJacobian(value)` - Format a jacobian for deterministic user-facing output. +67. `multivariableAndVectorCalculusCompareJacobian(left, right)` - Compare two jacobian values under the conventions of Multivariable and Vector Calculus. +68. `multivariableAndVectorCalculusCombineJacobian(left, right)` - Combine two jacobian values with the natural operation for Multivariable and Vector Calculus. +69. `multivariableAndVectorCalculusDecomposeJacobian(value)` - Decompose a jacobian into simpler or canonical components. +70. `multivariableAndVectorCalculusEvaluateJacobian(value, point=None)` - Evaluate a jacobian at a point, sample, or finite model. +71. `multivariableAndVectorCalculusComputeJacobian(value)` - Compute the central numerical or symbolic data of a jacobian. +72. `multivariableAndVectorCalculusEstimateJacobian(value, samples=None)` - Estimate a jacobian property from finite samples or approximations. +73. `multivariableAndVectorCalculusApproximateJacobian(value, tolerance=1e-9)` - Approximate a jacobian with explicit tolerance controls. +74. `multivariableAndVectorCalculusTransformJacobian(value, mapping)` - Transform a jacobian through a map, operator, or representation change. +75. `multivariableAndVectorCalculusSimplifyJacobian(value)` - Simplify a jacobian without changing its mathematical meaning. +76. `multivariableAndVectorCalculusEnumerateJacobian(value, limit=None)` - Enumerate finite members, cases, or derived objects for a jacobian. +77. `multivariableAndVectorCalculusClassifyJacobian(value)` - Classify a jacobian by its standard Multivariable and Vector Calculus invariants. +78. `multivariableAndVectorCalculusTestEquivalenceJacobian(left, right)` - Test whether two jacobian values are equivalent in Multivariable and Vector Calculus. +79. `multivariableAndVectorCalculusGenerateExampleJacobian(size=3)` - Generate a small documented example of a jacobian. +80. `multivariableAndVectorCalculusDocumentJacobian(value)` - Return a structured explanation of a jacobian and related assumptions. +81. `multivariableAndVectorCalculusValidateSurfaceIntegral(value)` - Validate the surface integral representation and domain rules for Multivariable and Vector Calculus. +82. `multivariableAndVectorCalculusConstructSurfaceIntegral(*args)` - Construct a surface integral from explicit inputs for Multivariable and Vector Calculus. +83. `multivariableAndVectorCalculusNormalizeSurfaceIntegral(value)` - Normalize a surface integral into the standard Multivariable and Vector Calculus representation. +84. `multivariableAndVectorCalculusCanonicalizeSurfaceIntegral(value)` - Canonicalize a surface integral so equivalent inputs share one form. +85. `multivariableAndVectorCalculusParseSurfaceIntegral(text)` - Parse a text or structured value into a surface integral. +86. `multivariableAndVectorCalculusFormatSurfaceIntegral(value)` - Format a surface integral for deterministic user-facing output. +87. `multivariableAndVectorCalculusCompareSurfaceIntegral(left, right)` - Compare two surface integral values under the conventions of Multivariable and Vector Calculus. +88. `multivariableAndVectorCalculusCombineSurfaceIntegral(left, right)` - Combine two surface integral values with the natural operation for Multivariable and Vector Calculus. +89. `multivariableAndVectorCalculusDecomposeSurfaceIntegral(value)` - Decompose a surface integral into simpler or canonical components. +90. `multivariableAndVectorCalculusEvaluateSurfaceIntegral(value, point=None)` - Evaluate a surface integral at a point, sample, or finite model. +91. `multivariableAndVectorCalculusComputeSurfaceIntegral(value)` - Compute the central numerical or symbolic data of a surface integral. +92. `multivariableAndVectorCalculusEstimateSurfaceIntegral(value, samples=None)` - Estimate a surface integral property from finite samples or approximations. +93. `multivariableAndVectorCalculusApproximateSurfaceIntegral(value, tolerance=1e-9)` - Approximate a surface integral with explicit tolerance controls. +94. `multivariableAndVectorCalculusTransformSurfaceIntegral(value, mapping)` - Transform a surface integral through a map, operator, or representation change. +95. `multivariableAndVectorCalculusSimplifySurfaceIntegral(value)` - Simplify a surface integral without changing its mathematical meaning. +96. `multivariableAndVectorCalculusEnumerateSurfaceIntegral(value, limit=None)` - Enumerate finite members, cases, or derived objects for a surface integral. +97. `multivariableAndVectorCalculusClassifySurfaceIntegral(value)` - Classify a surface integral by its standard Multivariable and Vector Calculus invariants. +98. `multivariableAndVectorCalculusTestEquivalenceSurfaceIntegral(left, right)` - Test whether two surface integral values are equivalent in Multivariable and Vector Calculus. +99. `multivariableAndVectorCalculusGenerateExampleSurfaceIntegral(size=3)` - Generate a small documented example of a surface integral. +100. `multivariableAndVectorCalculusDocumentSurfaceIntegral(value)` - Return a structured explanation of a surface integral and related assumptions. + +### Combinatorics + +Core object families: + +- combinatorial class +- generating function +- permutation family +- partition family +- counting identity + +Candidate functions: + +1. `combinatoricsValidateCombinatorialClass(value)` - Validate the combinatorial class representation and domain rules for Combinatorics. +2. `combinatoricsConstructCombinatorialClass(*args)` - Construct a combinatorial class from explicit inputs for Combinatorics. +3. `combinatoricsNormalizeCombinatorialClass(value)` - Normalize a combinatorial class into the standard Combinatorics representation. +4. `combinatoricsCanonicalizeCombinatorialClass(value)` - Canonicalize a combinatorial class so equivalent inputs share one form. +5. `combinatoricsParseCombinatorialClass(text)` - Parse a text or structured value into a combinatorial class. +6. `combinatoricsFormatCombinatorialClass(value)` - Format a combinatorial class for deterministic user-facing output. +7. `combinatoricsCompareCombinatorialClass(left, right)` - Compare two combinatorial class values under the conventions of Combinatorics. +8. `combinatoricsCombineCombinatorialClass(left, right)` - Combine two combinatorial class values with the natural operation for Combinatorics. +9. `combinatoricsDecomposeCombinatorialClass(value)` - Decompose a combinatorial class into simpler or canonical components. +10. `combinatoricsEvaluateCombinatorialClass(value, point=None)` - Evaluate a combinatorial class at a point, sample, or finite model. +11. `combinatoricsComputeCombinatorialClass(value)` - Compute the central numerical or symbolic data of a combinatorial class. +12. `combinatoricsEstimateCombinatorialClass(value, samples=None)` - Estimate a combinatorial class property from finite samples or approximations. +13. `combinatoricsApproximateCombinatorialClass(value, tolerance=1e-9)` - Approximate a combinatorial class with explicit tolerance controls. +14. `combinatoricsTransformCombinatorialClass(value, mapping)` - Transform a combinatorial class through a map, operator, or representation change. +15. `combinatoricsSimplifyCombinatorialClass(value)` - Simplify a combinatorial class without changing its mathematical meaning. +16. `combinatoricsEnumerateCombinatorialClass(value, limit=None)` - Enumerate finite members, cases, or derived objects for a combinatorial class. +17. `combinatoricsClassifyCombinatorialClass(value)` - Classify a combinatorial class by its standard Combinatorics invariants. +18. `combinatoricsTestEquivalenceCombinatorialClass(left, right)` - Test whether two combinatorial class values are equivalent in Combinatorics. +19. `combinatoricsGenerateExampleCombinatorialClass(size=3)` - Generate a small documented example of a combinatorial class. +20. `combinatoricsDocumentCombinatorialClass(value)` - Return a structured explanation of a combinatorial class and related assumptions. +21. `combinatoricsValidateGeneratingFunction(value)` - Validate the generating function representation and domain rules for Combinatorics. +22. `combinatoricsConstructGeneratingFunction(*args)` - Construct a generating function from explicit inputs for Combinatorics. +23. `combinatoricsNormalizeGeneratingFunction(value)` - Normalize a generating function into the standard Combinatorics representation. +24. `combinatoricsCanonicalizeGeneratingFunction(value)` - Canonicalize a generating function so equivalent inputs share one form. +25. `combinatoricsParseGeneratingFunction(text)` - Parse a text or structured value into a generating function. +26. `combinatoricsFormatGeneratingFunction(value)` - Format a generating function for deterministic user-facing output. +27. `combinatoricsCompareGeneratingFunction(left, right)` - Compare two generating function values under the conventions of Combinatorics. +28. `combinatoricsCombineGeneratingFunction(left, right)` - Combine two generating function values with the natural operation for Combinatorics. +29. `combinatoricsDecomposeGeneratingFunction(value)` - Decompose a generating function into simpler or canonical components. +30. `combinatoricsEvaluateGeneratingFunction(value, point=None)` - Evaluate a generating function at a point, sample, or finite model. +31. `combinatoricsComputeGeneratingFunction(value)` - Compute the central numerical or symbolic data of a generating function. +32. `combinatoricsEstimateGeneratingFunction(value, samples=None)` - Estimate a generating function property from finite samples or approximations. +33. `combinatoricsApproximateGeneratingFunction(value, tolerance=1e-9)` - Approximate a generating function with explicit tolerance controls. +34. `combinatoricsTransformGeneratingFunction(value, mapping)` - Transform a generating function through a map, operator, or representation change. +35. `combinatoricsSimplifyGeneratingFunction(value)` - Simplify a generating function without changing its mathematical meaning. +36. `combinatoricsEnumerateGeneratingFunction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a generating function. +37. `combinatoricsClassifyGeneratingFunction(value)` - Classify a generating function by its standard Combinatorics invariants. +38. `combinatoricsTestEquivalenceGeneratingFunction(left, right)` - Test whether two generating function values are equivalent in Combinatorics. +39. `combinatoricsGenerateExampleGeneratingFunction(size=3)` - Generate a small documented example of a generating function. +40. `combinatoricsDocumentGeneratingFunction(value)` - Return a structured explanation of a generating function and related assumptions. +41. `combinatoricsValidatePermutationFamily(value)` - Validate the permutation family representation and domain rules for Combinatorics. +42. `combinatoricsConstructPermutationFamily(*args)` - Construct a permutation family from explicit inputs for Combinatorics. +43. `combinatoricsNormalizePermutationFamily(value)` - Normalize a permutation family into the standard Combinatorics representation. +44. `combinatoricsCanonicalizePermutationFamily(value)` - Canonicalize a permutation family so equivalent inputs share one form. +45. `combinatoricsParsePermutationFamily(text)` - Parse a text or structured value into a permutation family. +46. `combinatoricsFormatPermutationFamily(value)` - Format a permutation family for deterministic user-facing output. +47. `combinatoricsComparePermutationFamily(left, right)` - Compare two permutation family values under the conventions of Combinatorics. +48. `combinatoricsCombinePermutationFamily(left, right)` - Combine two permutation family values with the natural operation for Combinatorics. +49. `combinatoricsDecomposePermutationFamily(value)` - Decompose a permutation family into simpler or canonical components. +50. `combinatoricsEvaluatePermutationFamily(value, point=None)` - Evaluate a permutation family at a point, sample, or finite model. +51. `combinatoricsComputePermutationFamily(value)` - Compute the central numerical or symbolic data of a permutation family. +52. `combinatoricsEstimatePermutationFamily(value, samples=None)` - Estimate a permutation family property from finite samples or approximations. +53. `combinatoricsApproximatePermutationFamily(value, tolerance=1e-9)` - Approximate a permutation family with explicit tolerance controls. +54. `combinatoricsTransformPermutationFamily(value, mapping)` - Transform a permutation family through a map, operator, or representation change. +55. `combinatoricsSimplifyPermutationFamily(value)` - Simplify a permutation family without changing its mathematical meaning. +56. `combinatoricsEnumeratePermutationFamily(value, limit=None)` - Enumerate finite members, cases, or derived objects for a permutation family. +57. `combinatoricsClassifyPermutationFamily(value)` - Classify a permutation family by its standard Combinatorics invariants. +58. `combinatoricsTestEquivalencePermutationFamily(left, right)` - Test whether two permutation family values are equivalent in Combinatorics. +59. `combinatoricsGenerateExamplePermutationFamily(size=3)` - Generate a small documented example of a permutation family. +60. `combinatoricsDocumentPermutationFamily(value)` - Return a structured explanation of a permutation family and related assumptions. +61. `combinatoricsValidatePartitionFamily(value)` - Validate the partition family representation and domain rules for Combinatorics. +62. `combinatoricsConstructPartitionFamily(*args)` - Construct a partition family from explicit inputs for Combinatorics. +63. `combinatoricsNormalizePartitionFamily(value)` - Normalize a partition family into the standard Combinatorics representation. +64. `combinatoricsCanonicalizePartitionFamily(value)` - Canonicalize a partition family so equivalent inputs share one form. +65. `combinatoricsParsePartitionFamily(text)` - Parse a text or structured value into a partition family. +66. `combinatoricsFormatPartitionFamily(value)` - Format a partition family for deterministic user-facing output. +67. `combinatoricsComparePartitionFamily(left, right)` - Compare two partition family values under the conventions of Combinatorics. +68. `combinatoricsCombinePartitionFamily(left, right)` - Combine two partition family values with the natural operation for Combinatorics. +69. `combinatoricsDecomposePartitionFamily(value)` - Decompose a partition family into simpler or canonical components. +70. `combinatoricsEvaluatePartitionFamily(value, point=None)` - Evaluate a partition family at a point, sample, or finite model. +71. `combinatoricsComputePartitionFamily(value)` - Compute the central numerical or symbolic data of a partition family. +72. `combinatoricsEstimatePartitionFamily(value, samples=None)` - Estimate a partition family property from finite samples or approximations. +73. `combinatoricsApproximatePartitionFamily(value, tolerance=1e-9)` - Approximate a partition family with explicit tolerance controls. +74. `combinatoricsTransformPartitionFamily(value, mapping)` - Transform a partition family through a map, operator, or representation change. +75. `combinatoricsSimplifyPartitionFamily(value)` - Simplify a partition family without changing its mathematical meaning. +76. `combinatoricsEnumeratePartitionFamily(value, limit=None)` - Enumerate finite members, cases, or derived objects for a partition family. +77. `combinatoricsClassifyPartitionFamily(value)` - Classify a partition family by its standard Combinatorics invariants. +78. `combinatoricsTestEquivalencePartitionFamily(left, right)` - Test whether two partition family values are equivalent in Combinatorics. +79. `combinatoricsGenerateExamplePartitionFamily(size=3)` - Generate a small documented example of a partition family. +80. `combinatoricsDocumentPartitionFamily(value)` - Return a structured explanation of a partition family and related assumptions. +81. `combinatoricsValidateCountingIdentity(value)` - Validate the counting identity representation and domain rules for Combinatorics. +82. `combinatoricsConstructCountingIdentity(*args)` - Construct a counting identity from explicit inputs for Combinatorics. +83. `combinatoricsNormalizeCountingIdentity(value)` - Normalize a counting identity into the standard Combinatorics representation. +84. `combinatoricsCanonicalizeCountingIdentity(value)` - Canonicalize a counting identity so equivalent inputs share one form. +85. `combinatoricsParseCountingIdentity(text)` - Parse a text or structured value into a counting identity. +86. `combinatoricsFormatCountingIdentity(value)` - Format a counting identity for deterministic user-facing output. +87. `combinatoricsCompareCountingIdentity(left, right)` - Compare two counting identity values under the conventions of Combinatorics. +88. `combinatoricsCombineCountingIdentity(left, right)` - Combine two counting identity values with the natural operation for Combinatorics. +89. `combinatoricsDecomposeCountingIdentity(value)` - Decompose a counting identity into simpler or canonical components. +90. `combinatoricsEvaluateCountingIdentity(value, point=None)` - Evaluate a counting identity at a point, sample, or finite model. +91. `combinatoricsComputeCountingIdentity(value)` - Compute the central numerical or symbolic data of a counting identity. +92. `combinatoricsEstimateCountingIdentity(value, samples=None)` - Estimate a counting identity property from finite samples or approximations. +93. `combinatoricsApproximateCountingIdentity(value, tolerance=1e-9)` - Approximate a counting identity with explicit tolerance controls. +94. `combinatoricsTransformCountingIdentity(value, mapping)` - Transform a counting identity through a map, operator, or representation change. +95. `combinatoricsSimplifyCountingIdentity(value)` - Simplify a counting identity without changing its mathematical meaning. +96. `combinatoricsEnumerateCountingIdentity(value, limit=None)` - Enumerate finite members, cases, or derived objects for a counting identity. +97. `combinatoricsClassifyCountingIdentity(value)` - Classify a counting identity by its standard Combinatorics invariants. +98. `combinatoricsTestEquivalenceCountingIdentity(left, right)` - Test whether two counting identity values are equivalent in Combinatorics. +99. `combinatoricsGenerateExampleCountingIdentity(size=3)` - Generate a small documented example of a counting identity. +100. `combinatoricsDocumentCountingIdentity(value)` - Return a structured explanation of a counting identity and related assumptions. + +### Geometry + +Core object families: + +- point +- line +- polygon +- circle +- geometric transform + +Candidate functions: + +1. `geometryValidatePoint(value)` - Validate the point representation and domain rules for Geometry. +2. `geometryConstructPoint(*args)` - Construct a point from explicit inputs for Geometry. +3. `geometryNormalizePoint(value)` - Normalize a point into the standard Geometry representation. +4. `geometryCanonicalizePoint(value)` - Canonicalize a point so equivalent inputs share one form. +5. `geometryParsePoint(text)` - Parse a text or structured value into a point. +6. `geometryFormatPoint(value)` - Format a point for deterministic user-facing output. +7. `geometryComparePoint(left, right)` - Compare two point values under the conventions of Geometry. +8. `geometryCombinePoint(left, right)` - Combine two point values with the natural operation for Geometry. +9. `geometryDecomposePoint(value)` - Decompose a point into simpler or canonical components. +10. `geometryEvaluatePoint(value, point=None)` - Evaluate a point at a point, sample, or finite model. +11. `geometryComputePoint(value)` - Compute the central numerical or symbolic data of a point. +12. `geometryEstimatePoint(value, samples=None)` - Estimate a point property from finite samples or approximations. +13. `geometryApproximatePoint(value, tolerance=1e-9)` - Approximate a point with explicit tolerance controls. +14. `geometryTransformPoint(value, mapping)` - Transform a point through a map, operator, or representation change. +15. `geometrySimplifyPoint(value)` - Simplify a point without changing its mathematical meaning. +16. `geometryEnumeratePoint(value, limit=None)` - Enumerate finite members, cases, or derived objects for a point. +17. `geometryClassifyPoint(value)` - Classify a point by its standard Geometry invariants. +18. `geometryTestEquivalencePoint(left, right)` - Test whether two point values are equivalent in Geometry. +19. `geometryGenerateExamplePoint(size=3)` - Generate a small documented example of a point. +20. `geometryDocumentPoint(value)` - Return a structured explanation of a point and related assumptions. +21. `geometryValidateLine(value)` - Validate the line representation and domain rules for Geometry. +22. `geometryConstructLine(*args)` - Construct a line from explicit inputs for Geometry. +23. `geometryNormalizeLine(value)` - Normalize a line into the standard Geometry representation. +24. `geometryCanonicalizeLine(value)` - Canonicalize a line so equivalent inputs share one form. +25. `geometryParseLine(text)` - Parse a text or structured value into a line. +26. `geometryFormatLine(value)` - Format a line for deterministic user-facing output. +27. `geometryCompareLine(left, right)` - Compare two line values under the conventions of Geometry. +28. `geometryCombineLine(left, right)` - Combine two line values with the natural operation for Geometry. +29. `geometryDecomposeLine(value)` - Decompose a line into simpler or canonical components. +30. `geometryEvaluateLine(value, point=None)` - Evaluate a line at a point, sample, or finite model. +31. `geometryComputeLine(value)` - Compute the central numerical or symbolic data of a line. +32. `geometryEstimateLine(value, samples=None)` - Estimate a line property from finite samples or approximations. +33. `geometryApproximateLine(value, tolerance=1e-9)` - Approximate a line with explicit tolerance controls. +34. `geometryTransformLine(value, mapping)` - Transform a line through a map, operator, or representation change. +35. `geometrySimplifyLine(value)` - Simplify a line without changing its mathematical meaning. +36. `geometryEnumerateLine(value, limit=None)` - Enumerate finite members, cases, or derived objects for a line. +37. `geometryClassifyLine(value)` - Classify a line by its standard Geometry invariants. +38. `geometryTestEquivalenceLine(left, right)` - Test whether two line values are equivalent in Geometry. +39. `geometryGenerateExampleLine(size=3)` - Generate a small documented example of a line. +40. `geometryDocumentLine(value)` - Return a structured explanation of a line and related assumptions. +41. `geometryValidatePolygon(value)` - Validate the polygon representation and domain rules for Geometry. +42. `geometryConstructPolygon(*args)` - Construct a polygon from explicit inputs for Geometry. +43. `geometryNormalizePolygon(value)` - Normalize a polygon into the standard Geometry representation. +44. `geometryCanonicalizePolygon(value)` - Canonicalize a polygon so equivalent inputs share one form. +45. `geometryParsePolygon(text)` - Parse a text or structured value into a polygon. +46. `geometryFormatPolygon(value)` - Format a polygon for deterministic user-facing output. +47. `geometryComparePolygon(left, right)` - Compare two polygon values under the conventions of Geometry. +48. `geometryCombinePolygon(left, right)` - Combine two polygon values with the natural operation for Geometry. +49. `geometryDecomposePolygon(value)` - Decompose a polygon into simpler or canonical components. +50. `geometryEvaluatePolygon(value, point=None)` - Evaluate a polygon at a point, sample, or finite model. +51. `geometryComputePolygon(value)` - Compute the central numerical or symbolic data of a polygon. +52. `geometryEstimatePolygon(value, samples=None)` - Estimate a polygon property from finite samples or approximations. +53. `geometryApproximatePolygon(value, tolerance=1e-9)` - Approximate a polygon with explicit tolerance controls. +54. `geometryTransformPolygon(value, mapping)` - Transform a polygon through a map, operator, or representation change. +55. `geometrySimplifyPolygon(value)` - Simplify a polygon without changing its mathematical meaning. +56. `geometryEnumeratePolygon(value, limit=None)` - Enumerate finite members, cases, or derived objects for a polygon. +57. `geometryClassifyPolygon(value)` - Classify a polygon by its standard Geometry invariants. +58. `geometryTestEquivalencePolygon(left, right)` - Test whether two polygon values are equivalent in Geometry. +59. `geometryGenerateExamplePolygon(size=3)` - Generate a small documented example of a polygon. +60. `geometryDocumentPolygon(value)` - Return a structured explanation of a polygon and related assumptions. +61. `geometryValidateCircle(value)` - Validate the circle representation and domain rules for Geometry. +62. `geometryConstructCircle(*args)` - Construct a circle from explicit inputs for Geometry. +63. `geometryNormalizeCircle(value)` - Normalize a circle into the standard Geometry representation. +64. `geometryCanonicalizeCircle(value)` - Canonicalize a circle so equivalent inputs share one form. +65. `geometryParseCircle(text)` - Parse a text or structured value into a circle. +66. `geometryFormatCircle(value)` - Format a circle for deterministic user-facing output. +67. `geometryCompareCircle(left, right)` - Compare two circle values under the conventions of Geometry. +68. `geometryCombineCircle(left, right)` - Combine two circle values with the natural operation for Geometry. +69. `geometryDecomposeCircle(value)` - Decompose a circle into simpler or canonical components. +70. `geometryEvaluateCircle(value, point=None)` - Evaluate a circle at a point, sample, or finite model. +71. `geometryComputeCircle(value)` - Compute the central numerical or symbolic data of a circle. +72. `geometryEstimateCircle(value, samples=None)` - Estimate a circle property from finite samples or approximations. +73. `geometryApproximateCircle(value, tolerance=1e-9)` - Approximate a circle with explicit tolerance controls. +74. `geometryTransformCircle(value, mapping)` - Transform a circle through a map, operator, or representation change. +75. `geometrySimplifyCircle(value)` - Simplify a circle without changing its mathematical meaning. +76. `geometryEnumerateCircle(value, limit=None)` - Enumerate finite members, cases, or derived objects for a circle. +77. `geometryClassifyCircle(value)` - Classify a circle by its standard Geometry invariants. +78. `geometryTestEquivalenceCircle(left, right)` - Test whether two circle values are equivalent in Geometry. +79. `geometryGenerateExampleCircle(size=3)` - Generate a small documented example of a circle. +80. `geometryDocumentCircle(value)` - Return a structured explanation of a circle and related assumptions. +81. `geometryValidateGeometricTransform(value)` - Validate the geometric transform representation and domain rules for Geometry. +82. `geometryConstructGeometricTransform(*args)` - Construct a geometric transform from explicit inputs for Geometry. +83. `geometryNormalizeGeometricTransform(value)` - Normalize a geometric transform into the standard Geometry representation. +84. `geometryCanonicalizeGeometricTransform(value)` - Canonicalize a geometric transform so equivalent inputs share one form. +85. `geometryParseGeometricTransform(text)` - Parse a text or structured value into a geometric transform. +86. `geometryFormatGeometricTransform(value)` - Format a geometric transform for deterministic user-facing output. +87. `geometryCompareGeometricTransform(left, right)` - Compare two geometric transform values under the conventions of Geometry. +88. `geometryCombineGeometricTransform(left, right)` - Combine two geometric transform values with the natural operation for Geometry. +89. `geometryDecomposeGeometricTransform(value)` - Decompose a geometric transform into simpler or canonical components. +90. `geometryEvaluateGeometricTransform(value, point=None)` - Evaluate a geometric transform at a point, sample, or finite model. +91. `geometryComputeGeometricTransform(value)` - Compute the central numerical or symbolic data of a geometric transform. +92. `geometryEstimateGeometricTransform(value, samples=None)` - Estimate a geometric transform property from finite samples or approximations. +93. `geometryApproximateGeometricTransform(value, tolerance=1e-9)` - Approximate a geometric transform with explicit tolerance controls. +94. `geometryTransformGeometricTransform(value, mapping)` - Transform a geometric transform through a map, operator, or representation change. +95. `geometrySimplifyGeometricTransform(value)` - Simplify a geometric transform without changing its mathematical meaning. +96. `geometryEnumerateGeometricTransform(value, limit=None)` - Enumerate finite members, cases, or derived objects for a geometric transform. +97. `geometryClassifyGeometricTransform(value)` - Classify a geometric transform by its standard Geometry invariants. +98. `geometryTestEquivalenceGeometricTransform(left, right)` - Test whether two geometric transform values are equivalent in Geometry. +99. `geometryGenerateExampleGeometricTransform(size=3)` - Generate a small documented example of a geometric transform. +100. `geometryDocumentGeometricTransform(value)` - Return a structured explanation of a geometric transform and related assumptions. + +### Mathematical Logic + +Core object families: + +- proposition +- formula +- truth assignment +- inference rule +- logical theory + +Candidate functions: + +1. `mathematicalLogicValidateProposition(value)` - Validate the proposition representation and domain rules for Mathematical Logic. +2. `mathematicalLogicConstructProposition(*args)` - Construct a proposition from explicit inputs for Mathematical Logic. +3. `mathematicalLogicNormalizeProposition(value)` - Normalize a proposition into the standard Mathematical Logic representation. +4. `mathematicalLogicCanonicalizeProposition(value)` - Canonicalize a proposition so equivalent inputs share one form. +5. `mathematicalLogicParseProposition(text)` - Parse a text or structured value into a proposition. +6. `mathematicalLogicFormatProposition(value)` - Format a proposition for deterministic user-facing output. +7. `mathematicalLogicCompareProposition(left, right)` - Compare two proposition values under the conventions of Mathematical Logic. +8. `mathematicalLogicCombineProposition(left, right)` - Combine two proposition values with the natural operation for Mathematical Logic. +9. `mathematicalLogicDecomposeProposition(value)` - Decompose a proposition into simpler or canonical components. +10. `mathematicalLogicEvaluateProposition(value, point=None)` - Evaluate a proposition at a point, sample, or finite model. +11. `mathematicalLogicComputeProposition(value)` - Compute the central numerical or symbolic data of a proposition. +12. `mathematicalLogicEstimateProposition(value, samples=None)` - Estimate a proposition property from finite samples or approximations. +13. `mathematicalLogicApproximateProposition(value, tolerance=1e-9)` - Approximate a proposition with explicit tolerance controls. +14. `mathematicalLogicTransformProposition(value, mapping)` - Transform a proposition through a map, operator, or representation change. +15. `mathematicalLogicSimplifyProposition(value)` - Simplify a proposition without changing its mathematical meaning. +16. `mathematicalLogicEnumerateProposition(value, limit=None)` - Enumerate finite members, cases, or derived objects for a proposition. +17. `mathematicalLogicClassifyProposition(value)` - Classify a proposition by its standard Mathematical Logic invariants. +18. `mathematicalLogicTestEquivalenceProposition(left, right)` - Test whether two proposition values are equivalent in Mathematical Logic. +19. `mathematicalLogicGenerateExampleProposition(size=3)` - Generate a small documented example of a proposition. +20. `mathematicalLogicDocumentProposition(value)` - Return a structured explanation of a proposition and related assumptions. +21. `mathematicalLogicValidateFormula(value)` - Validate the formula representation and domain rules for Mathematical Logic. +22. `mathematicalLogicConstructFormula(*args)` - Construct a formula from explicit inputs for Mathematical Logic. +23. `mathematicalLogicNormalizeFormula(value)` - Normalize a formula into the standard Mathematical Logic representation. +24. `mathematicalLogicCanonicalizeFormula(value)` - Canonicalize a formula so equivalent inputs share one form. +25. `mathematicalLogicParseFormula(text)` - Parse a text or structured value into a formula. +26. `mathematicalLogicFormatFormula(value)` - Format a formula for deterministic user-facing output. +27. `mathematicalLogicCompareFormula(left, right)` - Compare two formula values under the conventions of Mathematical Logic. +28. `mathematicalLogicCombineFormula(left, right)` - Combine two formula values with the natural operation for Mathematical Logic. +29. `mathematicalLogicDecomposeFormula(value)` - Decompose a formula into simpler or canonical components. +30. `mathematicalLogicEvaluateFormula(value, point=None)` - Evaluate a formula at a point, sample, or finite model. +31. `mathematicalLogicComputeFormula(value)` - Compute the central numerical or symbolic data of a formula. +32. `mathematicalLogicEstimateFormula(value, samples=None)` - Estimate a formula property from finite samples or approximations. +33. `mathematicalLogicApproximateFormula(value, tolerance=1e-9)` - Approximate a formula with explicit tolerance controls. +34. `mathematicalLogicTransformFormula(value, mapping)` - Transform a formula through a map, operator, or representation change. +35. `mathematicalLogicSimplifyFormula(value)` - Simplify a formula without changing its mathematical meaning. +36. `mathematicalLogicEnumerateFormula(value, limit=None)` - Enumerate finite members, cases, or derived objects for a formula. +37. `mathematicalLogicClassifyFormula(value)` - Classify a formula by its standard Mathematical Logic invariants. +38. `mathematicalLogicTestEquivalenceFormula(left, right)` - Test whether two formula values are equivalent in Mathematical Logic. +39. `mathematicalLogicGenerateExampleFormula(size=3)` - Generate a small documented example of a formula. +40. `mathematicalLogicDocumentFormula(value)` - Return a structured explanation of a formula and related assumptions. +41. `mathematicalLogicValidateTruthAssignment(value)` - Validate the truth assignment representation and domain rules for Mathematical Logic. +42. `mathematicalLogicConstructTruthAssignment(*args)` - Construct a truth assignment from explicit inputs for Mathematical Logic. +43. `mathematicalLogicNormalizeTruthAssignment(value)` - Normalize a truth assignment into the standard Mathematical Logic representation. +44. `mathematicalLogicCanonicalizeTruthAssignment(value)` - Canonicalize a truth assignment so equivalent inputs share one form. +45. `mathematicalLogicParseTruthAssignment(text)` - Parse a text or structured value into a truth assignment. +46. `mathematicalLogicFormatTruthAssignment(value)` - Format a truth assignment for deterministic user-facing output. +47. `mathematicalLogicCompareTruthAssignment(left, right)` - Compare two truth assignment values under the conventions of Mathematical Logic. +48. `mathematicalLogicCombineTruthAssignment(left, right)` - Combine two truth assignment values with the natural operation for Mathematical Logic. +49. `mathematicalLogicDecomposeTruthAssignment(value)` - Decompose a truth assignment into simpler or canonical components. +50. `mathematicalLogicEvaluateTruthAssignment(value, point=None)` - Evaluate a truth assignment at a point, sample, or finite model. +51. `mathematicalLogicComputeTruthAssignment(value)` - Compute the central numerical or symbolic data of a truth assignment. +52. `mathematicalLogicEstimateTruthAssignment(value, samples=None)` - Estimate a truth assignment property from finite samples or approximations. +53. `mathematicalLogicApproximateTruthAssignment(value, tolerance=1e-9)` - Approximate a truth assignment with explicit tolerance controls. +54. `mathematicalLogicTransformTruthAssignment(value, mapping)` - Transform a truth assignment through a map, operator, or representation change. +55. `mathematicalLogicSimplifyTruthAssignment(value)` - Simplify a truth assignment without changing its mathematical meaning. +56. `mathematicalLogicEnumerateTruthAssignment(value, limit=None)` - Enumerate finite members, cases, or derived objects for a truth assignment. +57. `mathematicalLogicClassifyTruthAssignment(value)` - Classify a truth assignment by its standard Mathematical Logic invariants. +58. `mathematicalLogicTestEquivalenceTruthAssignment(left, right)` - Test whether two truth assignment values are equivalent in Mathematical Logic. +59. `mathematicalLogicGenerateExampleTruthAssignment(size=3)` - Generate a small documented example of a truth assignment. +60. `mathematicalLogicDocumentTruthAssignment(value)` - Return a structured explanation of a truth assignment and related assumptions. +61. `mathematicalLogicValidateInferenceRule(value)` - Validate the inference rule representation and domain rules for Mathematical Logic. +62. `mathematicalLogicConstructInferenceRule(*args)` - Construct a inference rule from explicit inputs for Mathematical Logic. +63. `mathematicalLogicNormalizeInferenceRule(value)` - Normalize a inference rule into the standard Mathematical Logic representation. +64. `mathematicalLogicCanonicalizeInferenceRule(value)` - Canonicalize a inference rule so equivalent inputs share one form. +65. `mathematicalLogicParseInferenceRule(text)` - Parse a text or structured value into a inference rule. +66. `mathematicalLogicFormatInferenceRule(value)` - Format a inference rule for deterministic user-facing output. +67. `mathematicalLogicCompareInferenceRule(left, right)` - Compare two inference rule values under the conventions of Mathematical Logic. +68. `mathematicalLogicCombineInferenceRule(left, right)` - Combine two inference rule values with the natural operation for Mathematical Logic. +69. `mathematicalLogicDecomposeInferenceRule(value)` - Decompose a inference rule into simpler or canonical components. +70. `mathematicalLogicEvaluateInferenceRule(value, point=None)` - Evaluate a inference rule at a point, sample, or finite model. +71. `mathematicalLogicComputeInferenceRule(value)` - Compute the central numerical or symbolic data of a inference rule. +72. `mathematicalLogicEstimateInferenceRule(value, samples=None)` - Estimate a inference rule property from finite samples or approximations. +73. `mathematicalLogicApproximateInferenceRule(value, tolerance=1e-9)` - Approximate a inference rule with explicit tolerance controls. +74. `mathematicalLogicTransformInferenceRule(value, mapping)` - Transform a inference rule through a map, operator, or representation change. +75. `mathematicalLogicSimplifyInferenceRule(value)` - Simplify a inference rule without changing its mathematical meaning. +76. `mathematicalLogicEnumerateInferenceRule(value, limit=None)` - Enumerate finite members, cases, or derived objects for a inference rule. +77. `mathematicalLogicClassifyInferenceRule(value)` - Classify a inference rule by its standard Mathematical Logic invariants. +78. `mathematicalLogicTestEquivalenceInferenceRule(left, right)` - Test whether two inference rule values are equivalent in Mathematical Logic. +79. `mathematicalLogicGenerateExampleInferenceRule(size=3)` - Generate a small documented example of a inference rule. +80. `mathematicalLogicDocumentInferenceRule(value)` - Return a structured explanation of a inference rule and related assumptions. +81. `mathematicalLogicValidateLogicalTheory(value)` - Validate the logical theory representation and domain rules for Mathematical Logic. +82. `mathematicalLogicConstructLogicalTheory(*args)` - Construct a logical theory from explicit inputs for Mathematical Logic. +83. `mathematicalLogicNormalizeLogicalTheory(value)` - Normalize a logical theory into the standard Mathematical Logic representation. +84. `mathematicalLogicCanonicalizeLogicalTheory(value)` - Canonicalize a logical theory so equivalent inputs share one form. +85. `mathematicalLogicParseLogicalTheory(text)` - Parse a text or structured value into a logical theory. +86. `mathematicalLogicFormatLogicalTheory(value)` - Format a logical theory for deterministic user-facing output. +87. `mathematicalLogicCompareLogicalTheory(left, right)` - Compare two logical theory values under the conventions of Mathematical Logic. +88. `mathematicalLogicCombineLogicalTheory(left, right)` - Combine two logical theory values with the natural operation for Mathematical Logic. +89. `mathematicalLogicDecomposeLogicalTheory(value)` - Decompose a logical theory into simpler or canonical components. +90. `mathematicalLogicEvaluateLogicalTheory(value, point=None)` - Evaluate a logical theory at a point, sample, or finite model. +91. `mathematicalLogicComputeLogicalTheory(value)` - Compute the central numerical or symbolic data of a logical theory. +92. `mathematicalLogicEstimateLogicalTheory(value, samples=None)` - Estimate a logical theory property from finite samples or approximations. +93. `mathematicalLogicApproximateLogicalTheory(value, tolerance=1e-9)` - Approximate a logical theory with explicit tolerance controls. +94. `mathematicalLogicTransformLogicalTheory(value, mapping)` - Transform a logical theory through a map, operator, or representation change. +95. `mathematicalLogicSimplifyLogicalTheory(value)` - Simplify a logical theory without changing its mathematical meaning. +96. `mathematicalLogicEnumerateLogicalTheory(value, limit=None)` - Enumerate finite members, cases, or derived objects for a logical theory. +97. `mathematicalLogicClassifyLogicalTheory(value)` - Classify a logical theory by its standard Mathematical Logic invariants. +98. `mathematicalLogicTestEquivalenceLogicalTheory(left, right)` - Test whether two logical theory values are equivalent in Mathematical Logic. +99. `mathematicalLogicGenerateExampleLogicalTheory(size=3)` - Generate a small documented example of a logical theory. +100. `mathematicalLogicDocumentLogicalTheory(value)` - Return a structured explanation of a logical theory and related assumptions. + +### Optimization + +Core object families: + +- objective function +- constraint set +- search state +- descent step +- optimality condition + +Candidate functions: + +1. `optimizationValidateObjectiveFunction(value)` - Validate the objective function representation and domain rules for Optimization. +2. `optimizationConstructObjectiveFunction(*args)` - Construct a objective function from explicit inputs for Optimization. +3. `optimizationNormalizeObjectiveFunction(value)` - Normalize a objective function into the standard Optimization representation. +4. `optimizationCanonicalizeObjectiveFunction(value)` - Canonicalize a objective function so equivalent inputs share one form. +5. `optimizationParseObjectiveFunction(text)` - Parse a text or structured value into a objective function. +6. `optimizationFormatObjectiveFunction(value)` - Format a objective function for deterministic user-facing output. +7. `optimizationCompareObjectiveFunction(left, right)` - Compare two objective function values under the conventions of Optimization. +8. `optimizationCombineObjectiveFunction(left, right)` - Combine two objective function values with the natural operation for Optimization. +9. `optimizationDecomposeObjectiveFunction(value)` - Decompose a objective function into simpler or canonical components. +10. `optimizationEvaluateObjectiveFunction(value, point=None)` - Evaluate a objective function at a point, sample, or finite model. +11. `optimizationComputeObjectiveFunction(value)` - Compute the central numerical or symbolic data of a objective function. +12. `optimizationEstimateObjectiveFunction(value, samples=None)` - Estimate a objective function property from finite samples or approximations. +13. `optimizationApproximateObjectiveFunction(value, tolerance=1e-9)` - Approximate a objective function with explicit tolerance controls. +14. `optimizationTransformObjectiveFunction(value, mapping)` - Transform a objective function through a map, operator, or representation change. +15. `optimizationSimplifyObjectiveFunction(value)` - Simplify a objective function without changing its mathematical meaning. +16. `optimizationEnumerateObjectiveFunction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a objective function. +17. `optimizationClassifyObjectiveFunction(value)` - Classify a objective function by its standard Optimization invariants. +18. `optimizationTestEquivalenceObjectiveFunction(left, right)` - Test whether two objective function values are equivalent in Optimization. +19. `optimizationGenerateExampleObjectiveFunction(size=3)` - Generate a small documented example of a objective function. +20. `optimizationDocumentObjectiveFunction(value)` - Return a structured explanation of a objective function and related assumptions. +21. `optimizationValidateConstraintSet(value)` - Validate the constraint set representation and domain rules for Optimization. +22. `optimizationConstructConstraintSet(*args)` - Construct a constraint set from explicit inputs for Optimization. +23. `optimizationNormalizeConstraintSet(value)` - Normalize a constraint set into the standard Optimization representation. +24. `optimizationCanonicalizeConstraintSet(value)` - Canonicalize a constraint set so equivalent inputs share one form. +25. `optimizationParseConstraintSet(text)` - Parse a text or structured value into a constraint set. +26. `optimizationFormatConstraintSet(value)` - Format a constraint set for deterministic user-facing output. +27. `optimizationCompareConstraintSet(left, right)` - Compare two constraint set values under the conventions of Optimization. +28. `optimizationCombineConstraintSet(left, right)` - Combine two constraint set values with the natural operation for Optimization. +29. `optimizationDecomposeConstraintSet(value)` - Decompose a constraint set into simpler or canonical components. +30. `optimizationEvaluateConstraintSet(value, point=None)` - Evaluate a constraint set at a point, sample, or finite model. +31. `optimizationComputeConstraintSet(value)` - Compute the central numerical or symbolic data of a constraint set. +32. `optimizationEstimateConstraintSet(value, samples=None)` - Estimate a constraint set property from finite samples or approximations. +33. `optimizationApproximateConstraintSet(value, tolerance=1e-9)` - Approximate a constraint set with explicit tolerance controls. +34. `optimizationTransformConstraintSet(value, mapping)` - Transform a constraint set through a map, operator, or representation change. +35. `optimizationSimplifyConstraintSet(value)` - Simplify a constraint set without changing its mathematical meaning. +36. `optimizationEnumerateConstraintSet(value, limit=None)` - Enumerate finite members, cases, or derived objects for a constraint set. +37. `optimizationClassifyConstraintSet(value)` - Classify a constraint set by its standard Optimization invariants. +38. `optimizationTestEquivalenceConstraintSet(left, right)` - Test whether two constraint set values are equivalent in Optimization. +39. `optimizationGenerateExampleConstraintSet(size=3)` - Generate a small documented example of a constraint set. +40. `optimizationDocumentConstraintSet(value)` - Return a structured explanation of a constraint set and related assumptions. +41. `optimizationValidateSearchState(value)` - Validate the search state representation and domain rules for Optimization. +42. `optimizationConstructSearchState(*args)` - Construct a search state from explicit inputs for Optimization. +43. `optimizationNormalizeSearchState(value)` - Normalize a search state into the standard Optimization representation. +44. `optimizationCanonicalizeSearchState(value)` - Canonicalize a search state so equivalent inputs share one form. +45. `optimizationParseSearchState(text)` - Parse a text or structured value into a search state. +46. `optimizationFormatSearchState(value)` - Format a search state for deterministic user-facing output. +47. `optimizationCompareSearchState(left, right)` - Compare two search state values under the conventions of Optimization. +48. `optimizationCombineSearchState(left, right)` - Combine two search state values with the natural operation for Optimization. +49. `optimizationDecomposeSearchState(value)` - Decompose a search state into simpler or canonical components. +50. `optimizationEvaluateSearchState(value, point=None)` - Evaluate a search state at a point, sample, or finite model. +51. `optimizationComputeSearchState(value)` - Compute the central numerical or symbolic data of a search state. +52. `optimizationEstimateSearchState(value, samples=None)` - Estimate a search state property from finite samples or approximations. +53. `optimizationApproximateSearchState(value, tolerance=1e-9)` - Approximate a search state with explicit tolerance controls. +54. `optimizationTransformSearchState(value, mapping)` - Transform a search state through a map, operator, or representation change. +55. `optimizationSimplifySearchState(value)` - Simplify a search state without changing its mathematical meaning. +56. `optimizationEnumerateSearchState(value, limit=None)` - Enumerate finite members, cases, or derived objects for a search state. +57. `optimizationClassifySearchState(value)` - Classify a search state by its standard Optimization invariants. +58. `optimizationTestEquivalenceSearchState(left, right)` - Test whether two search state values are equivalent in Optimization. +59. `optimizationGenerateExampleSearchState(size=3)` - Generate a small documented example of a search state. +60. `optimizationDocumentSearchState(value)` - Return a structured explanation of a search state and related assumptions. +61. `optimizationValidateDescentStep(value)` - Validate the descent step representation and domain rules for Optimization. +62. `optimizationConstructDescentStep(*args)` - Construct a descent step from explicit inputs for Optimization. +63. `optimizationNormalizeDescentStep(value)` - Normalize a descent step into the standard Optimization representation. +64. `optimizationCanonicalizeDescentStep(value)` - Canonicalize a descent step so equivalent inputs share one form. +65. `optimizationParseDescentStep(text)` - Parse a text or structured value into a descent step. +66. `optimizationFormatDescentStep(value)` - Format a descent step for deterministic user-facing output. +67. `optimizationCompareDescentStep(left, right)` - Compare two descent step values under the conventions of Optimization. +68. `optimizationCombineDescentStep(left, right)` - Combine two descent step values with the natural operation for Optimization. +69. `optimizationDecomposeDescentStep(value)` - Decompose a descent step into simpler or canonical components. +70. `optimizationEvaluateDescentStep(value, point=None)` - Evaluate a descent step at a point, sample, or finite model. +71. `optimizationComputeDescentStep(value)` - Compute the central numerical or symbolic data of a descent step. +72. `optimizationEstimateDescentStep(value, samples=None)` - Estimate a descent step property from finite samples or approximations. +73. `optimizationApproximateDescentStep(value, tolerance=1e-9)` - Approximate a descent step with explicit tolerance controls. +74. `optimizationTransformDescentStep(value, mapping)` - Transform a descent step through a map, operator, or representation change. +75. `optimizationSimplifyDescentStep(value)` - Simplify a descent step without changing its mathematical meaning. +76. `optimizationEnumerateDescentStep(value, limit=None)` - Enumerate finite members, cases, or derived objects for a descent step. +77. `optimizationClassifyDescentStep(value)` - Classify a descent step by its standard Optimization invariants. +78. `optimizationTestEquivalenceDescentStep(left, right)` - Test whether two descent step values are equivalent in Optimization. +79. `optimizationGenerateExampleDescentStep(size=3)` - Generate a small documented example of a descent step. +80. `optimizationDocumentDescentStep(value)` - Return a structured explanation of a descent step and related assumptions. +81. `optimizationValidateOptimalityCondition(value)` - Validate the optimality condition representation and domain rules for Optimization. +82. `optimizationConstructOptimalityCondition(*args)` - Construct a optimality condition from explicit inputs for Optimization. +83. `optimizationNormalizeOptimalityCondition(value)` - Normalize a optimality condition into the standard Optimization representation. +84. `optimizationCanonicalizeOptimalityCondition(value)` - Canonicalize a optimality condition so equivalent inputs share one form. +85. `optimizationParseOptimalityCondition(text)` - Parse a text or structured value into a optimality condition. +86. `optimizationFormatOptimalityCondition(value)` - Format a optimality condition for deterministic user-facing output. +87. `optimizationCompareOptimalityCondition(left, right)` - Compare two optimality condition values under the conventions of Optimization. +88. `optimizationCombineOptimalityCondition(left, right)` - Combine two optimality condition values with the natural operation for Optimization. +89. `optimizationDecomposeOptimalityCondition(value)` - Decompose a optimality condition into simpler or canonical components. +90. `optimizationEvaluateOptimalityCondition(value, point=None)` - Evaluate a optimality condition at a point, sample, or finite model. +91. `optimizationComputeOptimalityCondition(value)` - Compute the central numerical or symbolic data of a optimality condition. +92. `optimizationEstimateOptimalityCondition(value, samples=None)` - Estimate a optimality condition property from finite samples or approximations. +93. `optimizationApproximateOptimalityCondition(value, tolerance=1e-9)` - Approximate a optimality condition with explicit tolerance controls. +94. `optimizationTransformOptimalityCondition(value, mapping)` - Transform a optimality condition through a map, operator, or representation change. +95. `optimizationSimplifyOptimalityCondition(value)` - Simplify a optimality condition without changing its mathematical meaning. +96. `optimizationEnumerateOptimalityCondition(value, limit=None)` - Enumerate finite members, cases, or derived objects for a optimality condition. +97. `optimizationClassifyOptimalityCondition(value)` - Classify a optimality condition by its standard Optimization invariants. +98. `optimizationTestEquivalenceOptimalityCondition(left, right)` - Test whether two optimality condition values are equivalent in Optimization. +99. `optimizationGenerateExampleOptimalityCondition(size=3)` - Generate a small documented example of a optimality condition. +100. `optimizationDocumentOptimalityCondition(value)` - Return a structured explanation of a optimality condition and related assumptions. + +### Information Theory + +Core object families: + +- probability vector +- code distribution +- channel +- entropy measure +- information divergence + +Candidate functions: + +1. `informationTheoryValidateProbabilityVector(value)` - Validate the probability vector representation and domain rules for Information Theory. +2. `informationTheoryConstructProbabilityVector(*args)` - Construct a probability vector from explicit inputs for Information Theory. +3. `informationTheoryNormalizeProbabilityVector(value)` - Normalize a probability vector into the standard Information Theory representation. +4. `informationTheoryCanonicalizeProbabilityVector(value)` - Canonicalize a probability vector so equivalent inputs share one form. +5. `informationTheoryParseProbabilityVector(text)` - Parse a text or structured value into a probability vector. +6. `informationTheoryFormatProbabilityVector(value)` - Format a probability vector for deterministic user-facing output. +7. `informationTheoryCompareProbabilityVector(left, right)` - Compare two probability vector values under the conventions of Information Theory. +8. `informationTheoryCombineProbabilityVector(left, right)` - Combine two probability vector values with the natural operation for Information Theory. +9. `informationTheoryDecomposeProbabilityVector(value)` - Decompose a probability vector into simpler or canonical components. +10. `informationTheoryEvaluateProbabilityVector(value, point=None)` - Evaluate a probability vector at a point, sample, or finite model. +11. `informationTheoryComputeProbabilityVector(value)` - Compute the central numerical or symbolic data of a probability vector. +12. `informationTheoryEstimateProbabilityVector(value, samples=None)` - Estimate a probability vector property from finite samples or approximations. +13. `informationTheoryApproximateProbabilityVector(value, tolerance=1e-9)` - Approximate a probability vector with explicit tolerance controls. +14. `informationTheoryTransformProbabilityVector(value, mapping)` - Transform a probability vector through a map, operator, or representation change. +15. `informationTheorySimplifyProbabilityVector(value)` - Simplify a probability vector without changing its mathematical meaning. +16. `informationTheoryEnumerateProbabilityVector(value, limit=None)` - Enumerate finite members, cases, or derived objects for a probability vector. +17. `informationTheoryClassifyProbabilityVector(value)` - Classify a probability vector by its standard Information Theory invariants. +18. `informationTheoryTestEquivalenceProbabilityVector(left, right)` - Test whether two probability vector values are equivalent in Information Theory. +19. `informationTheoryGenerateExampleProbabilityVector(size=3)` - Generate a small documented example of a probability vector. +20. `informationTheoryDocumentProbabilityVector(value)` - Return a structured explanation of a probability vector and related assumptions. +21. `informationTheoryValidateCodeDistribution(value)` - Validate the code distribution representation and domain rules for Information Theory. +22. `informationTheoryConstructCodeDistribution(*args)` - Construct a code distribution from explicit inputs for Information Theory. +23. `informationTheoryNormalizeCodeDistribution(value)` - Normalize a code distribution into the standard Information Theory representation. +24. `informationTheoryCanonicalizeCodeDistribution(value)` - Canonicalize a code distribution so equivalent inputs share one form. +25. `informationTheoryParseCodeDistribution(text)` - Parse a text or structured value into a code distribution. +26. `informationTheoryFormatCodeDistribution(value)` - Format a code distribution for deterministic user-facing output. +27. `informationTheoryCompareCodeDistribution(left, right)` - Compare two code distribution values under the conventions of Information Theory. +28. `informationTheoryCombineCodeDistribution(left, right)` - Combine two code distribution values with the natural operation for Information Theory. +29. `informationTheoryDecomposeCodeDistribution(value)` - Decompose a code distribution into simpler or canonical components. +30. `informationTheoryEvaluateCodeDistribution(value, point=None)` - Evaluate a code distribution at a point, sample, or finite model. +31. `informationTheoryComputeCodeDistribution(value)` - Compute the central numerical or symbolic data of a code distribution. +32. `informationTheoryEstimateCodeDistribution(value, samples=None)` - Estimate a code distribution property from finite samples or approximations. +33. `informationTheoryApproximateCodeDistribution(value, tolerance=1e-9)` - Approximate a code distribution with explicit tolerance controls. +34. `informationTheoryTransformCodeDistribution(value, mapping)` - Transform a code distribution through a map, operator, or representation change. +35. `informationTheorySimplifyCodeDistribution(value)` - Simplify a code distribution without changing its mathematical meaning. +36. `informationTheoryEnumerateCodeDistribution(value, limit=None)` - Enumerate finite members, cases, or derived objects for a code distribution. +37. `informationTheoryClassifyCodeDistribution(value)` - Classify a code distribution by its standard Information Theory invariants. +38. `informationTheoryTestEquivalenceCodeDistribution(left, right)` - Test whether two code distribution values are equivalent in Information Theory. +39. `informationTheoryGenerateExampleCodeDistribution(size=3)` - Generate a small documented example of a code distribution. +40. `informationTheoryDocumentCodeDistribution(value)` - Return a structured explanation of a code distribution and related assumptions. +41. `informationTheoryValidateChannel(value)` - Validate the channel representation and domain rules for Information Theory. +42. `informationTheoryConstructChannel(*args)` - Construct a channel from explicit inputs for Information Theory. +43. `informationTheoryNormalizeChannel(value)` - Normalize a channel into the standard Information Theory representation. +44. `informationTheoryCanonicalizeChannel(value)` - Canonicalize a channel so equivalent inputs share one form. +45. `informationTheoryParseChannel(text)` - Parse a text or structured value into a channel. +46. `informationTheoryFormatChannel(value)` - Format a channel for deterministic user-facing output. +47. `informationTheoryCompareChannel(left, right)` - Compare two channel values under the conventions of Information Theory. +48. `informationTheoryCombineChannel(left, right)` - Combine two channel values with the natural operation for Information Theory. +49. `informationTheoryDecomposeChannel(value)` - Decompose a channel into simpler or canonical components. +50. `informationTheoryEvaluateChannel(value, point=None)` - Evaluate a channel at a point, sample, or finite model. +51. `informationTheoryComputeChannel(value)` - Compute the central numerical or symbolic data of a channel. +52. `informationTheoryEstimateChannel(value, samples=None)` - Estimate a channel property from finite samples or approximations. +53. `informationTheoryApproximateChannel(value, tolerance=1e-9)` - Approximate a channel with explicit tolerance controls. +54. `informationTheoryTransformChannel(value, mapping)` - Transform a channel through a map, operator, or representation change. +55. `informationTheorySimplifyChannel(value)` - Simplify a channel without changing its mathematical meaning. +56. `informationTheoryEnumerateChannel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a channel. +57. `informationTheoryClassifyChannel(value)` - Classify a channel by its standard Information Theory invariants. +58. `informationTheoryTestEquivalenceChannel(left, right)` - Test whether two channel values are equivalent in Information Theory. +59. `informationTheoryGenerateExampleChannel(size=3)` - Generate a small documented example of a channel. +60. `informationTheoryDocumentChannel(value)` - Return a structured explanation of a channel and related assumptions. +61. `informationTheoryValidateEntropyMeasure(value)` - Validate the entropy measure representation and domain rules for Information Theory. +62. `informationTheoryConstructEntropyMeasure(*args)` - Construct a entropy measure from explicit inputs for Information Theory. +63. `informationTheoryNormalizeEntropyMeasure(value)` - Normalize a entropy measure into the standard Information Theory representation. +64. `informationTheoryCanonicalizeEntropyMeasure(value)` - Canonicalize a entropy measure so equivalent inputs share one form. +65. `informationTheoryParseEntropyMeasure(text)` - Parse a text or structured value into a entropy measure. +66. `informationTheoryFormatEntropyMeasure(value)` - Format a entropy measure for deterministic user-facing output. +67. `informationTheoryCompareEntropyMeasure(left, right)` - Compare two entropy measure values under the conventions of Information Theory. +68. `informationTheoryCombineEntropyMeasure(left, right)` - Combine two entropy measure values with the natural operation for Information Theory. +69. `informationTheoryDecomposeEntropyMeasure(value)` - Decompose a entropy measure into simpler or canonical components. +70. `informationTheoryEvaluateEntropyMeasure(value, point=None)` - Evaluate a entropy measure at a point, sample, or finite model. +71. `informationTheoryComputeEntropyMeasure(value)` - Compute the central numerical or symbolic data of a entropy measure. +72. `informationTheoryEstimateEntropyMeasure(value, samples=None)` - Estimate a entropy measure property from finite samples or approximations. +73. `informationTheoryApproximateEntropyMeasure(value, tolerance=1e-9)` - Approximate a entropy measure with explicit tolerance controls. +74. `informationTheoryTransformEntropyMeasure(value, mapping)` - Transform a entropy measure through a map, operator, or representation change. +75. `informationTheorySimplifyEntropyMeasure(value)` - Simplify a entropy measure without changing its mathematical meaning. +76. `informationTheoryEnumerateEntropyMeasure(value, limit=None)` - Enumerate finite members, cases, or derived objects for a entropy measure. +77. `informationTheoryClassifyEntropyMeasure(value)` - Classify a entropy measure by its standard Information Theory invariants. +78. `informationTheoryTestEquivalenceEntropyMeasure(left, right)` - Test whether two entropy measure values are equivalent in Information Theory. +79. `informationTheoryGenerateExampleEntropyMeasure(size=3)` - Generate a small documented example of a entropy measure. +80. `informationTheoryDocumentEntropyMeasure(value)` - Return a structured explanation of a entropy measure and related assumptions. +81. `informationTheoryValidateInformationDivergence(value)` - Validate the information divergence representation and domain rules for Information Theory. +82. `informationTheoryConstructInformationDivergence(*args)` - Construct a information divergence from explicit inputs for Information Theory. +83. `informationTheoryNormalizeInformationDivergence(value)` - Normalize a information divergence into the standard Information Theory representation. +84. `informationTheoryCanonicalizeInformationDivergence(value)` - Canonicalize a information divergence so equivalent inputs share one form. +85. `informationTheoryParseInformationDivergence(text)` - Parse a text or structured value into a information divergence. +86. `informationTheoryFormatInformationDivergence(value)` - Format a information divergence for deterministic user-facing output. +87. `informationTheoryCompareInformationDivergence(left, right)` - Compare two information divergence values under the conventions of Information Theory. +88. `informationTheoryCombineInformationDivergence(left, right)` - Combine two information divergence values with the natural operation for Information Theory. +89. `informationTheoryDecomposeInformationDivergence(value)` - Decompose a information divergence into simpler or canonical components. +90. `informationTheoryEvaluateInformationDivergence(value, point=None)` - Evaluate a information divergence at a point, sample, or finite model. +91. `informationTheoryComputeInformationDivergence(value)` - Compute the central numerical or symbolic data of a information divergence. +92. `informationTheoryEstimateInformationDivergence(value, samples=None)` - Estimate a information divergence property from finite samples or approximations. +93. `informationTheoryApproximateInformationDivergence(value, tolerance=1e-9)` - Approximate a information divergence with explicit tolerance controls. +94. `informationTheoryTransformInformationDivergence(value, mapping)` - Transform a information divergence through a map, operator, or representation change. +95. `informationTheorySimplifyInformationDivergence(value)` - Simplify a information divergence without changing its mathematical meaning. +96. `informationTheoryEnumerateInformationDivergence(value, limit=None)` - Enumerate finite members, cases, or derived objects for a information divergence. +97. `informationTheoryClassifyInformationDivergence(value)` - Classify a information divergence by its standard Information Theory invariants. +98. `informationTheoryTestEquivalenceInformationDivergence(left, right)` - Test whether two information divergence values are equivalent in Information Theory. +99. `informationTheoryGenerateExampleInformationDivergence(size=3)` - Generate a small documented example of a information divergence. +100. `informationTheoryDocumentInformationDivergence(value)` - Return a structured explanation of a information divergence and related assumptions. + +### Category Theory + +Core object families: + +- category +- object +- morphism +- functor +- natural transformation + +Candidate functions: + +1. `categoryTheoryValidateCategory(value)` - Validate the category representation and domain rules for Category Theory. +2. `categoryTheoryConstructCategory(*args)` - Construct a category from explicit inputs for Category Theory. +3. `categoryTheoryNormalizeCategory(value)` - Normalize a category into the standard Category Theory representation. +4. `categoryTheoryCanonicalizeCategory(value)` - Canonicalize a category so equivalent inputs share one form. +5. `categoryTheoryParseCategory(text)` - Parse a text or structured value into a category. +6. `categoryTheoryFormatCategory(value)` - Format a category for deterministic user-facing output. +7. `categoryTheoryCompareCategory(left, right)` - Compare two category values under the conventions of Category Theory. +8. `categoryTheoryCombineCategory(left, right)` - Combine two category values with the natural operation for Category Theory. +9. `categoryTheoryDecomposeCategory(value)` - Decompose a category into simpler or canonical components. +10. `categoryTheoryEvaluateCategory(value, point=None)` - Evaluate a category at a point, sample, or finite model. +11. `categoryTheoryComputeCategory(value)` - Compute the central numerical or symbolic data of a category. +12. `categoryTheoryEstimateCategory(value, samples=None)` - Estimate a category property from finite samples or approximations. +13. `categoryTheoryApproximateCategory(value, tolerance=1e-9)` - Approximate a category with explicit tolerance controls. +14. `categoryTheoryTransformCategory(value, mapping)` - Transform a category through a map, operator, or representation change. +15. `categoryTheorySimplifyCategory(value)` - Simplify a category without changing its mathematical meaning. +16. `categoryTheoryEnumerateCategory(value, limit=None)` - Enumerate finite members, cases, or derived objects for a category. +17. `categoryTheoryClassifyCategory(value)` - Classify a category by its standard Category Theory invariants. +18. `categoryTheoryTestEquivalenceCategory(left, right)` - Test whether two category values are equivalent in Category Theory. +19. `categoryTheoryGenerateExampleCategory(size=3)` - Generate a small documented example of a category. +20. `categoryTheoryDocumentCategory(value)` - Return a structured explanation of a category and related assumptions. +21. `categoryTheoryValidateObject(value)` - Validate the object representation and domain rules for Category Theory. +22. `categoryTheoryConstructObject(*args)` - Construct a object from explicit inputs for Category Theory. +23. `categoryTheoryNormalizeObject(value)` - Normalize a object into the standard Category Theory representation. +24. `categoryTheoryCanonicalizeObject(value)` - Canonicalize a object so equivalent inputs share one form. +25. `categoryTheoryParseObject(text)` - Parse a text or structured value into a object. +26. `categoryTheoryFormatObject(value)` - Format a object for deterministic user-facing output. +27. `categoryTheoryCompareObject(left, right)` - Compare two object values under the conventions of Category Theory. +28. `categoryTheoryCombineObject(left, right)` - Combine two object values with the natural operation for Category Theory. +29. `categoryTheoryDecomposeObject(value)` - Decompose a object into simpler or canonical components. +30. `categoryTheoryEvaluateObject(value, point=None)` - Evaluate a object at a point, sample, or finite model. +31. `categoryTheoryComputeObject(value)` - Compute the central numerical or symbolic data of a object. +32. `categoryTheoryEstimateObject(value, samples=None)` - Estimate a object property from finite samples or approximations. +33. `categoryTheoryApproximateObject(value, tolerance=1e-9)` - Approximate a object with explicit tolerance controls. +34. `categoryTheoryTransformObject(value, mapping)` - Transform a object through a map, operator, or representation change. +35. `categoryTheorySimplifyObject(value)` - Simplify a object without changing its mathematical meaning. +36. `categoryTheoryEnumerateObject(value, limit=None)` - Enumerate finite members, cases, or derived objects for a object. +37. `categoryTheoryClassifyObject(value)` - Classify a object by its standard Category Theory invariants. +38. `categoryTheoryTestEquivalenceObject(left, right)` - Test whether two object values are equivalent in Category Theory. +39. `categoryTheoryGenerateExampleObject(size=3)` - Generate a small documented example of a object. +40. `categoryTheoryDocumentObject(value)` - Return a structured explanation of a object and related assumptions. +41. `categoryTheoryValidateMorphism(value)` - Validate the morphism representation and domain rules for Category Theory. +42. `categoryTheoryConstructMorphism(*args)` - Construct a morphism from explicit inputs for Category Theory. +43. `categoryTheoryNormalizeMorphism(value)` - Normalize a morphism into the standard Category Theory representation. +44. `categoryTheoryCanonicalizeMorphism(value)` - Canonicalize a morphism so equivalent inputs share one form. +45. `categoryTheoryParseMorphism(text)` - Parse a text or structured value into a morphism. +46. `categoryTheoryFormatMorphism(value)` - Format a morphism for deterministic user-facing output. +47. `categoryTheoryCompareMorphism(left, right)` - Compare two morphism values under the conventions of Category Theory. +48. `categoryTheoryCombineMorphism(left, right)` - Combine two morphism values with the natural operation for Category Theory. +49. `categoryTheoryDecomposeMorphism(value)` - Decompose a morphism into simpler or canonical components. +50. `categoryTheoryEvaluateMorphism(value, point=None)` - Evaluate a morphism at a point, sample, or finite model. +51. `categoryTheoryComputeMorphism(value)` - Compute the central numerical or symbolic data of a morphism. +52. `categoryTheoryEstimateMorphism(value, samples=None)` - Estimate a morphism property from finite samples or approximations. +53. `categoryTheoryApproximateMorphism(value, tolerance=1e-9)` - Approximate a morphism with explicit tolerance controls. +54. `categoryTheoryTransformMorphism(value, mapping)` - Transform a morphism through a map, operator, or representation change. +55. `categoryTheorySimplifyMorphism(value)` - Simplify a morphism without changing its mathematical meaning. +56. `categoryTheoryEnumerateMorphism(value, limit=None)` - Enumerate finite members, cases, or derived objects for a morphism. +57. `categoryTheoryClassifyMorphism(value)` - Classify a morphism by its standard Category Theory invariants. +58. `categoryTheoryTestEquivalenceMorphism(left, right)` - Test whether two morphism values are equivalent in Category Theory. +59. `categoryTheoryGenerateExampleMorphism(size=3)` - Generate a small documented example of a morphism. +60. `categoryTheoryDocumentMorphism(value)` - Return a structured explanation of a morphism and related assumptions. +61. `categoryTheoryValidateFunctor(value)` - Validate the functor representation and domain rules for Category Theory. +62. `categoryTheoryConstructFunctor(*args)` - Construct a functor from explicit inputs for Category Theory. +63. `categoryTheoryNormalizeFunctor(value)` - Normalize a functor into the standard Category Theory representation. +64. `categoryTheoryCanonicalizeFunctor(value)` - Canonicalize a functor so equivalent inputs share one form. +65. `categoryTheoryParseFunctor(text)` - Parse a text or structured value into a functor. +66. `categoryTheoryFormatFunctor(value)` - Format a functor for deterministic user-facing output. +67. `categoryTheoryCompareFunctor(left, right)` - Compare two functor values under the conventions of Category Theory. +68. `categoryTheoryCombineFunctor(left, right)` - Combine two functor values with the natural operation for Category Theory. +69. `categoryTheoryDecomposeFunctor(value)` - Decompose a functor into simpler or canonical components. +70. `categoryTheoryEvaluateFunctor(value, point=None)` - Evaluate a functor at a point, sample, or finite model. +71. `categoryTheoryComputeFunctor(value)` - Compute the central numerical or symbolic data of a functor. +72. `categoryTheoryEstimateFunctor(value, samples=None)` - Estimate a functor property from finite samples or approximations. +73. `categoryTheoryApproximateFunctor(value, tolerance=1e-9)` - Approximate a functor with explicit tolerance controls. +74. `categoryTheoryTransformFunctor(value, mapping)` - Transform a functor through a map, operator, or representation change. +75. `categoryTheorySimplifyFunctor(value)` - Simplify a functor without changing its mathematical meaning. +76. `categoryTheoryEnumerateFunctor(value, limit=None)` - Enumerate finite members, cases, or derived objects for a functor. +77. `categoryTheoryClassifyFunctor(value)` - Classify a functor by its standard Category Theory invariants. +78. `categoryTheoryTestEquivalenceFunctor(left, right)` - Test whether two functor values are equivalent in Category Theory. +79. `categoryTheoryGenerateExampleFunctor(size=3)` - Generate a small documented example of a functor. +80. `categoryTheoryDocumentFunctor(value)` - Return a structured explanation of a functor and related assumptions. +81. `categoryTheoryValidateNaturalTransformation(value)` - Validate the natural transformation representation and domain rules for Category Theory. +82. `categoryTheoryConstructNaturalTransformation(*args)` - Construct a natural transformation from explicit inputs for Category Theory. +83. `categoryTheoryNormalizeNaturalTransformation(value)` - Normalize a natural transformation into the standard Category Theory representation. +84. `categoryTheoryCanonicalizeNaturalTransformation(value)` - Canonicalize a natural transformation so equivalent inputs share one form. +85. `categoryTheoryParseNaturalTransformation(text)` - Parse a text or structured value into a natural transformation. +86. `categoryTheoryFormatNaturalTransformation(value)` - Format a natural transformation for deterministic user-facing output. +87. `categoryTheoryCompareNaturalTransformation(left, right)` - Compare two natural transformation values under the conventions of Category Theory. +88. `categoryTheoryCombineNaturalTransformation(left, right)` - Combine two natural transformation values with the natural operation for Category Theory. +89. `categoryTheoryDecomposeNaturalTransformation(value)` - Decompose a natural transformation into simpler or canonical components. +90. `categoryTheoryEvaluateNaturalTransformation(value, point=None)` - Evaluate a natural transformation at a point, sample, or finite model. +91. `categoryTheoryComputeNaturalTransformation(value)` - Compute the central numerical or symbolic data of a natural transformation. +92. `categoryTheoryEstimateNaturalTransformation(value, samples=None)` - Estimate a natural transformation property from finite samples or approximations. +93. `categoryTheoryApproximateNaturalTransformation(value, tolerance=1e-9)` - Approximate a natural transformation with explicit tolerance controls. +94. `categoryTheoryTransformNaturalTransformation(value, mapping)` - Transform a natural transformation through a map, operator, or representation change. +95. `categoryTheorySimplifyNaturalTransformation(value)` - Simplify a natural transformation without changing its mathematical meaning. +96. `categoryTheoryEnumerateNaturalTransformation(value, limit=None)` - Enumerate finite members, cases, or derived objects for a natural transformation. +97. `categoryTheoryClassifyNaturalTransformation(value)` - Classify a natural transformation by its standard Category Theory invariants. +98. `categoryTheoryTestEquivalenceNaturalTransformation(left, right)` - Test whether two natural transformation values are equivalent in Category Theory. +99. `categoryTheoryGenerateExampleNaturalTransformation(size=3)` - Generate a small documented example of a natural transformation. +100. `categoryTheoryDocumentNaturalTransformation(value)` - Return a structured explanation of a natural transformation and related assumptions. + +### Game Theory + +Core object families: + +- game matrix +- strategy +- payoff model +- equilibrium +- coalition + +Candidate functions: + +1. `gameTheoryValidateGameMatrix(value)` - Validate the game matrix representation and domain rules for Game Theory. +2. `gameTheoryConstructGameMatrix(*args)` - Construct a game matrix from explicit inputs for Game Theory. +3. `gameTheoryNormalizeGameMatrix(value)` - Normalize a game matrix into the standard Game Theory representation. +4. `gameTheoryCanonicalizeGameMatrix(value)` - Canonicalize a game matrix so equivalent inputs share one form. +5. `gameTheoryParseGameMatrix(text)` - Parse a text or structured value into a game matrix. +6. `gameTheoryFormatGameMatrix(value)` - Format a game matrix for deterministic user-facing output. +7. `gameTheoryCompareGameMatrix(left, right)` - Compare two game matrix values under the conventions of Game Theory. +8. `gameTheoryCombineGameMatrix(left, right)` - Combine two game matrix values with the natural operation for Game Theory. +9. `gameTheoryDecomposeGameMatrix(value)` - Decompose a game matrix into simpler or canonical components. +10. `gameTheoryEvaluateGameMatrix(value, point=None)` - Evaluate a game matrix at a point, sample, or finite model. +11. `gameTheoryComputeGameMatrix(value)` - Compute the central numerical or symbolic data of a game matrix. +12. `gameTheoryEstimateGameMatrix(value, samples=None)` - Estimate a game matrix property from finite samples or approximations. +13. `gameTheoryApproximateGameMatrix(value, tolerance=1e-9)` - Approximate a game matrix with explicit tolerance controls. +14. `gameTheoryTransformGameMatrix(value, mapping)` - Transform a game matrix through a map, operator, or representation change. +15. `gameTheorySimplifyGameMatrix(value)` - Simplify a game matrix without changing its mathematical meaning. +16. `gameTheoryEnumerateGameMatrix(value, limit=None)` - Enumerate finite members, cases, or derived objects for a game matrix. +17. `gameTheoryClassifyGameMatrix(value)` - Classify a game matrix by its standard Game Theory invariants. +18. `gameTheoryTestEquivalenceGameMatrix(left, right)` - Test whether two game matrix values are equivalent in Game Theory. +19. `gameTheoryGenerateExampleGameMatrix(size=3)` - Generate a small documented example of a game matrix. +20. `gameTheoryDocumentGameMatrix(value)` - Return a structured explanation of a game matrix and related assumptions. +21. `gameTheoryValidateStrategy(value)` - Validate the strategy representation and domain rules for Game Theory. +22. `gameTheoryConstructStrategy(*args)` - Construct a strategy from explicit inputs for Game Theory. +23. `gameTheoryNormalizeStrategy(value)` - Normalize a strategy into the standard Game Theory representation. +24. `gameTheoryCanonicalizeStrategy(value)` - Canonicalize a strategy so equivalent inputs share one form. +25. `gameTheoryParseStrategy(text)` - Parse a text or structured value into a strategy. +26. `gameTheoryFormatStrategy(value)` - Format a strategy for deterministic user-facing output. +27. `gameTheoryCompareStrategy(left, right)` - Compare two strategy values under the conventions of Game Theory. +28. `gameTheoryCombineStrategy(left, right)` - Combine two strategy values with the natural operation for Game Theory. +29. `gameTheoryDecomposeStrategy(value)` - Decompose a strategy into simpler or canonical components. +30. `gameTheoryEvaluateStrategy(value, point=None)` - Evaluate a strategy at a point, sample, or finite model. +31. `gameTheoryComputeStrategy(value)` - Compute the central numerical or symbolic data of a strategy. +32. `gameTheoryEstimateStrategy(value, samples=None)` - Estimate a strategy property from finite samples or approximations. +33. `gameTheoryApproximateStrategy(value, tolerance=1e-9)` - Approximate a strategy with explicit tolerance controls. +34. `gameTheoryTransformStrategy(value, mapping)` - Transform a strategy through a map, operator, or representation change. +35. `gameTheorySimplifyStrategy(value)` - Simplify a strategy without changing its mathematical meaning. +36. `gameTheoryEnumerateStrategy(value, limit=None)` - Enumerate finite members, cases, or derived objects for a strategy. +37. `gameTheoryClassifyStrategy(value)` - Classify a strategy by its standard Game Theory invariants. +38. `gameTheoryTestEquivalenceStrategy(left, right)` - Test whether two strategy values are equivalent in Game Theory. +39. `gameTheoryGenerateExampleStrategy(size=3)` - Generate a small documented example of a strategy. +40. `gameTheoryDocumentStrategy(value)` - Return a structured explanation of a strategy and related assumptions. +41. `gameTheoryValidatePayoffModel(value)` - Validate the payoff model representation and domain rules for Game Theory. +42. `gameTheoryConstructPayoffModel(*args)` - Construct a payoff model from explicit inputs for Game Theory. +43. `gameTheoryNormalizePayoffModel(value)` - Normalize a payoff model into the standard Game Theory representation. +44. `gameTheoryCanonicalizePayoffModel(value)` - Canonicalize a payoff model so equivalent inputs share one form. +45. `gameTheoryParsePayoffModel(text)` - Parse a text or structured value into a payoff model. +46. `gameTheoryFormatPayoffModel(value)` - Format a payoff model for deterministic user-facing output. +47. `gameTheoryComparePayoffModel(left, right)` - Compare two payoff model values under the conventions of Game Theory. +48. `gameTheoryCombinePayoffModel(left, right)` - Combine two payoff model values with the natural operation for Game Theory. +49. `gameTheoryDecomposePayoffModel(value)` - Decompose a payoff model into simpler or canonical components. +50. `gameTheoryEvaluatePayoffModel(value, point=None)` - Evaluate a payoff model at a point, sample, or finite model. +51. `gameTheoryComputePayoffModel(value)` - Compute the central numerical or symbolic data of a payoff model. +52. `gameTheoryEstimatePayoffModel(value, samples=None)` - Estimate a payoff model property from finite samples or approximations. +53. `gameTheoryApproximatePayoffModel(value, tolerance=1e-9)` - Approximate a payoff model with explicit tolerance controls. +54. `gameTheoryTransformPayoffModel(value, mapping)` - Transform a payoff model through a map, operator, or representation change. +55. `gameTheorySimplifyPayoffModel(value)` - Simplify a payoff model without changing its mathematical meaning. +56. `gameTheoryEnumeratePayoffModel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a payoff model. +57. `gameTheoryClassifyPayoffModel(value)` - Classify a payoff model by its standard Game Theory invariants. +58. `gameTheoryTestEquivalencePayoffModel(left, right)` - Test whether two payoff model values are equivalent in Game Theory. +59. `gameTheoryGenerateExamplePayoffModel(size=3)` - Generate a small documented example of a payoff model. +60. `gameTheoryDocumentPayoffModel(value)` - Return a structured explanation of a payoff model and related assumptions. +61. `gameTheoryValidateEquilibrium(value)` - Validate the equilibrium representation and domain rules for Game Theory. +62. `gameTheoryConstructEquilibrium(*args)` - Construct a equilibrium from explicit inputs for Game Theory. +63. `gameTheoryNormalizeEquilibrium(value)` - Normalize a equilibrium into the standard Game Theory representation. +64. `gameTheoryCanonicalizeEquilibrium(value)` - Canonicalize a equilibrium so equivalent inputs share one form. +65. `gameTheoryParseEquilibrium(text)` - Parse a text or structured value into a equilibrium. +66. `gameTheoryFormatEquilibrium(value)` - Format a equilibrium for deterministic user-facing output. +67. `gameTheoryCompareEquilibrium(left, right)` - Compare two equilibrium values under the conventions of Game Theory. +68. `gameTheoryCombineEquilibrium(left, right)` - Combine two equilibrium values with the natural operation for Game Theory. +69. `gameTheoryDecomposeEquilibrium(value)` - Decompose a equilibrium into simpler or canonical components. +70. `gameTheoryEvaluateEquilibrium(value, point=None)` - Evaluate a equilibrium at a point, sample, or finite model. +71. `gameTheoryComputeEquilibrium(value)` - Compute the central numerical or symbolic data of a equilibrium. +72. `gameTheoryEstimateEquilibrium(value, samples=None)` - Estimate a equilibrium property from finite samples or approximations. +73. `gameTheoryApproximateEquilibrium(value, tolerance=1e-9)` - Approximate a equilibrium with explicit tolerance controls. +74. `gameTheoryTransformEquilibrium(value, mapping)` - Transform a equilibrium through a map, operator, or representation change. +75. `gameTheorySimplifyEquilibrium(value)` - Simplify a equilibrium without changing its mathematical meaning. +76. `gameTheoryEnumerateEquilibrium(value, limit=None)` - Enumerate finite members, cases, or derived objects for a equilibrium. +77. `gameTheoryClassifyEquilibrium(value)` - Classify a equilibrium by its standard Game Theory invariants. +78. `gameTheoryTestEquivalenceEquilibrium(left, right)` - Test whether two equilibrium values are equivalent in Game Theory. +79. `gameTheoryGenerateExampleEquilibrium(size=3)` - Generate a small documented example of a equilibrium. +80. `gameTheoryDocumentEquilibrium(value)` - Return a structured explanation of a equilibrium and related assumptions. +81. `gameTheoryValidateCoalition(value)` - Validate the coalition representation and domain rules for Game Theory. +82. `gameTheoryConstructCoalition(*args)` - Construct a coalition from explicit inputs for Game Theory. +83. `gameTheoryNormalizeCoalition(value)` - Normalize a coalition into the standard Game Theory representation. +84. `gameTheoryCanonicalizeCoalition(value)` - Canonicalize a coalition so equivalent inputs share one form. +85. `gameTheoryParseCoalition(text)` - Parse a text or structured value into a coalition. +86. `gameTheoryFormatCoalition(value)` - Format a coalition for deterministic user-facing output. +87. `gameTheoryCompareCoalition(left, right)` - Compare two coalition values under the conventions of Game Theory. +88. `gameTheoryCombineCoalition(left, right)` - Combine two coalition values with the natural operation for Game Theory. +89. `gameTheoryDecomposeCoalition(value)` - Decompose a coalition into simpler or canonical components. +90. `gameTheoryEvaluateCoalition(value, point=None)` - Evaluate a coalition at a point, sample, or finite model. +91. `gameTheoryComputeCoalition(value)` - Compute the central numerical or symbolic data of a coalition. +92. `gameTheoryEstimateCoalition(value, samples=None)` - Estimate a coalition property from finite samples or approximations. +93. `gameTheoryApproximateCoalition(value, tolerance=1e-9)` - Approximate a coalition with explicit tolerance controls. +94. `gameTheoryTransformCoalition(value, mapping)` - Transform a coalition through a map, operator, or representation change. +95. `gameTheorySimplifyCoalition(value)` - Simplify a coalition without changing its mathematical meaning. +96. `gameTheoryEnumerateCoalition(value, limit=None)` - Enumerate finite members, cases, or derived objects for a coalition. +97. `gameTheoryClassifyCoalition(value)` - Classify a coalition by its standard Game Theory invariants. +98. `gameTheoryTestEquivalenceCoalition(left, right)` - Test whether two coalition values are equivalent in Game Theory. +99. `gameTheoryGenerateExampleCoalition(size=3)` - Generate a small documented example of a coalition. +100. `gameTheoryDocumentCoalition(value)` - Return a structured explanation of a coalition and related assumptions. + +### Fourier Analysis + +Core object families: + +- signal +- frequency coefficient +- transform +- kernel +- convolution model + +Candidate functions: + +1. `fourierAnalysisValidateSignal(value)` - Validate the signal representation and domain rules for Fourier Analysis. +2. `fourierAnalysisConstructSignal(*args)` - Construct a signal from explicit inputs for Fourier Analysis. +3. `fourierAnalysisNormalizeSignal(value)` - Normalize a signal into the standard Fourier Analysis representation. +4. `fourierAnalysisCanonicalizeSignal(value)` - Canonicalize a signal so equivalent inputs share one form. +5. `fourierAnalysisParseSignal(text)` - Parse a text or structured value into a signal. +6. `fourierAnalysisFormatSignal(value)` - Format a signal for deterministic user-facing output. +7. `fourierAnalysisCompareSignal(left, right)` - Compare two signal values under the conventions of Fourier Analysis. +8. `fourierAnalysisCombineSignal(left, right)` - Combine two signal values with the natural operation for Fourier Analysis. +9. `fourierAnalysisDecomposeSignal(value)` - Decompose a signal into simpler or canonical components. +10. `fourierAnalysisEvaluateSignal(value, point=None)` - Evaluate a signal at a point, sample, or finite model. +11. `fourierAnalysisComputeSignal(value)` - Compute the central numerical or symbolic data of a signal. +12. `fourierAnalysisEstimateSignal(value, samples=None)` - Estimate a signal property from finite samples or approximations. +13. `fourierAnalysisApproximateSignal(value, tolerance=1e-9)` - Approximate a signal with explicit tolerance controls. +14. `fourierAnalysisTransformSignal(value, mapping)` - Transform a signal through a map, operator, or representation change. +15. `fourierAnalysisSimplifySignal(value)` - Simplify a signal without changing its mathematical meaning. +16. `fourierAnalysisEnumerateSignal(value, limit=None)` - Enumerate finite members, cases, or derived objects for a signal. +17. `fourierAnalysisClassifySignal(value)` - Classify a signal by its standard Fourier Analysis invariants. +18. `fourierAnalysisTestEquivalenceSignal(left, right)` - Test whether two signal values are equivalent in Fourier Analysis. +19. `fourierAnalysisGenerateExampleSignal(size=3)` - Generate a small documented example of a signal. +20. `fourierAnalysisDocumentSignal(value)` - Return a structured explanation of a signal and related assumptions. +21. `fourierAnalysisValidateFrequencyCoefficient(value)` - Validate the frequency coefficient representation and domain rules for Fourier Analysis. +22. `fourierAnalysisConstructFrequencyCoefficient(*args)` - Construct a frequency coefficient from explicit inputs for Fourier Analysis. +23. `fourierAnalysisNormalizeFrequencyCoefficient(value)` - Normalize a frequency coefficient into the standard Fourier Analysis representation. +24. `fourierAnalysisCanonicalizeFrequencyCoefficient(value)` - Canonicalize a frequency coefficient so equivalent inputs share one form. +25. `fourierAnalysisParseFrequencyCoefficient(text)` - Parse a text or structured value into a frequency coefficient. +26. `fourierAnalysisFormatFrequencyCoefficient(value)` - Format a frequency coefficient for deterministic user-facing output. +27. `fourierAnalysisCompareFrequencyCoefficient(left, right)` - Compare two frequency coefficient values under the conventions of Fourier Analysis. +28. `fourierAnalysisCombineFrequencyCoefficient(left, right)` - Combine two frequency coefficient values with the natural operation for Fourier Analysis. +29. `fourierAnalysisDecomposeFrequencyCoefficient(value)` - Decompose a frequency coefficient into simpler or canonical components. +30. `fourierAnalysisEvaluateFrequencyCoefficient(value, point=None)` - Evaluate a frequency coefficient at a point, sample, or finite model. +31. `fourierAnalysisComputeFrequencyCoefficient(value)` - Compute the central numerical or symbolic data of a frequency coefficient. +32. `fourierAnalysisEstimateFrequencyCoefficient(value, samples=None)` - Estimate a frequency coefficient property from finite samples or approximations. +33. `fourierAnalysisApproximateFrequencyCoefficient(value, tolerance=1e-9)` - Approximate a frequency coefficient with explicit tolerance controls. +34. `fourierAnalysisTransformFrequencyCoefficient(value, mapping)` - Transform a frequency coefficient through a map, operator, or representation change. +35. `fourierAnalysisSimplifyFrequencyCoefficient(value)` - Simplify a frequency coefficient without changing its mathematical meaning. +36. `fourierAnalysisEnumerateFrequencyCoefficient(value, limit=None)` - Enumerate finite members, cases, or derived objects for a frequency coefficient. +37. `fourierAnalysisClassifyFrequencyCoefficient(value)` - Classify a frequency coefficient by its standard Fourier Analysis invariants. +38. `fourierAnalysisTestEquivalenceFrequencyCoefficient(left, right)` - Test whether two frequency coefficient values are equivalent in Fourier Analysis. +39. `fourierAnalysisGenerateExampleFrequencyCoefficient(size=3)` - Generate a small documented example of a frequency coefficient. +40. `fourierAnalysisDocumentFrequencyCoefficient(value)` - Return a structured explanation of a frequency coefficient and related assumptions. +41. `fourierAnalysisValidateTransform(value)` - Validate the transform representation and domain rules for Fourier Analysis. +42. `fourierAnalysisConstructTransform(*args)` - Construct a transform from explicit inputs for Fourier Analysis. +43. `fourierAnalysisNormalizeTransform(value)` - Normalize a transform into the standard Fourier Analysis representation. +44. `fourierAnalysisCanonicalizeTransform(value)` - Canonicalize a transform so equivalent inputs share one form. +45. `fourierAnalysisParseTransform(text)` - Parse a text or structured value into a transform. +46. `fourierAnalysisFormatTransform(value)` - Format a transform for deterministic user-facing output. +47. `fourierAnalysisCompareTransform(left, right)` - Compare two transform values under the conventions of Fourier Analysis. +48. `fourierAnalysisCombineTransform(left, right)` - Combine two transform values with the natural operation for Fourier Analysis. +49. `fourierAnalysisDecomposeTransform(value)` - Decompose a transform into simpler or canonical components. +50. `fourierAnalysisEvaluateTransform(value, point=None)` - Evaluate a transform at a point, sample, or finite model. +51. `fourierAnalysisComputeTransform(value)` - Compute the central numerical or symbolic data of a transform. +52. `fourierAnalysisEstimateTransform(value, samples=None)` - Estimate a transform property from finite samples or approximations. +53. `fourierAnalysisApproximateTransform(value, tolerance=1e-9)` - Approximate a transform with explicit tolerance controls. +54. `fourierAnalysisTransformTransform(value, mapping)` - Transform a transform through a map, operator, or representation change. +55. `fourierAnalysisSimplifyTransform(value)` - Simplify a transform without changing its mathematical meaning. +56. `fourierAnalysisEnumerateTransform(value, limit=None)` - Enumerate finite members, cases, or derived objects for a transform. +57. `fourierAnalysisClassifyTransform(value)` - Classify a transform by its standard Fourier Analysis invariants. +58. `fourierAnalysisTestEquivalenceTransform(left, right)` - Test whether two transform values are equivalent in Fourier Analysis. +59. `fourierAnalysisGenerateExampleTransform(size=3)` - Generate a small documented example of a transform. +60. `fourierAnalysisDocumentTransform(value)` - Return a structured explanation of a transform and related assumptions. +61. `fourierAnalysisValidateKernel(value)` - Validate the kernel representation and domain rules for Fourier Analysis. +62. `fourierAnalysisConstructKernel(*args)` - Construct a kernel from explicit inputs for Fourier Analysis. +63. `fourierAnalysisNormalizeKernel(value)` - Normalize a kernel into the standard Fourier Analysis representation. +64. `fourierAnalysisCanonicalizeKernel(value)` - Canonicalize a kernel so equivalent inputs share one form. +65. `fourierAnalysisParseKernel(text)` - Parse a text or structured value into a kernel. +66. `fourierAnalysisFormatKernel(value)` - Format a kernel for deterministic user-facing output. +67. `fourierAnalysisCompareKernel(left, right)` - Compare two kernel values under the conventions of Fourier Analysis. +68. `fourierAnalysisCombineKernel(left, right)` - Combine two kernel values with the natural operation for Fourier Analysis. +69. `fourierAnalysisDecomposeKernel(value)` - Decompose a kernel into simpler or canonical components. +70. `fourierAnalysisEvaluateKernel(value, point=None)` - Evaluate a kernel at a point, sample, or finite model. +71. `fourierAnalysisComputeKernel(value)` - Compute the central numerical or symbolic data of a kernel. +72. `fourierAnalysisEstimateKernel(value, samples=None)` - Estimate a kernel property from finite samples or approximations. +73. `fourierAnalysisApproximateKernel(value, tolerance=1e-9)` - Approximate a kernel with explicit tolerance controls. +74. `fourierAnalysisTransformKernel(value, mapping)` - Transform a kernel through a map, operator, or representation change. +75. `fourierAnalysisSimplifyKernel(value)` - Simplify a kernel without changing its mathematical meaning. +76. `fourierAnalysisEnumerateKernel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a kernel. +77. `fourierAnalysisClassifyKernel(value)` - Classify a kernel by its standard Fourier Analysis invariants. +78. `fourierAnalysisTestEquivalenceKernel(left, right)` - Test whether two kernel values are equivalent in Fourier Analysis. +79. `fourierAnalysisGenerateExampleKernel(size=3)` - Generate a small documented example of a kernel. +80. `fourierAnalysisDocumentKernel(value)` - Return a structured explanation of a kernel and related assumptions. +81. `fourierAnalysisValidateConvolutionModel(value)` - Validate the convolution model representation and domain rules for Fourier Analysis. +82. `fourierAnalysisConstructConvolutionModel(*args)` - Construct a convolution model from explicit inputs for Fourier Analysis. +83. `fourierAnalysisNormalizeConvolutionModel(value)` - Normalize a convolution model into the standard Fourier Analysis representation. +84. `fourierAnalysisCanonicalizeConvolutionModel(value)` - Canonicalize a convolution model so equivalent inputs share one form. +85. `fourierAnalysisParseConvolutionModel(text)` - Parse a text or structured value into a convolution model. +86. `fourierAnalysisFormatConvolutionModel(value)` - Format a convolution model for deterministic user-facing output. +87. `fourierAnalysisCompareConvolutionModel(left, right)` - Compare two convolution model values under the conventions of Fourier Analysis. +88. `fourierAnalysisCombineConvolutionModel(left, right)` - Combine two convolution model values with the natural operation for Fourier Analysis. +89. `fourierAnalysisDecomposeConvolutionModel(value)` - Decompose a convolution model into simpler or canonical components. +90. `fourierAnalysisEvaluateConvolutionModel(value, point=None)` - Evaluate a convolution model at a point, sample, or finite model. +91. `fourierAnalysisComputeConvolutionModel(value)` - Compute the central numerical or symbolic data of a convolution model. +92. `fourierAnalysisEstimateConvolutionModel(value, samples=None)` - Estimate a convolution model property from finite samples or approximations. +93. `fourierAnalysisApproximateConvolutionModel(value, tolerance=1e-9)` - Approximate a convolution model with explicit tolerance controls. +94. `fourierAnalysisTransformConvolutionModel(value, mapping)` - Transform a convolution model through a map, operator, or representation change. +95. `fourierAnalysisSimplifyConvolutionModel(value)` - Simplify a convolution model without changing its mathematical meaning. +96. `fourierAnalysisEnumerateConvolutionModel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a convolution model. +97. `fourierAnalysisClassifyConvolutionModel(value)` - Classify a convolution model by its standard Fourier Analysis invariants. +98. `fourierAnalysisTestEquivalenceConvolutionModel(left, right)` - Test whether two convolution model values are equivalent in Fourier Analysis. +99. `fourierAnalysisGenerateExampleConvolutionModel(size=3)` - Generate a small documented example of a convolution model. +100. `fourierAnalysisDocumentConvolutionModel(value)` - Return a structured explanation of a convolution model and related assumptions. + +### Dynamical Systems + +Core object families: + +- iterated map +- orbit +- fixed point +- phase space +- stability profile + +Candidate functions: + +1. `dynamicalSystemsValidateIteratedMap(value)` - Validate the iterated map representation and domain rules for Dynamical Systems. +2. `dynamicalSystemsConstructIteratedMap(*args)` - Construct a iterated map from explicit inputs for Dynamical Systems. +3. `dynamicalSystemsNormalizeIteratedMap(value)` - Normalize a iterated map into the standard Dynamical Systems representation. +4. `dynamicalSystemsCanonicalizeIteratedMap(value)` - Canonicalize a iterated map so equivalent inputs share one form. +5. `dynamicalSystemsParseIteratedMap(text)` - Parse a text or structured value into a iterated map. +6. `dynamicalSystemsFormatIteratedMap(value)` - Format a iterated map for deterministic user-facing output. +7. `dynamicalSystemsCompareIteratedMap(left, right)` - Compare two iterated map values under the conventions of Dynamical Systems. +8. `dynamicalSystemsCombineIteratedMap(left, right)` - Combine two iterated map values with the natural operation for Dynamical Systems. +9. `dynamicalSystemsDecomposeIteratedMap(value)` - Decompose a iterated map into simpler or canonical components. +10. `dynamicalSystemsEvaluateIteratedMap(value, point=None)` - Evaluate a iterated map at a point, sample, or finite model. +11. `dynamicalSystemsComputeIteratedMap(value)` - Compute the central numerical or symbolic data of a iterated map. +12. `dynamicalSystemsEstimateIteratedMap(value, samples=None)` - Estimate a iterated map property from finite samples or approximations. +13. `dynamicalSystemsApproximateIteratedMap(value, tolerance=1e-9)` - Approximate a iterated map with explicit tolerance controls. +14. `dynamicalSystemsTransformIteratedMap(value, mapping)` - Transform a iterated map through a map, operator, or representation change. +15. `dynamicalSystemsSimplifyIteratedMap(value)` - Simplify a iterated map without changing its mathematical meaning. +16. `dynamicalSystemsEnumerateIteratedMap(value, limit=None)` - Enumerate finite members, cases, or derived objects for a iterated map. +17. `dynamicalSystemsClassifyIteratedMap(value)` - Classify a iterated map by its standard Dynamical Systems invariants. +18. `dynamicalSystemsTestEquivalenceIteratedMap(left, right)` - Test whether two iterated map values are equivalent in Dynamical Systems. +19. `dynamicalSystemsGenerateExampleIteratedMap(size=3)` - Generate a small documented example of a iterated map. +20. `dynamicalSystemsDocumentIteratedMap(value)` - Return a structured explanation of a iterated map and related assumptions. +21. `dynamicalSystemsValidateOrbit(value)` - Validate the orbit representation and domain rules for Dynamical Systems. +22. `dynamicalSystemsConstructOrbit(*args)` - Construct a orbit from explicit inputs for Dynamical Systems. +23. `dynamicalSystemsNormalizeOrbit(value)` - Normalize a orbit into the standard Dynamical Systems representation. +24. `dynamicalSystemsCanonicalizeOrbit(value)` - Canonicalize a orbit so equivalent inputs share one form. +25. `dynamicalSystemsParseOrbit(text)` - Parse a text or structured value into a orbit. +26. `dynamicalSystemsFormatOrbit(value)` - Format a orbit for deterministic user-facing output. +27. `dynamicalSystemsCompareOrbit(left, right)` - Compare two orbit values under the conventions of Dynamical Systems. +28. `dynamicalSystemsCombineOrbit(left, right)` - Combine two orbit values with the natural operation for Dynamical Systems. +29. `dynamicalSystemsDecomposeOrbit(value)` - Decompose a orbit into simpler or canonical components. +30. `dynamicalSystemsEvaluateOrbit(value, point=None)` - Evaluate a orbit at a point, sample, or finite model. +31. `dynamicalSystemsComputeOrbit(value)` - Compute the central numerical or symbolic data of a orbit. +32. `dynamicalSystemsEstimateOrbit(value, samples=None)` - Estimate a orbit property from finite samples or approximations. +33. `dynamicalSystemsApproximateOrbit(value, tolerance=1e-9)` - Approximate a orbit with explicit tolerance controls. +34. `dynamicalSystemsTransformOrbit(value, mapping)` - Transform a orbit through a map, operator, or representation change. +35. `dynamicalSystemsSimplifyOrbit(value)` - Simplify a orbit without changing its mathematical meaning. +36. `dynamicalSystemsEnumerateOrbit(value, limit=None)` - Enumerate finite members, cases, or derived objects for a orbit. +37. `dynamicalSystemsClassifyOrbit(value)` - Classify a orbit by its standard Dynamical Systems invariants. +38. `dynamicalSystemsTestEquivalenceOrbit(left, right)` - Test whether two orbit values are equivalent in Dynamical Systems. +39. `dynamicalSystemsGenerateExampleOrbit(size=3)` - Generate a small documented example of a orbit. +40. `dynamicalSystemsDocumentOrbit(value)` - Return a structured explanation of a orbit and related assumptions. +41. `dynamicalSystemsValidateFixedPoint(value)` - Validate the fixed point representation and domain rules for Dynamical Systems. +42. `dynamicalSystemsConstructFixedPoint(*args)` - Construct a fixed point from explicit inputs for Dynamical Systems. +43. `dynamicalSystemsNormalizeFixedPoint(value)` - Normalize a fixed point into the standard Dynamical Systems representation. +44. `dynamicalSystemsCanonicalizeFixedPoint(value)` - Canonicalize a fixed point so equivalent inputs share one form. +45. `dynamicalSystemsParseFixedPoint(text)` - Parse a text or structured value into a fixed point. +46. `dynamicalSystemsFormatFixedPoint(value)` - Format a fixed point for deterministic user-facing output. +47. `dynamicalSystemsCompareFixedPoint(left, right)` - Compare two fixed point values under the conventions of Dynamical Systems. +48. `dynamicalSystemsCombineFixedPoint(left, right)` - Combine two fixed point values with the natural operation for Dynamical Systems. +49. `dynamicalSystemsDecomposeFixedPoint(value)` - Decompose a fixed point into simpler or canonical components. +50. `dynamicalSystemsEvaluateFixedPoint(value, point=None)` - Evaluate a fixed point at a point, sample, or finite model. +51. `dynamicalSystemsComputeFixedPoint(value)` - Compute the central numerical or symbolic data of a fixed point. +52. `dynamicalSystemsEstimateFixedPoint(value, samples=None)` - Estimate a fixed point property from finite samples or approximations. +53. `dynamicalSystemsApproximateFixedPoint(value, tolerance=1e-9)` - Approximate a fixed point with explicit tolerance controls. +54. `dynamicalSystemsTransformFixedPoint(value, mapping)` - Transform a fixed point through a map, operator, or representation change. +55. `dynamicalSystemsSimplifyFixedPoint(value)` - Simplify a fixed point without changing its mathematical meaning. +56. `dynamicalSystemsEnumerateFixedPoint(value, limit=None)` - Enumerate finite members, cases, or derived objects for a fixed point. +57. `dynamicalSystemsClassifyFixedPoint(value)` - Classify a fixed point by its standard Dynamical Systems invariants. +58. `dynamicalSystemsTestEquivalenceFixedPoint(left, right)` - Test whether two fixed point values are equivalent in Dynamical Systems. +59. `dynamicalSystemsGenerateExampleFixedPoint(size=3)` - Generate a small documented example of a fixed point. +60. `dynamicalSystemsDocumentFixedPoint(value)` - Return a structured explanation of a fixed point and related assumptions. +61. `dynamicalSystemsValidatePhaseSpace(value)` - Validate the phase space representation and domain rules for Dynamical Systems. +62. `dynamicalSystemsConstructPhaseSpace(*args)` - Construct a phase space from explicit inputs for Dynamical Systems. +63. `dynamicalSystemsNormalizePhaseSpace(value)` - Normalize a phase space into the standard Dynamical Systems representation. +64. `dynamicalSystemsCanonicalizePhaseSpace(value)` - Canonicalize a phase space so equivalent inputs share one form. +65. `dynamicalSystemsParsePhaseSpace(text)` - Parse a text or structured value into a phase space. +66. `dynamicalSystemsFormatPhaseSpace(value)` - Format a phase space for deterministic user-facing output. +67. `dynamicalSystemsComparePhaseSpace(left, right)` - Compare two phase space values under the conventions of Dynamical Systems. +68. `dynamicalSystemsCombinePhaseSpace(left, right)` - Combine two phase space values with the natural operation for Dynamical Systems. +69. `dynamicalSystemsDecomposePhaseSpace(value)` - Decompose a phase space into simpler or canonical components. +70. `dynamicalSystemsEvaluatePhaseSpace(value, point=None)` - Evaluate a phase space at a point, sample, or finite model. +71. `dynamicalSystemsComputePhaseSpace(value)` - Compute the central numerical or symbolic data of a phase space. +72. `dynamicalSystemsEstimatePhaseSpace(value, samples=None)` - Estimate a phase space property from finite samples or approximations. +73. `dynamicalSystemsApproximatePhaseSpace(value, tolerance=1e-9)` - Approximate a phase space with explicit tolerance controls. +74. `dynamicalSystemsTransformPhaseSpace(value, mapping)` - Transform a phase space through a map, operator, or representation change. +75. `dynamicalSystemsSimplifyPhaseSpace(value)` - Simplify a phase space without changing its mathematical meaning. +76. `dynamicalSystemsEnumeratePhaseSpace(value, limit=None)` - Enumerate finite members, cases, or derived objects for a phase space. +77. `dynamicalSystemsClassifyPhaseSpace(value)` - Classify a phase space by its standard Dynamical Systems invariants. +78. `dynamicalSystemsTestEquivalencePhaseSpace(left, right)` - Test whether two phase space values are equivalent in Dynamical Systems. +79. `dynamicalSystemsGenerateExamplePhaseSpace(size=3)` - Generate a small documented example of a phase space. +80. `dynamicalSystemsDocumentPhaseSpace(value)` - Return a structured explanation of a phase space and related assumptions. +81. `dynamicalSystemsValidateStabilityProfile(value)` - Validate the stability profile representation and domain rules for Dynamical Systems. +82. `dynamicalSystemsConstructStabilityProfile(*args)` - Construct a stability profile from explicit inputs for Dynamical Systems. +83. `dynamicalSystemsNormalizeStabilityProfile(value)` - Normalize a stability profile into the standard Dynamical Systems representation. +84. `dynamicalSystemsCanonicalizeStabilityProfile(value)` - Canonicalize a stability profile so equivalent inputs share one form. +85. `dynamicalSystemsParseStabilityProfile(text)` - Parse a text or structured value into a stability profile. +86. `dynamicalSystemsFormatStabilityProfile(value)` - Format a stability profile for deterministic user-facing output. +87. `dynamicalSystemsCompareStabilityProfile(left, right)` - Compare two stability profile values under the conventions of Dynamical Systems. +88. `dynamicalSystemsCombineStabilityProfile(left, right)` - Combine two stability profile values with the natural operation for Dynamical Systems. +89. `dynamicalSystemsDecomposeStabilityProfile(value)` - Decompose a stability profile into simpler or canonical components. +90. `dynamicalSystemsEvaluateStabilityProfile(value, point=None)` - Evaluate a stability profile at a point, sample, or finite model. +91. `dynamicalSystemsComputeStabilityProfile(value)` - Compute the central numerical or symbolic data of a stability profile. +92. `dynamicalSystemsEstimateStabilityProfile(value, samples=None)` - Estimate a stability profile property from finite samples or approximations. +93. `dynamicalSystemsApproximateStabilityProfile(value, tolerance=1e-9)` - Approximate a stability profile with explicit tolerance controls. +94. `dynamicalSystemsTransformStabilityProfile(value, mapping)` - Transform a stability profile through a map, operator, or representation change. +95. `dynamicalSystemsSimplifyStabilityProfile(value)` - Simplify a stability profile without changing its mathematical meaning. +96. `dynamicalSystemsEnumerateStabilityProfile(value, limit=None)` - Enumerate finite members, cases, or derived objects for a stability profile. +97. `dynamicalSystemsClassifyStabilityProfile(value)` - Classify a stability profile by its standard Dynamical Systems invariants. +98. `dynamicalSystemsTestEquivalenceStabilityProfile(left, right)` - Test whether two stability profile values are equivalent in Dynamical Systems. +99. `dynamicalSystemsGenerateExampleStabilityProfile(size=3)` - Generate a small documented example of a stability profile. +100. `dynamicalSystemsDocumentStabilityProfile(value)` - Return a structured explanation of a stability profile and related assumptions. + +### Measure Theory + +Core object families: + +- sigma algebra +- measure +- measurable function +- simple function +- null set + +Candidate functions: + +1. `measureTheoryValidateSigmaAlgebra(value)` - Validate the sigma algebra representation and domain rules for Measure Theory. +2. `measureTheoryConstructSigmaAlgebra(*args)` - Construct a sigma algebra from explicit inputs for Measure Theory. +3. `measureTheoryNormalizeSigmaAlgebra(value)` - Normalize a sigma algebra into the standard Measure Theory representation. +4. `measureTheoryCanonicalizeSigmaAlgebra(value)` - Canonicalize a sigma algebra so equivalent inputs share one form. +5. `measureTheoryParseSigmaAlgebra(text)` - Parse a text or structured value into a sigma algebra. +6. `measureTheoryFormatSigmaAlgebra(value)` - Format a sigma algebra for deterministic user-facing output. +7. `measureTheoryCompareSigmaAlgebra(left, right)` - Compare two sigma algebra values under the conventions of Measure Theory. +8. `measureTheoryCombineSigmaAlgebra(left, right)` - Combine two sigma algebra values with the natural operation for Measure Theory. +9. `measureTheoryDecomposeSigmaAlgebra(value)` - Decompose a sigma algebra into simpler or canonical components. +10. `measureTheoryEvaluateSigmaAlgebra(value, point=None)` - Evaluate a sigma algebra at a point, sample, or finite model. +11. `measureTheoryComputeSigmaAlgebra(value)` - Compute the central numerical or symbolic data of a sigma algebra. +12. `measureTheoryEstimateSigmaAlgebra(value, samples=None)` - Estimate a sigma algebra property from finite samples or approximations. +13. `measureTheoryApproximateSigmaAlgebra(value, tolerance=1e-9)` - Approximate a sigma algebra with explicit tolerance controls. +14. `measureTheoryTransformSigmaAlgebra(value, mapping)` - Transform a sigma algebra through a map, operator, or representation change. +15. `measureTheorySimplifySigmaAlgebra(value)` - Simplify a sigma algebra without changing its mathematical meaning. +16. `measureTheoryEnumerateSigmaAlgebra(value, limit=None)` - Enumerate finite members, cases, or derived objects for a sigma algebra. +17. `measureTheoryClassifySigmaAlgebra(value)` - Classify a sigma algebra by its standard Measure Theory invariants. +18. `measureTheoryTestEquivalenceSigmaAlgebra(left, right)` - Test whether two sigma algebra values are equivalent in Measure Theory. +19. `measureTheoryGenerateExampleSigmaAlgebra(size=3)` - Generate a small documented example of a sigma algebra. +20. `measureTheoryDocumentSigmaAlgebra(value)` - Return a structured explanation of a sigma algebra and related assumptions. +21. `measureTheoryValidateMeasure(value)` - Validate the measure representation and domain rules for Measure Theory. +22. `measureTheoryConstructMeasure(*args)` - Construct a measure from explicit inputs for Measure Theory. +23. `measureTheoryNormalizeMeasure(value)` - Normalize a measure into the standard Measure Theory representation. +24. `measureTheoryCanonicalizeMeasure(value)` - Canonicalize a measure so equivalent inputs share one form. +25. `measureTheoryParseMeasure(text)` - Parse a text or structured value into a measure. +26. `measureTheoryFormatMeasure(value)` - Format a measure for deterministic user-facing output. +27. `measureTheoryCompareMeasure(left, right)` - Compare two measure values under the conventions of Measure Theory. +28. `measureTheoryCombineMeasure(left, right)` - Combine two measure values with the natural operation for Measure Theory. +29. `measureTheoryDecomposeMeasure(value)` - Decompose a measure into simpler or canonical components. +30. `measureTheoryEvaluateMeasure(value, point=None)` - Evaluate a measure at a point, sample, or finite model. +31. `measureTheoryComputeMeasure(value)` - Compute the central numerical or symbolic data of a measure. +32. `measureTheoryEstimateMeasure(value, samples=None)` - Estimate a measure property from finite samples or approximations. +33. `measureTheoryApproximateMeasure(value, tolerance=1e-9)` - Approximate a measure with explicit tolerance controls. +34. `measureTheoryTransformMeasure(value, mapping)` - Transform a measure through a map, operator, or representation change. +35. `measureTheorySimplifyMeasure(value)` - Simplify a measure without changing its mathematical meaning. +36. `measureTheoryEnumerateMeasure(value, limit=None)` - Enumerate finite members, cases, or derived objects for a measure. +37. `measureTheoryClassifyMeasure(value)` - Classify a measure by its standard Measure Theory invariants. +38. `measureTheoryTestEquivalenceMeasure(left, right)` - Test whether two measure values are equivalent in Measure Theory. +39. `measureTheoryGenerateExampleMeasure(size=3)` - Generate a small documented example of a measure. +40. `measureTheoryDocumentMeasure(value)` - Return a structured explanation of a measure and related assumptions. +41. `measureTheoryValidateMeasurableFunction(value)` - Validate the measurable function representation and domain rules for Measure Theory. +42. `measureTheoryConstructMeasurableFunction(*args)` - Construct a measurable function from explicit inputs for Measure Theory. +43. `measureTheoryNormalizeMeasurableFunction(value)` - Normalize a measurable function into the standard Measure Theory representation. +44. `measureTheoryCanonicalizeMeasurableFunction(value)` - Canonicalize a measurable function so equivalent inputs share one form. +45. `measureTheoryParseMeasurableFunction(text)` - Parse a text or structured value into a measurable function. +46. `measureTheoryFormatMeasurableFunction(value)` - Format a measurable function for deterministic user-facing output. +47. `measureTheoryCompareMeasurableFunction(left, right)` - Compare two measurable function values under the conventions of Measure Theory. +48. `measureTheoryCombineMeasurableFunction(left, right)` - Combine two measurable function values with the natural operation for Measure Theory. +49. `measureTheoryDecomposeMeasurableFunction(value)` - Decompose a measurable function into simpler or canonical components. +50. `measureTheoryEvaluateMeasurableFunction(value, point=None)` - Evaluate a measurable function at a point, sample, or finite model. +51. `measureTheoryComputeMeasurableFunction(value)` - Compute the central numerical or symbolic data of a measurable function. +52. `measureTheoryEstimateMeasurableFunction(value, samples=None)` - Estimate a measurable function property from finite samples or approximations. +53. `measureTheoryApproximateMeasurableFunction(value, tolerance=1e-9)` - Approximate a measurable function with explicit tolerance controls. +54. `measureTheoryTransformMeasurableFunction(value, mapping)` - Transform a measurable function through a map, operator, or representation change. +55. `measureTheorySimplifyMeasurableFunction(value)` - Simplify a measurable function without changing its mathematical meaning. +56. `measureTheoryEnumerateMeasurableFunction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a measurable function. +57. `measureTheoryClassifyMeasurableFunction(value)` - Classify a measurable function by its standard Measure Theory invariants. +58. `measureTheoryTestEquivalenceMeasurableFunction(left, right)` - Test whether two measurable function values are equivalent in Measure Theory. +59. `measureTheoryGenerateExampleMeasurableFunction(size=3)` - Generate a small documented example of a measurable function. +60. `measureTheoryDocumentMeasurableFunction(value)` - Return a structured explanation of a measurable function and related assumptions. +61. `measureTheoryValidateSimpleFunction(value)` - Validate the simple function representation and domain rules for Measure Theory. +62. `measureTheoryConstructSimpleFunction(*args)` - Construct a simple function from explicit inputs for Measure Theory. +63. `measureTheoryNormalizeSimpleFunction(value)` - Normalize a simple function into the standard Measure Theory representation. +64. `measureTheoryCanonicalizeSimpleFunction(value)` - Canonicalize a simple function so equivalent inputs share one form. +65. `measureTheoryParseSimpleFunction(text)` - Parse a text or structured value into a simple function. +66. `measureTheoryFormatSimpleFunction(value)` - Format a simple function for deterministic user-facing output. +67. `measureTheoryCompareSimpleFunction(left, right)` - Compare two simple function values under the conventions of Measure Theory. +68. `measureTheoryCombineSimpleFunction(left, right)` - Combine two simple function values with the natural operation for Measure Theory. +69. `measureTheoryDecomposeSimpleFunction(value)` - Decompose a simple function into simpler or canonical components. +70. `measureTheoryEvaluateSimpleFunction(value, point=None)` - Evaluate a simple function at a point, sample, or finite model. +71. `measureTheoryComputeSimpleFunction(value)` - Compute the central numerical or symbolic data of a simple function. +72. `measureTheoryEstimateSimpleFunction(value, samples=None)` - Estimate a simple function property from finite samples or approximations. +73. `measureTheoryApproximateSimpleFunction(value, tolerance=1e-9)` - Approximate a simple function with explicit tolerance controls. +74. `measureTheoryTransformSimpleFunction(value, mapping)` - Transform a simple function through a map, operator, or representation change. +75. `measureTheorySimplifySimpleFunction(value)` - Simplify a simple function without changing its mathematical meaning. +76. `measureTheoryEnumerateSimpleFunction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a simple function. +77. `measureTheoryClassifySimpleFunction(value)` - Classify a simple function by its standard Measure Theory invariants. +78. `measureTheoryTestEquivalenceSimpleFunction(left, right)` - Test whether two simple function values are equivalent in Measure Theory. +79. `measureTheoryGenerateExampleSimpleFunction(size=3)` - Generate a small documented example of a simple function. +80. `measureTheoryDocumentSimpleFunction(value)` - Return a structured explanation of a simple function and related assumptions. +81. `measureTheoryValidateNullSet(value)` - Validate the null set representation and domain rules for Measure Theory. +82. `measureTheoryConstructNullSet(*args)` - Construct a null set from explicit inputs for Measure Theory. +83. `measureTheoryNormalizeNullSet(value)` - Normalize a null set into the standard Measure Theory representation. +84. `measureTheoryCanonicalizeNullSet(value)` - Canonicalize a null set so equivalent inputs share one form. +85. `measureTheoryParseNullSet(text)` - Parse a text or structured value into a null set. +86. `measureTheoryFormatNullSet(value)` - Format a null set for deterministic user-facing output. +87. `measureTheoryCompareNullSet(left, right)` - Compare two null set values under the conventions of Measure Theory. +88. `measureTheoryCombineNullSet(left, right)` - Combine two null set values with the natural operation for Measure Theory. +89. `measureTheoryDecomposeNullSet(value)` - Decompose a null set into simpler or canonical components. +90. `measureTheoryEvaluateNullSet(value, point=None)` - Evaluate a null set at a point, sample, or finite model. +91. `measureTheoryComputeNullSet(value)` - Compute the central numerical or symbolic data of a null set. +92. `measureTheoryEstimateNullSet(value, samples=None)` - Estimate a null set property from finite samples or approximations. +93. `measureTheoryApproximateNullSet(value, tolerance=1e-9)` - Approximate a null set with explicit tolerance controls. +94. `measureTheoryTransformNullSet(value, mapping)` - Transform a null set through a map, operator, or representation change. +95. `measureTheorySimplifyNullSet(value)` - Simplify a null set without changing its mathematical meaning. +96. `measureTheoryEnumerateNullSet(value, limit=None)` - Enumerate finite members, cases, or derived objects for a null set. +97. `measureTheoryClassifyNullSet(value)` - Classify a null set by its standard Measure Theory invariants. +98. `measureTheoryTestEquivalenceNullSet(left, right)` - Test whether two null set values are equivalent in Measure Theory. +99. `measureTheoryGenerateExampleNullSet(size=3)` - Generate a small documented example of a null set. +100. `measureTheoryDocumentNullSet(value)` - Return a structured explanation of a null set and related assumptions. + +### Functional Analysis + +Core object families: + +- normed space +- linear functional +- bounded operator +- inner product +- complete space + +Candidate functions: + +1. `functionalAnalysisValidateNormedSpace(value)` - Validate the normed space representation and domain rules for Functional Analysis. +2. `functionalAnalysisConstructNormedSpace(*args)` - Construct a normed space from explicit inputs for Functional Analysis. +3. `functionalAnalysisNormalizeNormedSpace(value)` - Normalize a normed space into the standard Functional Analysis representation. +4. `functionalAnalysisCanonicalizeNormedSpace(value)` - Canonicalize a normed space so equivalent inputs share one form. +5. `functionalAnalysisParseNormedSpace(text)` - Parse a text or structured value into a normed space. +6. `functionalAnalysisFormatNormedSpace(value)` - Format a normed space for deterministic user-facing output. +7. `functionalAnalysisCompareNormedSpace(left, right)` - Compare two normed space values under the conventions of Functional Analysis. +8. `functionalAnalysisCombineNormedSpace(left, right)` - Combine two normed space values with the natural operation for Functional Analysis. +9. `functionalAnalysisDecomposeNormedSpace(value)` - Decompose a normed space into simpler or canonical components. +10. `functionalAnalysisEvaluateNormedSpace(value, point=None)` - Evaluate a normed space at a point, sample, or finite model. +11. `functionalAnalysisComputeNormedSpace(value)` - Compute the central numerical or symbolic data of a normed space. +12. `functionalAnalysisEstimateNormedSpace(value, samples=None)` - Estimate a normed space property from finite samples or approximations. +13. `functionalAnalysisApproximateNormedSpace(value, tolerance=1e-9)` - Approximate a normed space with explicit tolerance controls. +14. `functionalAnalysisTransformNormedSpace(value, mapping)` - Transform a normed space through a map, operator, or representation change. +15. `functionalAnalysisSimplifyNormedSpace(value)` - Simplify a normed space without changing its mathematical meaning. +16. `functionalAnalysisEnumerateNormedSpace(value, limit=None)` - Enumerate finite members, cases, or derived objects for a normed space. +17. `functionalAnalysisClassifyNormedSpace(value)` - Classify a normed space by its standard Functional Analysis invariants. +18. `functionalAnalysisTestEquivalenceNormedSpace(left, right)` - Test whether two normed space values are equivalent in Functional Analysis. +19. `functionalAnalysisGenerateExampleNormedSpace(size=3)` - Generate a small documented example of a normed space. +20. `functionalAnalysisDocumentNormedSpace(value)` - Return a structured explanation of a normed space and related assumptions. +21. `functionalAnalysisValidateLinearFunctional(value)` - Validate the linear functional representation and domain rules for Functional Analysis. +22. `functionalAnalysisConstructLinearFunctional(*args)` - Construct a linear functional from explicit inputs for Functional Analysis. +23. `functionalAnalysisNormalizeLinearFunctional(value)` - Normalize a linear functional into the standard Functional Analysis representation. +24. `functionalAnalysisCanonicalizeLinearFunctional(value)` - Canonicalize a linear functional so equivalent inputs share one form. +25. `functionalAnalysisParseLinearFunctional(text)` - Parse a text or structured value into a linear functional. +26. `functionalAnalysisFormatLinearFunctional(value)` - Format a linear functional for deterministic user-facing output. +27. `functionalAnalysisCompareLinearFunctional(left, right)` - Compare two linear functional values under the conventions of Functional Analysis. +28. `functionalAnalysisCombineLinearFunctional(left, right)` - Combine two linear functional values with the natural operation for Functional Analysis. +29. `functionalAnalysisDecomposeLinearFunctional(value)` - Decompose a linear functional into simpler or canonical components. +30. `functionalAnalysisEvaluateLinearFunctional(value, point=None)` - Evaluate a linear functional at a point, sample, or finite model. +31. `functionalAnalysisComputeLinearFunctional(value)` - Compute the central numerical or symbolic data of a linear functional. +32. `functionalAnalysisEstimateLinearFunctional(value, samples=None)` - Estimate a linear functional property from finite samples or approximations. +33. `functionalAnalysisApproximateLinearFunctional(value, tolerance=1e-9)` - Approximate a linear functional with explicit tolerance controls. +34. `functionalAnalysisTransformLinearFunctional(value, mapping)` - Transform a linear functional through a map, operator, or representation change. +35. `functionalAnalysisSimplifyLinearFunctional(value)` - Simplify a linear functional without changing its mathematical meaning. +36. `functionalAnalysisEnumerateLinearFunctional(value, limit=None)` - Enumerate finite members, cases, or derived objects for a linear functional. +37. `functionalAnalysisClassifyLinearFunctional(value)` - Classify a linear functional by its standard Functional Analysis invariants. +38. `functionalAnalysisTestEquivalenceLinearFunctional(left, right)` - Test whether two linear functional values are equivalent in Functional Analysis. +39. `functionalAnalysisGenerateExampleLinearFunctional(size=3)` - Generate a small documented example of a linear functional. +40. `functionalAnalysisDocumentLinearFunctional(value)` - Return a structured explanation of a linear functional and related assumptions. +41. `functionalAnalysisValidateBoundedOperator(value)` - Validate the bounded operator representation and domain rules for Functional Analysis. +42. `functionalAnalysisConstructBoundedOperator(*args)` - Construct a bounded operator from explicit inputs for Functional Analysis. +43. `functionalAnalysisNormalizeBoundedOperator(value)` - Normalize a bounded operator into the standard Functional Analysis representation. +44. `functionalAnalysisCanonicalizeBoundedOperator(value)` - Canonicalize a bounded operator so equivalent inputs share one form. +45. `functionalAnalysisParseBoundedOperator(text)` - Parse a text or structured value into a bounded operator. +46. `functionalAnalysisFormatBoundedOperator(value)` - Format a bounded operator for deterministic user-facing output. +47. `functionalAnalysisCompareBoundedOperator(left, right)` - Compare two bounded operator values under the conventions of Functional Analysis. +48. `functionalAnalysisCombineBoundedOperator(left, right)` - Combine two bounded operator values with the natural operation for Functional Analysis. +49. `functionalAnalysisDecomposeBoundedOperator(value)` - Decompose a bounded operator into simpler or canonical components. +50. `functionalAnalysisEvaluateBoundedOperator(value, point=None)` - Evaluate a bounded operator at a point, sample, or finite model. +51. `functionalAnalysisComputeBoundedOperator(value)` - Compute the central numerical or symbolic data of a bounded operator. +52. `functionalAnalysisEstimateBoundedOperator(value, samples=None)` - Estimate a bounded operator property from finite samples or approximations. +53. `functionalAnalysisApproximateBoundedOperator(value, tolerance=1e-9)` - Approximate a bounded operator with explicit tolerance controls. +54. `functionalAnalysisTransformBoundedOperator(value, mapping)` - Transform a bounded operator through a map, operator, or representation change. +55. `functionalAnalysisSimplifyBoundedOperator(value)` - Simplify a bounded operator without changing its mathematical meaning. +56. `functionalAnalysisEnumerateBoundedOperator(value, limit=None)` - Enumerate finite members, cases, or derived objects for a bounded operator. +57. `functionalAnalysisClassifyBoundedOperator(value)` - Classify a bounded operator by its standard Functional Analysis invariants. +58. `functionalAnalysisTestEquivalenceBoundedOperator(left, right)` - Test whether two bounded operator values are equivalent in Functional Analysis. +59. `functionalAnalysisGenerateExampleBoundedOperator(size=3)` - Generate a small documented example of a bounded operator. +60. `functionalAnalysisDocumentBoundedOperator(value)` - Return a structured explanation of a bounded operator and related assumptions. +61. `functionalAnalysisValidateInnerProduct(value)` - Validate the inner product representation and domain rules for Functional Analysis. +62. `functionalAnalysisConstructInnerProduct(*args)` - Construct a inner product from explicit inputs for Functional Analysis. +63. `functionalAnalysisNormalizeInnerProduct(value)` - Normalize a inner product into the standard Functional Analysis representation. +64. `functionalAnalysisCanonicalizeInnerProduct(value)` - Canonicalize a inner product so equivalent inputs share one form. +65. `functionalAnalysisParseInnerProduct(text)` - Parse a text or structured value into a inner product. +66. `functionalAnalysisFormatInnerProduct(value)` - Format a inner product for deterministic user-facing output. +67. `functionalAnalysisCompareInnerProduct(left, right)` - Compare two inner product values under the conventions of Functional Analysis. +68. `functionalAnalysisCombineInnerProduct(left, right)` - Combine two inner product values with the natural operation for Functional Analysis. +69. `functionalAnalysisDecomposeInnerProduct(value)` - Decompose a inner product into simpler or canonical components. +70. `functionalAnalysisEvaluateInnerProduct(value, point=None)` - Evaluate a inner product at a point, sample, or finite model. +71. `functionalAnalysisComputeInnerProduct(value)` - Compute the central numerical or symbolic data of a inner product. +72. `functionalAnalysisEstimateInnerProduct(value, samples=None)` - Estimate a inner product property from finite samples or approximations. +73. `functionalAnalysisApproximateInnerProduct(value, tolerance=1e-9)` - Approximate a inner product with explicit tolerance controls. +74. `functionalAnalysisTransformInnerProduct(value, mapping)` - Transform a inner product through a map, operator, or representation change. +75. `functionalAnalysisSimplifyInnerProduct(value)` - Simplify a inner product without changing its mathematical meaning. +76. `functionalAnalysisEnumerateInnerProduct(value, limit=None)` - Enumerate finite members, cases, or derived objects for a inner product. +77. `functionalAnalysisClassifyInnerProduct(value)` - Classify a inner product by its standard Functional Analysis invariants. +78. `functionalAnalysisTestEquivalenceInnerProduct(left, right)` - Test whether two inner product values are equivalent in Functional Analysis. +79. `functionalAnalysisGenerateExampleInnerProduct(size=3)` - Generate a small documented example of a inner product. +80. `functionalAnalysisDocumentInnerProduct(value)` - Return a structured explanation of a inner product and related assumptions. +81. `functionalAnalysisValidateCompleteSpace(value)` - Validate the complete space representation and domain rules for Functional Analysis. +82. `functionalAnalysisConstructCompleteSpace(*args)` - Construct a complete space from explicit inputs for Functional Analysis. +83. `functionalAnalysisNormalizeCompleteSpace(value)` - Normalize a complete space into the standard Functional Analysis representation. +84. `functionalAnalysisCanonicalizeCompleteSpace(value)` - Canonicalize a complete space so equivalent inputs share one form. +85. `functionalAnalysisParseCompleteSpace(text)` - Parse a text or structured value into a complete space. +86. `functionalAnalysisFormatCompleteSpace(value)` - Format a complete space for deterministic user-facing output. +87. `functionalAnalysisCompareCompleteSpace(left, right)` - Compare two complete space values under the conventions of Functional Analysis. +88. `functionalAnalysisCombineCompleteSpace(left, right)` - Combine two complete space values with the natural operation for Functional Analysis. +89. `functionalAnalysisDecomposeCompleteSpace(value)` - Decompose a complete space into simpler or canonical components. +90. `functionalAnalysisEvaluateCompleteSpace(value, point=None)` - Evaluate a complete space at a point, sample, or finite model. +91. `functionalAnalysisComputeCompleteSpace(value)` - Compute the central numerical or symbolic data of a complete space. +92. `functionalAnalysisEstimateCompleteSpace(value, samples=None)` - Estimate a complete space property from finite samples or approximations. +93. `functionalAnalysisApproximateCompleteSpace(value, tolerance=1e-9)` - Approximate a complete space with explicit tolerance controls. +94. `functionalAnalysisTransformCompleteSpace(value, mapping)` - Transform a complete space through a map, operator, or representation change. +95. `functionalAnalysisSimplifyCompleteSpace(value)` - Simplify a complete space without changing its mathematical meaning. +96. `functionalAnalysisEnumerateCompleteSpace(value, limit=None)` - Enumerate finite members, cases, or derived objects for a complete space. +97. `functionalAnalysisClassifyCompleteSpace(value)` - Classify a complete space by its standard Functional Analysis invariants. +98. `functionalAnalysisTestEquivalenceCompleteSpace(left, right)` - Test whether two complete space values are equivalent in Functional Analysis. +99. `functionalAnalysisGenerateExampleCompleteSpace(size=3)` - Generate a small documented example of a complete space. +100. `functionalAnalysisDocumentCompleteSpace(value)` - Return a structured explanation of a complete space and related assumptions. + +### Operator Theory + +Core object families: + +- operator +- adjoint +- projection +- spectrum +- operator algebra + +Candidate functions: + +1. `operatorTheoryValidateOperator(value)` - Validate the operator representation and domain rules for Operator Theory. +2. `operatorTheoryConstructOperator(*args)` - Construct a operator from explicit inputs for Operator Theory. +3. `operatorTheoryNormalizeOperator(value)` - Normalize a operator into the standard Operator Theory representation. +4. `operatorTheoryCanonicalizeOperator(value)` - Canonicalize a operator so equivalent inputs share one form. +5. `operatorTheoryParseOperator(text)` - Parse a text or structured value into a operator. +6. `operatorTheoryFormatOperator(value)` - Format a operator for deterministic user-facing output. +7. `operatorTheoryCompareOperator(left, right)` - Compare two operator values under the conventions of Operator Theory. +8. `operatorTheoryCombineOperator(left, right)` - Combine two operator values with the natural operation for Operator Theory. +9. `operatorTheoryDecomposeOperator(value)` - Decompose a operator into simpler or canonical components. +10. `operatorTheoryEvaluateOperator(value, point=None)` - Evaluate a operator at a point, sample, or finite model. +11. `operatorTheoryComputeOperator(value)` - Compute the central numerical or symbolic data of a operator. +12. `operatorTheoryEstimateOperator(value, samples=None)` - Estimate a operator property from finite samples or approximations. +13. `operatorTheoryApproximateOperator(value, tolerance=1e-9)` - Approximate a operator with explicit tolerance controls. +14. `operatorTheoryTransformOperator(value, mapping)` - Transform a operator through a map, operator, or representation change. +15. `operatorTheorySimplifyOperator(value)` - Simplify a operator without changing its mathematical meaning. +16. `operatorTheoryEnumerateOperator(value, limit=None)` - Enumerate finite members, cases, or derived objects for a operator. +17. `operatorTheoryClassifyOperator(value)` - Classify a operator by its standard Operator Theory invariants. +18. `operatorTheoryTestEquivalenceOperator(left, right)` - Test whether two operator values are equivalent in Operator Theory. +19. `operatorTheoryGenerateExampleOperator(size=3)` - Generate a small documented example of a operator. +20. `operatorTheoryDocumentOperator(value)` - Return a structured explanation of a operator and related assumptions. +21. `operatorTheoryValidateAdjoint(value)` - Validate the adjoint representation and domain rules for Operator Theory. +22. `operatorTheoryConstructAdjoint(*args)` - Construct a adjoint from explicit inputs for Operator Theory. +23. `operatorTheoryNormalizeAdjoint(value)` - Normalize a adjoint into the standard Operator Theory representation. +24. `operatorTheoryCanonicalizeAdjoint(value)` - Canonicalize a adjoint so equivalent inputs share one form. +25. `operatorTheoryParseAdjoint(text)` - Parse a text or structured value into a adjoint. +26. `operatorTheoryFormatAdjoint(value)` - Format a adjoint for deterministic user-facing output. +27. `operatorTheoryCompareAdjoint(left, right)` - Compare two adjoint values under the conventions of Operator Theory. +28. `operatorTheoryCombineAdjoint(left, right)` - Combine two adjoint values with the natural operation for Operator Theory. +29. `operatorTheoryDecomposeAdjoint(value)` - Decompose a adjoint into simpler or canonical components. +30. `operatorTheoryEvaluateAdjoint(value, point=None)` - Evaluate a adjoint at a point, sample, or finite model. +31. `operatorTheoryComputeAdjoint(value)` - Compute the central numerical or symbolic data of a adjoint. +32. `operatorTheoryEstimateAdjoint(value, samples=None)` - Estimate a adjoint property from finite samples or approximations. +33. `operatorTheoryApproximateAdjoint(value, tolerance=1e-9)` - Approximate a adjoint with explicit tolerance controls. +34. `operatorTheoryTransformAdjoint(value, mapping)` - Transform a adjoint through a map, operator, or representation change. +35. `operatorTheorySimplifyAdjoint(value)` - Simplify a adjoint without changing its mathematical meaning. +36. `operatorTheoryEnumerateAdjoint(value, limit=None)` - Enumerate finite members, cases, or derived objects for a adjoint. +37. `operatorTheoryClassifyAdjoint(value)` - Classify a adjoint by its standard Operator Theory invariants. +38. `operatorTheoryTestEquivalenceAdjoint(left, right)` - Test whether two adjoint values are equivalent in Operator Theory. +39. `operatorTheoryGenerateExampleAdjoint(size=3)` - Generate a small documented example of a adjoint. +40. `operatorTheoryDocumentAdjoint(value)` - Return a structured explanation of a adjoint and related assumptions. +41. `operatorTheoryValidateProjection(value)` - Validate the projection representation and domain rules for Operator Theory. +42. `operatorTheoryConstructProjection(*args)` - Construct a projection from explicit inputs for Operator Theory. +43. `operatorTheoryNormalizeProjection(value)` - Normalize a projection into the standard Operator Theory representation. +44. `operatorTheoryCanonicalizeProjection(value)` - Canonicalize a projection so equivalent inputs share one form. +45. `operatorTheoryParseProjection(text)` - Parse a text or structured value into a projection. +46. `operatorTheoryFormatProjection(value)` - Format a projection for deterministic user-facing output. +47. `operatorTheoryCompareProjection(left, right)` - Compare two projection values under the conventions of Operator Theory. +48. `operatorTheoryCombineProjection(left, right)` - Combine two projection values with the natural operation for Operator Theory. +49. `operatorTheoryDecomposeProjection(value)` - Decompose a projection into simpler or canonical components. +50. `operatorTheoryEvaluateProjection(value, point=None)` - Evaluate a projection at a point, sample, or finite model. +51. `operatorTheoryComputeProjection(value)` - Compute the central numerical or symbolic data of a projection. +52. `operatorTheoryEstimateProjection(value, samples=None)` - Estimate a projection property from finite samples or approximations. +53. `operatorTheoryApproximateProjection(value, tolerance=1e-9)` - Approximate a projection with explicit tolerance controls. +54. `operatorTheoryTransformProjection(value, mapping)` - Transform a projection through a map, operator, or representation change. +55. `operatorTheorySimplifyProjection(value)` - Simplify a projection without changing its mathematical meaning. +56. `operatorTheoryEnumerateProjection(value, limit=None)` - Enumerate finite members, cases, or derived objects for a projection. +57. `operatorTheoryClassifyProjection(value)` - Classify a projection by its standard Operator Theory invariants. +58. `operatorTheoryTestEquivalenceProjection(left, right)` - Test whether two projection values are equivalent in Operator Theory. +59. `operatorTheoryGenerateExampleProjection(size=3)` - Generate a small documented example of a projection. +60. `operatorTheoryDocumentProjection(value)` - Return a structured explanation of a projection and related assumptions. +61. `operatorTheoryValidateSpectrum(value)` - Validate the spectrum representation and domain rules for Operator Theory. +62. `operatorTheoryConstructSpectrum(*args)` - Construct a spectrum from explicit inputs for Operator Theory. +63. `operatorTheoryNormalizeSpectrum(value)` - Normalize a spectrum into the standard Operator Theory representation. +64. `operatorTheoryCanonicalizeSpectrum(value)` - Canonicalize a spectrum so equivalent inputs share one form. +65. `operatorTheoryParseSpectrum(text)` - Parse a text or structured value into a spectrum. +66. `operatorTheoryFormatSpectrum(value)` - Format a spectrum for deterministic user-facing output. +67. `operatorTheoryCompareSpectrum(left, right)` - Compare two spectrum values under the conventions of Operator Theory. +68. `operatorTheoryCombineSpectrum(left, right)` - Combine two spectrum values with the natural operation for Operator Theory. +69. `operatorTheoryDecomposeSpectrum(value)` - Decompose a spectrum into simpler or canonical components. +70. `operatorTheoryEvaluateSpectrum(value, point=None)` - Evaluate a spectrum at a point, sample, or finite model. +71. `operatorTheoryComputeSpectrum(value)` - Compute the central numerical or symbolic data of a spectrum. +72. `operatorTheoryEstimateSpectrum(value, samples=None)` - Estimate a spectrum property from finite samples or approximations. +73. `operatorTheoryApproximateSpectrum(value, tolerance=1e-9)` - Approximate a spectrum with explicit tolerance controls. +74. `operatorTheoryTransformSpectrum(value, mapping)` - Transform a spectrum through a map, operator, or representation change. +75. `operatorTheorySimplifySpectrum(value)` - Simplify a spectrum without changing its mathematical meaning. +76. `operatorTheoryEnumerateSpectrum(value, limit=None)` - Enumerate finite members, cases, or derived objects for a spectrum. +77. `operatorTheoryClassifySpectrum(value)` - Classify a spectrum by its standard Operator Theory invariants. +78. `operatorTheoryTestEquivalenceSpectrum(left, right)` - Test whether two spectrum values are equivalent in Operator Theory. +79. `operatorTheoryGenerateExampleSpectrum(size=3)` - Generate a small documented example of a spectrum. +80. `operatorTheoryDocumentSpectrum(value)` - Return a structured explanation of a spectrum and related assumptions. +81. `operatorTheoryValidateOperatorAlgebra(value)` - Validate the operator algebra representation and domain rules for Operator Theory. +82. `operatorTheoryConstructOperatorAlgebra(*args)` - Construct a operator algebra from explicit inputs for Operator Theory. +83. `operatorTheoryNormalizeOperatorAlgebra(value)` - Normalize a operator algebra into the standard Operator Theory representation. +84. `operatorTheoryCanonicalizeOperatorAlgebra(value)` - Canonicalize a operator algebra so equivalent inputs share one form. +85. `operatorTheoryParseOperatorAlgebra(text)` - Parse a text or structured value into a operator algebra. +86. `operatorTheoryFormatOperatorAlgebra(value)` - Format a operator algebra for deterministic user-facing output. +87. `operatorTheoryCompareOperatorAlgebra(left, right)` - Compare two operator algebra values under the conventions of Operator Theory. +88. `operatorTheoryCombineOperatorAlgebra(left, right)` - Combine two operator algebra values with the natural operation for Operator Theory. +89. `operatorTheoryDecomposeOperatorAlgebra(value)` - Decompose a operator algebra into simpler or canonical components. +90. `operatorTheoryEvaluateOperatorAlgebra(value, point=None)` - Evaluate a operator algebra at a point, sample, or finite model. +91. `operatorTheoryComputeOperatorAlgebra(value)` - Compute the central numerical or symbolic data of a operator algebra. +92. `operatorTheoryEstimateOperatorAlgebra(value, samples=None)` - Estimate a operator algebra property from finite samples or approximations. +93. `operatorTheoryApproximateOperatorAlgebra(value, tolerance=1e-9)` - Approximate a operator algebra with explicit tolerance controls. +94. `operatorTheoryTransformOperatorAlgebra(value, mapping)` - Transform a operator algebra through a map, operator, or representation change. +95. `operatorTheorySimplifyOperatorAlgebra(value)` - Simplify a operator algebra without changing its mathematical meaning. +96. `operatorTheoryEnumerateOperatorAlgebra(value, limit=None)` - Enumerate finite members, cases, or derived objects for a operator algebra. +97. `operatorTheoryClassifyOperatorAlgebra(value)` - Classify a operator algebra by its standard Operator Theory invariants. +98. `operatorTheoryTestEquivalenceOperatorAlgebra(left, right)` - Test whether two operator algebra values are equivalent in Operator Theory. +99. `operatorTheoryGenerateExampleOperatorAlgebra(size=3)` - Generate a small documented example of a operator algebra. +100. `operatorTheoryDocumentOperatorAlgebra(value)` - Return a structured explanation of a operator algebra and related assumptions. + +### Harmonic Analysis + +Core object families: + +- harmonic signal +- kernel +- frequency band +- convolution operator +- basis expansion + +Candidate functions: + +1. `harmonicAnalysisValidateHarmonicSignal(value)` - Validate the harmonic signal representation and domain rules for Harmonic Analysis. +2. `harmonicAnalysisConstructHarmonicSignal(*args)` - Construct a harmonic signal from explicit inputs for Harmonic Analysis. +3. `harmonicAnalysisNormalizeHarmonicSignal(value)` - Normalize a harmonic signal into the standard Harmonic Analysis representation. +4. `harmonicAnalysisCanonicalizeHarmonicSignal(value)` - Canonicalize a harmonic signal so equivalent inputs share one form. +5. `harmonicAnalysisParseHarmonicSignal(text)` - Parse a text or structured value into a harmonic signal. +6. `harmonicAnalysisFormatHarmonicSignal(value)` - Format a harmonic signal for deterministic user-facing output. +7. `harmonicAnalysisCompareHarmonicSignal(left, right)` - Compare two harmonic signal values under the conventions of Harmonic Analysis. +8. `harmonicAnalysisCombineHarmonicSignal(left, right)` - Combine two harmonic signal values with the natural operation for Harmonic Analysis. +9. `harmonicAnalysisDecomposeHarmonicSignal(value)` - Decompose a harmonic signal into simpler or canonical components. +10. `harmonicAnalysisEvaluateHarmonicSignal(value, point=None)` - Evaluate a harmonic signal at a point, sample, or finite model. +11. `harmonicAnalysisComputeHarmonicSignal(value)` - Compute the central numerical or symbolic data of a harmonic signal. +12. `harmonicAnalysisEstimateHarmonicSignal(value, samples=None)` - Estimate a harmonic signal property from finite samples or approximations. +13. `harmonicAnalysisApproximateHarmonicSignal(value, tolerance=1e-9)` - Approximate a harmonic signal with explicit tolerance controls. +14. `harmonicAnalysisTransformHarmonicSignal(value, mapping)` - Transform a harmonic signal through a map, operator, or representation change. +15. `harmonicAnalysisSimplifyHarmonicSignal(value)` - Simplify a harmonic signal without changing its mathematical meaning. +16. `harmonicAnalysisEnumerateHarmonicSignal(value, limit=None)` - Enumerate finite members, cases, or derived objects for a harmonic signal. +17. `harmonicAnalysisClassifyHarmonicSignal(value)` - Classify a harmonic signal by its standard Harmonic Analysis invariants. +18. `harmonicAnalysisTestEquivalenceHarmonicSignal(left, right)` - Test whether two harmonic signal values are equivalent in Harmonic Analysis. +19. `harmonicAnalysisGenerateExampleHarmonicSignal(size=3)` - Generate a small documented example of a harmonic signal. +20. `harmonicAnalysisDocumentHarmonicSignal(value)` - Return a structured explanation of a harmonic signal and related assumptions. +21. `harmonicAnalysisValidateKernel(value)` - Validate the kernel representation and domain rules for Harmonic Analysis. +22. `harmonicAnalysisConstructKernel(*args)` - Construct a kernel from explicit inputs for Harmonic Analysis. +23. `harmonicAnalysisNormalizeKernel(value)` - Normalize a kernel into the standard Harmonic Analysis representation. +24. `harmonicAnalysisCanonicalizeKernel(value)` - Canonicalize a kernel so equivalent inputs share one form. +25. `harmonicAnalysisParseKernel(text)` - Parse a text or structured value into a kernel. +26. `harmonicAnalysisFormatKernel(value)` - Format a kernel for deterministic user-facing output. +27. `harmonicAnalysisCompareKernel(left, right)` - Compare two kernel values under the conventions of Harmonic Analysis. +28. `harmonicAnalysisCombineKernel(left, right)` - Combine two kernel values with the natural operation for Harmonic Analysis. +29. `harmonicAnalysisDecomposeKernel(value)` - Decompose a kernel into simpler or canonical components. +30. `harmonicAnalysisEvaluateKernel(value, point=None)` - Evaluate a kernel at a point, sample, or finite model. +31. `harmonicAnalysisComputeKernel(value)` - Compute the central numerical or symbolic data of a kernel. +32. `harmonicAnalysisEstimateKernel(value, samples=None)` - Estimate a kernel property from finite samples or approximations. +33. `harmonicAnalysisApproximateKernel(value, tolerance=1e-9)` - Approximate a kernel with explicit tolerance controls. +34. `harmonicAnalysisTransformKernel(value, mapping)` - Transform a kernel through a map, operator, or representation change. +35. `harmonicAnalysisSimplifyKernel(value)` - Simplify a kernel without changing its mathematical meaning. +36. `harmonicAnalysisEnumerateKernel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a kernel. +37. `harmonicAnalysisClassifyKernel(value)` - Classify a kernel by its standard Harmonic Analysis invariants. +38. `harmonicAnalysisTestEquivalenceKernel(left, right)` - Test whether two kernel values are equivalent in Harmonic Analysis. +39. `harmonicAnalysisGenerateExampleKernel(size=3)` - Generate a small documented example of a kernel. +40. `harmonicAnalysisDocumentKernel(value)` - Return a structured explanation of a kernel and related assumptions. +41. `harmonicAnalysisValidateFrequencyBand(value)` - Validate the frequency band representation and domain rules for Harmonic Analysis. +42. `harmonicAnalysisConstructFrequencyBand(*args)` - Construct a frequency band from explicit inputs for Harmonic Analysis. +43. `harmonicAnalysisNormalizeFrequencyBand(value)` - Normalize a frequency band into the standard Harmonic Analysis representation. +44. `harmonicAnalysisCanonicalizeFrequencyBand(value)` - Canonicalize a frequency band so equivalent inputs share one form. +45. `harmonicAnalysisParseFrequencyBand(text)` - Parse a text or structured value into a frequency band. +46. `harmonicAnalysisFormatFrequencyBand(value)` - Format a frequency band for deterministic user-facing output. +47. `harmonicAnalysisCompareFrequencyBand(left, right)` - Compare two frequency band values under the conventions of Harmonic Analysis. +48. `harmonicAnalysisCombineFrequencyBand(left, right)` - Combine two frequency band values with the natural operation for Harmonic Analysis. +49. `harmonicAnalysisDecomposeFrequencyBand(value)` - Decompose a frequency band into simpler or canonical components. +50. `harmonicAnalysisEvaluateFrequencyBand(value, point=None)` - Evaluate a frequency band at a point, sample, or finite model. +51. `harmonicAnalysisComputeFrequencyBand(value)` - Compute the central numerical or symbolic data of a frequency band. +52. `harmonicAnalysisEstimateFrequencyBand(value, samples=None)` - Estimate a frequency band property from finite samples or approximations. +53. `harmonicAnalysisApproximateFrequencyBand(value, tolerance=1e-9)` - Approximate a frequency band with explicit tolerance controls. +54. `harmonicAnalysisTransformFrequencyBand(value, mapping)` - Transform a frequency band through a map, operator, or representation change. +55. `harmonicAnalysisSimplifyFrequencyBand(value)` - Simplify a frequency band without changing its mathematical meaning. +56. `harmonicAnalysisEnumerateFrequencyBand(value, limit=None)` - Enumerate finite members, cases, or derived objects for a frequency band. +57. `harmonicAnalysisClassifyFrequencyBand(value)` - Classify a frequency band by its standard Harmonic Analysis invariants. +58. `harmonicAnalysisTestEquivalenceFrequencyBand(left, right)` - Test whether two frequency band values are equivalent in Harmonic Analysis. +59. `harmonicAnalysisGenerateExampleFrequencyBand(size=3)` - Generate a small documented example of a frequency band. +60. `harmonicAnalysisDocumentFrequencyBand(value)` - Return a structured explanation of a frequency band and related assumptions. +61. `harmonicAnalysisValidateConvolutionOperator(value)` - Validate the convolution operator representation and domain rules for Harmonic Analysis. +62. `harmonicAnalysisConstructConvolutionOperator(*args)` - Construct a convolution operator from explicit inputs for Harmonic Analysis. +63. `harmonicAnalysisNormalizeConvolutionOperator(value)` - Normalize a convolution operator into the standard Harmonic Analysis representation. +64. `harmonicAnalysisCanonicalizeConvolutionOperator(value)` - Canonicalize a convolution operator so equivalent inputs share one form. +65. `harmonicAnalysisParseConvolutionOperator(text)` - Parse a text or structured value into a convolution operator. +66. `harmonicAnalysisFormatConvolutionOperator(value)` - Format a convolution operator for deterministic user-facing output. +67. `harmonicAnalysisCompareConvolutionOperator(left, right)` - Compare two convolution operator values under the conventions of Harmonic Analysis. +68. `harmonicAnalysisCombineConvolutionOperator(left, right)` - Combine two convolution operator values with the natural operation for Harmonic Analysis. +69. `harmonicAnalysisDecomposeConvolutionOperator(value)` - Decompose a convolution operator into simpler or canonical components. +70. `harmonicAnalysisEvaluateConvolutionOperator(value, point=None)` - Evaluate a convolution operator at a point, sample, or finite model. +71. `harmonicAnalysisComputeConvolutionOperator(value)` - Compute the central numerical or symbolic data of a convolution operator. +72. `harmonicAnalysisEstimateConvolutionOperator(value, samples=None)` - Estimate a convolution operator property from finite samples or approximations. +73. `harmonicAnalysisApproximateConvolutionOperator(value, tolerance=1e-9)` - Approximate a convolution operator with explicit tolerance controls. +74. `harmonicAnalysisTransformConvolutionOperator(value, mapping)` - Transform a convolution operator through a map, operator, or representation change. +75. `harmonicAnalysisSimplifyConvolutionOperator(value)` - Simplify a convolution operator without changing its mathematical meaning. +76. `harmonicAnalysisEnumerateConvolutionOperator(value, limit=None)` - Enumerate finite members, cases, or derived objects for a convolution operator. +77. `harmonicAnalysisClassifyConvolutionOperator(value)` - Classify a convolution operator by its standard Harmonic Analysis invariants. +78. `harmonicAnalysisTestEquivalenceConvolutionOperator(left, right)` - Test whether two convolution operator values are equivalent in Harmonic Analysis. +79. `harmonicAnalysisGenerateExampleConvolutionOperator(size=3)` - Generate a small documented example of a convolution operator. +80. `harmonicAnalysisDocumentConvolutionOperator(value)` - Return a structured explanation of a convolution operator and related assumptions. +81. `harmonicAnalysisValidateBasisExpansion(value)` - Validate the basis expansion representation and domain rules for Harmonic Analysis. +82. `harmonicAnalysisConstructBasisExpansion(*args)` - Construct a basis expansion from explicit inputs for Harmonic Analysis. +83. `harmonicAnalysisNormalizeBasisExpansion(value)` - Normalize a basis expansion into the standard Harmonic Analysis representation. +84. `harmonicAnalysisCanonicalizeBasisExpansion(value)` - Canonicalize a basis expansion so equivalent inputs share one form. +85. `harmonicAnalysisParseBasisExpansion(text)` - Parse a text or structured value into a basis expansion. +86. `harmonicAnalysisFormatBasisExpansion(value)` - Format a basis expansion for deterministic user-facing output. +87. `harmonicAnalysisCompareBasisExpansion(left, right)` - Compare two basis expansion values under the conventions of Harmonic Analysis. +88. `harmonicAnalysisCombineBasisExpansion(left, right)` - Combine two basis expansion values with the natural operation for Harmonic Analysis. +89. `harmonicAnalysisDecomposeBasisExpansion(value)` - Decompose a basis expansion into simpler or canonical components. +90. `harmonicAnalysisEvaluateBasisExpansion(value, point=None)` - Evaluate a basis expansion at a point, sample, or finite model. +91. `harmonicAnalysisComputeBasisExpansion(value)` - Compute the central numerical or symbolic data of a basis expansion. +92. `harmonicAnalysisEstimateBasisExpansion(value, samples=None)` - Estimate a basis expansion property from finite samples or approximations. +93. `harmonicAnalysisApproximateBasisExpansion(value, tolerance=1e-9)` - Approximate a basis expansion with explicit tolerance controls. +94. `harmonicAnalysisTransformBasisExpansion(value, mapping)` - Transform a basis expansion through a map, operator, or representation change. +95. `harmonicAnalysisSimplifyBasisExpansion(value)` - Simplify a basis expansion without changing its mathematical meaning. +96. `harmonicAnalysisEnumerateBasisExpansion(value, limit=None)` - Enumerate finite members, cases, or derived objects for a basis expansion. +97. `harmonicAnalysisClassifyBasisExpansion(value)` - Classify a basis expansion by its standard Harmonic Analysis invariants. +98. `harmonicAnalysisTestEquivalenceBasisExpansion(left, right)` - Test whether two basis expansion values are equivalent in Harmonic Analysis. +99. `harmonicAnalysisGenerateExampleBasisExpansion(size=3)` - Generate a small documented example of a basis expansion. +100. `harmonicAnalysisDocumentBasisExpansion(value)` - Return a structured explanation of a basis expansion and related assumptions. + +### Partial Differential Equations + +Core object families: + +- grid function +- boundary condition +- difference stencil +- pde model +- stability condition + +Candidate functions: + +1. `partialDifferentialEquationsValidateGridFunction(value)` - Validate the grid function representation and domain rules for Partial Differential Equations. +2. `partialDifferentialEquationsConstructGridFunction(*args)` - Construct a grid function from explicit inputs for Partial Differential Equations. +3. `partialDifferentialEquationsNormalizeGridFunction(value)` - Normalize a grid function into the standard Partial Differential Equations representation. +4. `partialDifferentialEquationsCanonicalizeGridFunction(value)` - Canonicalize a grid function so equivalent inputs share one form. +5. `partialDifferentialEquationsParseGridFunction(text)` - Parse a text or structured value into a grid function. +6. `partialDifferentialEquationsFormatGridFunction(value)` - Format a grid function for deterministic user-facing output. +7. `partialDifferentialEquationsCompareGridFunction(left, right)` - Compare two grid function values under the conventions of Partial Differential Equations. +8. `partialDifferentialEquationsCombineGridFunction(left, right)` - Combine two grid function values with the natural operation for Partial Differential Equations. +9. `partialDifferentialEquationsDecomposeGridFunction(value)` - Decompose a grid function into simpler or canonical components. +10. `partialDifferentialEquationsEvaluateGridFunction(value, point=None)` - Evaluate a grid function at a point, sample, or finite model. +11. `partialDifferentialEquationsComputeGridFunction(value)` - Compute the central numerical or symbolic data of a grid function. +12. `partialDifferentialEquationsEstimateGridFunction(value, samples=None)` - Estimate a grid function property from finite samples or approximations. +13. `partialDifferentialEquationsApproximateGridFunction(value, tolerance=1e-9)` - Approximate a grid function with explicit tolerance controls. +14. `partialDifferentialEquationsTransformGridFunction(value, mapping)` - Transform a grid function through a map, operator, or representation change. +15. `partialDifferentialEquationsSimplifyGridFunction(value)` - Simplify a grid function without changing its mathematical meaning. +16. `partialDifferentialEquationsEnumerateGridFunction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a grid function. +17. `partialDifferentialEquationsClassifyGridFunction(value)` - Classify a grid function by its standard Partial Differential Equations invariants. +18. `partialDifferentialEquationsTestEquivalenceGridFunction(left, right)` - Test whether two grid function values are equivalent in Partial Differential Equations. +19. `partialDifferentialEquationsGenerateExampleGridFunction(size=3)` - Generate a small documented example of a grid function. +20. `partialDifferentialEquationsDocumentGridFunction(value)` - Return a structured explanation of a grid function and related assumptions. +21. `partialDifferentialEquationsValidateBoundaryCondition(value)` - Validate the boundary condition representation and domain rules for Partial Differential Equations. +22. `partialDifferentialEquationsConstructBoundaryCondition(*args)` - Construct a boundary condition from explicit inputs for Partial Differential Equations. +23. `partialDifferentialEquationsNormalizeBoundaryCondition(value)` - Normalize a boundary condition into the standard Partial Differential Equations representation. +24. `partialDifferentialEquationsCanonicalizeBoundaryCondition(value)` - Canonicalize a boundary condition so equivalent inputs share one form. +25. `partialDifferentialEquationsParseBoundaryCondition(text)` - Parse a text or structured value into a boundary condition. +26. `partialDifferentialEquationsFormatBoundaryCondition(value)` - Format a boundary condition for deterministic user-facing output. +27. `partialDifferentialEquationsCompareBoundaryCondition(left, right)` - Compare two boundary condition values under the conventions of Partial Differential Equations. +28. `partialDifferentialEquationsCombineBoundaryCondition(left, right)` - Combine two boundary condition values with the natural operation for Partial Differential Equations. +29. `partialDifferentialEquationsDecomposeBoundaryCondition(value)` - Decompose a boundary condition into simpler or canonical components. +30. `partialDifferentialEquationsEvaluateBoundaryCondition(value, point=None)` - Evaluate a boundary condition at a point, sample, or finite model. +31. `partialDifferentialEquationsComputeBoundaryCondition(value)` - Compute the central numerical or symbolic data of a boundary condition. +32. `partialDifferentialEquationsEstimateBoundaryCondition(value, samples=None)` - Estimate a boundary condition property from finite samples or approximations. +33. `partialDifferentialEquationsApproximateBoundaryCondition(value, tolerance=1e-9)` - Approximate a boundary condition with explicit tolerance controls. +34. `partialDifferentialEquationsTransformBoundaryCondition(value, mapping)` - Transform a boundary condition through a map, operator, or representation change. +35. `partialDifferentialEquationsSimplifyBoundaryCondition(value)` - Simplify a boundary condition without changing its mathematical meaning. +36. `partialDifferentialEquationsEnumerateBoundaryCondition(value, limit=None)` - Enumerate finite members, cases, or derived objects for a boundary condition. +37. `partialDifferentialEquationsClassifyBoundaryCondition(value)` - Classify a boundary condition by its standard Partial Differential Equations invariants. +38. `partialDifferentialEquationsTestEquivalenceBoundaryCondition(left, right)` - Test whether two boundary condition values are equivalent in Partial Differential Equations. +39. `partialDifferentialEquationsGenerateExampleBoundaryCondition(size=3)` - Generate a small documented example of a boundary condition. +40. `partialDifferentialEquationsDocumentBoundaryCondition(value)` - Return a structured explanation of a boundary condition and related assumptions. +41. `partialDifferentialEquationsValidateDifferenceStencil(value)` - Validate the difference stencil representation and domain rules for Partial Differential Equations. +42. `partialDifferentialEquationsConstructDifferenceStencil(*args)` - Construct a difference stencil from explicit inputs for Partial Differential Equations. +43. `partialDifferentialEquationsNormalizeDifferenceStencil(value)` - Normalize a difference stencil into the standard Partial Differential Equations representation. +44. `partialDifferentialEquationsCanonicalizeDifferenceStencil(value)` - Canonicalize a difference stencil so equivalent inputs share one form. +45. `partialDifferentialEquationsParseDifferenceStencil(text)` - Parse a text or structured value into a difference stencil. +46. `partialDifferentialEquationsFormatDifferenceStencil(value)` - Format a difference stencil for deterministic user-facing output. +47. `partialDifferentialEquationsCompareDifferenceStencil(left, right)` - Compare two difference stencil values under the conventions of Partial Differential Equations. +48. `partialDifferentialEquationsCombineDifferenceStencil(left, right)` - Combine two difference stencil values with the natural operation for Partial Differential Equations. +49. `partialDifferentialEquationsDecomposeDifferenceStencil(value)` - Decompose a difference stencil into simpler or canonical components. +50. `partialDifferentialEquationsEvaluateDifferenceStencil(value, point=None)` - Evaluate a difference stencil at a point, sample, or finite model. +51. `partialDifferentialEquationsComputeDifferenceStencil(value)` - Compute the central numerical or symbolic data of a difference stencil. +52. `partialDifferentialEquationsEstimateDifferenceStencil(value, samples=None)` - Estimate a difference stencil property from finite samples or approximations. +53. `partialDifferentialEquationsApproximateDifferenceStencil(value, tolerance=1e-9)` - Approximate a difference stencil with explicit tolerance controls. +54. `partialDifferentialEquationsTransformDifferenceStencil(value, mapping)` - Transform a difference stencil through a map, operator, or representation change. +55. `partialDifferentialEquationsSimplifyDifferenceStencil(value)` - Simplify a difference stencil without changing its mathematical meaning. +56. `partialDifferentialEquationsEnumerateDifferenceStencil(value, limit=None)` - Enumerate finite members, cases, or derived objects for a difference stencil. +57. `partialDifferentialEquationsClassifyDifferenceStencil(value)` - Classify a difference stencil by its standard Partial Differential Equations invariants. +58. `partialDifferentialEquationsTestEquivalenceDifferenceStencil(left, right)` - Test whether two difference stencil values are equivalent in Partial Differential Equations. +59. `partialDifferentialEquationsGenerateExampleDifferenceStencil(size=3)` - Generate a small documented example of a difference stencil. +60. `partialDifferentialEquationsDocumentDifferenceStencil(value)` - Return a structured explanation of a difference stencil and related assumptions. +61. `partialDifferentialEquationsValidatePdeModel(value)` - Validate the pde model representation and domain rules for Partial Differential Equations. +62. `partialDifferentialEquationsConstructPdeModel(*args)` - Construct a pde model from explicit inputs for Partial Differential Equations. +63. `partialDifferentialEquationsNormalizePdeModel(value)` - Normalize a pde model into the standard Partial Differential Equations representation. +64. `partialDifferentialEquationsCanonicalizePdeModel(value)` - Canonicalize a pde model so equivalent inputs share one form. +65. `partialDifferentialEquationsParsePdeModel(text)` - Parse a text or structured value into a pde model. +66. `partialDifferentialEquationsFormatPdeModel(value)` - Format a pde model for deterministic user-facing output. +67. `partialDifferentialEquationsComparePdeModel(left, right)` - Compare two pde model values under the conventions of Partial Differential Equations. +68. `partialDifferentialEquationsCombinePdeModel(left, right)` - Combine two pde model values with the natural operation for Partial Differential Equations. +69. `partialDifferentialEquationsDecomposePdeModel(value)` - Decompose a pde model into simpler or canonical components. +70. `partialDifferentialEquationsEvaluatePdeModel(value, point=None)` - Evaluate a pde model at a point, sample, or finite model. +71. `partialDifferentialEquationsComputePdeModel(value)` - Compute the central numerical or symbolic data of a pde model. +72. `partialDifferentialEquationsEstimatePdeModel(value, samples=None)` - Estimate a pde model property from finite samples or approximations. +73. `partialDifferentialEquationsApproximatePdeModel(value, tolerance=1e-9)` - Approximate a pde model with explicit tolerance controls. +74. `partialDifferentialEquationsTransformPdeModel(value, mapping)` - Transform a pde model through a map, operator, or representation change. +75. `partialDifferentialEquationsSimplifyPdeModel(value)` - Simplify a pde model without changing its mathematical meaning. +76. `partialDifferentialEquationsEnumeratePdeModel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a pde model. +77. `partialDifferentialEquationsClassifyPdeModel(value)` - Classify a pde model by its standard Partial Differential Equations invariants. +78. `partialDifferentialEquationsTestEquivalencePdeModel(left, right)` - Test whether two pde model values are equivalent in Partial Differential Equations. +79. `partialDifferentialEquationsGenerateExamplePdeModel(size=3)` - Generate a small documented example of a pde model. +80. `partialDifferentialEquationsDocumentPdeModel(value)` - Return a structured explanation of a pde model and related assumptions. +81. `partialDifferentialEquationsValidateStabilityCondition(value)` - Validate the stability condition representation and domain rules for Partial Differential Equations. +82. `partialDifferentialEquationsConstructStabilityCondition(*args)` - Construct a stability condition from explicit inputs for Partial Differential Equations. +83. `partialDifferentialEquationsNormalizeStabilityCondition(value)` - Normalize a stability condition into the standard Partial Differential Equations representation. +84. `partialDifferentialEquationsCanonicalizeStabilityCondition(value)` - Canonicalize a stability condition so equivalent inputs share one form. +85. `partialDifferentialEquationsParseStabilityCondition(text)` - Parse a text or structured value into a stability condition. +86. `partialDifferentialEquationsFormatStabilityCondition(value)` - Format a stability condition for deterministic user-facing output. +87. `partialDifferentialEquationsCompareStabilityCondition(left, right)` - Compare two stability condition values under the conventions of Partial Differential Equations. +88. `partialDifferentialEquationsCombineStabilityCondition(left, right)` - Combine two stability condition values with the natural operation for Partial Differential Equations. +89. `partialDifferentialEquationsDecomposeStabilityCondition(value)` - Decompose a stability condition into simpler or canonical components. +90. `partialDifferentialEquationsEvaluateStabilityCondition(value, point=None)` - Evaluate a stability condition at a point, sample, or finite model. +91. `partialDifferentialEquationsComputeStabilityCondition(value)` - Compute the central numerical or symbolic data of a stability condition. +92. `partialDifferentialEquationsEstimateStabilityCondition(value, samples=None)` - Estimate a stability condition property from finite samples or approximations. +93. `partialDifferentialEquationsApproximateStabilityCondition(value, tolerance=1e-9)` - Approximate a stability condition with explicit tolerance controls. +94. `partialDifferentialEquationsTransformStabilityCondition(value, mapping)` - Transform a stability condition through a map, operator, or representation change. +95. `partialDifferentialEquationsSimplifyStabilityCondition(value)` - Simplify a stability condition without changing its mathematical meaning. +96. `partialDifferentialEquationsEnumerateStabilityCondition(value, limit=None)` - Enumerate finite members, cases, or derived objects for a stability condition. +97. `partialDifferentialEquationsClassifyStabilityCondition(value)` - Classify a stability condition by its standard Partial Differential Equations invariants. +98. `partialDifferentialEquationsTestEquivalenceStabilityCondition(left, right)` - Test whether two stability condition values are equivalent in Partial Differential Equations. +99. `partialDifferentialEquationsGenerateExampleStabilityCondition(size=3)` - Generate a small documented example of a stability condition. +100. `partialDifferentialEquationsDocumentStabilityCondition(value)` - Return a structured explanation of a stability condition and related assumptions. + +### Stochastic Processes + +Core object families: + +- random process +- transition matrix +- state distribution +- martingale candidate +- hitting event + +Candidate functions: + +1. `stochasticProcessesValidateRandomProcess(value)` - Validate the random process representation and domain rules for Stochastic Processes. +2. `stochasticProcessesConstructRandomProcess(*args)` - Construct a random process from explicit inputs for Stochastic Processes. +3. `stochasticProcessesNormalizeRandomProcess(value)` - Normalize a random process into the standard Stochastic Processes representation. +4. `stochasticProcessesCanonicalizeRandomProcess(value)` - Canonicalize a random process so equivalent inputs share one form. +5. `stochasticProcessesParseRandomProcess(text)` - Parse a text or structured value into a random process. +6. `stochasticProcessesFormatRandomProcess(value)` - Format a random process for deterministic user-facing output. +7. `stochasticProcessesCompareRandomProcess(left, right)` - Compare two random process values under the conventions of Stochastic Processes. +8. `stochasticProcessesCombineRandomProcess(left, right)` - Combine two random process values with the natural operation for Stochastic Processes. +9. `stochasticProcessesDecomposeRandomProcess(value)` - Decompose a random process into simpler or canonical components. +10. `stochasticProcessesEvaluateRandomProcess(value, point=None)` - Evaluate a random process at a point, sample, or finite model. +11. `stochasticProcessesComputeRandomProcess(value)` - Compute the central numerical or symbolic data of a random process. +12. `stochasticProcessesEstimateRandomProcess(value, samples=None)` - Estimate a random process property from finite samples or approximations. +13. `stochasticProcessesApproximateRandomProcess(value, tolerance=1e-9)` - Approximate a random process with explicit tolerance controls. +14. `stochasticProcessesTransformRandomProcess(value, mapping)` - Transform a random process through a map, operator, or representation change. +15. `stochasticProcessesSimplifyRandomProcess(value)` - Simplify a random process without changing its mathematical meaning. +16. `stochasticProcessesEnumerateRandomProcess(value, limit=None)` - Enumerate finite members, cases, or derived objects for a random process. +17. `stochasticProcessesClassifyRandomProcess(value)` - Classify a random process by its standard Stochastic Processes invariants. +18. `stochasticProcessesTestEquivalenceRandomProcess(left, right)` - Test whether two random process values are equivalent in Stochastic Processes. +19. `stochasticProcessesGenerateExampleRandomProcess(size=3)` - Generate a small documented example of a random process. +20. `stochasticProcessesDocumentRandomProcess(value)` - Return a structured explanation of a random process and related assumptions. +21. `stochasticProcessesValidateTransitionMatrix(value)` - Validate the transition matrix representation and domain rules for Stochastic Processes. +22. `stochasticProcessesConstructTransitionMatrix(*args)` - Construct a transition matrix from explicit inputs for Stochastic Processes. +23. `stochasticProcessesNormalizeTransitionMatrix(value)` - Normalize a transition matrix into the standard Stochastic Processes representation. +24. `stochasticProcessesCanonicalizeTransitionMatrix(value)` - Canonicalize a transition matrix so equivalent inputs share one form. +25. `stochasticProcessesParseTransitionMatrix(text)` - Parse a text or structured value into a transition matrix. +26. `stochasticProcessesFormatTransitionMatrix(value)` - Format a transition matrix for deterministic user-facing output. +27. `stochasticProcessesCompareTransitionMatrix(left, right)` - Compare two transition matrix values under the conventions of Stochastic Processes. +28. `stochasticProcessesCombineTransitionMatrix(left, right)` - Combine two transition matrix values with the natural operation for Stochastic Processes. +29. `stochasticProcessesDecomposeTransitionMatrix(value)` - Decompose a transition matrix into simpler or canonical components. +30. `stochasticProcessesEvaluateTransitionMatrix(value, point=None)` - Evaluate a transition matrix at a point, sample, or finite model. +31. `stochasticProcessesComputeTransitionMatrix(value)` - Compute the central numerical or symbolic data of a transition matrix. +32. `stochasticProcessesEstimateTransitionMatrix(value, samples=None)` - Estimate a transition matrix property from finite samples or approximations. +33. `stochasticProcessesApproximateTransitionMatrix(value, tolerance=1e-9)` - Approximate a transition matrix with explicit tolerance controls. +34. `stochasticProcessesTransformTransitionMatrix(value, mapping)` - Transform a transition matrix through a map, operator, or representation change. +35. `stochasticProcessesSimplifyTransitionMatrix(value)` - Simplify a transition matrix without changing its mathematical meaning. +36. `stochasticProcessesEnumerateTransitionMatrix(value, limit=None)` - Enumerate finite members, cases, or derived objects for a transition matrix. +37. `stochasticProcessesClassifyTransitionMatrix(value)` - Classify a transition matrix by its standard Stochastic Processes invariants. +38. `stochasticProcessesTestEquivalenceTransitionMatrix(left, right)` - Test whether two transition matrix values are equivalent in Stochastic Processes. +39. `stochasticProcessesGenerateExampleTransitionMatrix(size=3)` - Generate a small documented example of a transition matrix. +40. `stochasticProcessesDocumentTransitionMatrix(value)` - Return a structured explanation of a transition matrix and related assumptions. +41. `stochasticProcessesValidateStateDistribution(value)` - Validate the state distribution representation and domain rules for Stochastic Processes. +42. `stochasticProcessesConstructStateDistribution(*args)` - Construct a state distribution from explicit inputs for Stochastic Processes. +43. `stochasticProcessesNormalizeStateDistribution(value)` - Normalize a state distribution into the standard Stochastic Processes representation. +44. `stochasticProcessesCanonicalizeStateDistribution(value)` - Canonicalize a state distribution so equivalent inputs share one form. +45. `stochasticProcessesParseStateDistribution(text)` - Parse a text or structured value into a state distribution. +46. `stochasticProcessesFormatStateDistribution(value)` - Format a state distribution for deterministic user-facing output. +47. `stochasticProcessesCompareStateDistribution(left, right)` - Compare two state distribution values under the conventions of Stochastic Processes. +48. `stochasticProcessesCombineStateDistribution(left, right)` - Combine two state distribution values with the natural operation for Stochastic Processes. +49. `stochasticProcessesDecomposeStateDistribution(value)` - Decompose a state distribution into simpler or canonical components. +50. `stochasticProcessesEvaluateStateDistribution(value, point=None)` - Evaluate a state distribution at a point, sample, or finite model. +51. `stochasticProcessesComputeStateDistribution(value)` - Compute the central numerical or symbolic data of a state distribution. +52. `stochasticProcessesEstimateStateDistribution(value, samples=None)` - Estimate a state distribution property from finite samples or approximations. +53. `stochasticProcessesApproximateStateDistribution(value, tolerance=1e-9)` - Approximate a state distribution with explicit tolerance controls. +54. `stochasticProcessesTransformStateDistribution(value, mapping)` - Transform a state distribution through a map, operator, or representation change. +55. `stochasticProcessesSimplifyStateDistribution(value)` - Simplify a state distribution without changing its mathematical meaning. +56. `stochasticProcessesEnumerateStateDistribution(value, limit=None)` - Enumerate finite members, cases, or derived objects for a state distribution. +57. `stochasticProcessesClassifyStateDistribution(value)` - Classify a state distribution by its standard Stochastic Processes invariants. +58. `stochasticProcessesTestEquivalenceStateDistribution(left, right)` - Test whether two state distribution values are equivalent in Stochastic Processes. +59. `stochasticProcessesGenerateExampleStateDistribution(size=3)` - Generate a small documented example of a state distribution. +60. `stochasticProcessesDocumentStateDistribution(value)` - Return a structured explanation of a state distribution and related assumptions. +61. `stochasticProcessesValidateMartingaleCandidate(value)` - Validate the martingale candidate representation and domain rules for Stochastic Processes. +62. `stochasticProcessesConstructMartingaleCandidate(*args)` - Construct a martingale candidate from explicit inputs for Stochastic Processes. +63. `stochasticProcessesNormalizeMartingaleCandidate(value)` - Normalize a martingale candidate into the standard Stochastic Processes representation. +64. `stochasticProcessesCanonicalizeMartingaleCandidate(value)` - Canonicalize a martingale candidate so equivalent inputs share one form. +65. `stochasticProcessesParseMartingaleCandidate(text)` - Parse a text or structured value into a martingale candidate. +66. `stochasticProcessesFormatMartingaleCandidate(value)` - Format a martingale candidate for deterministic user-facing output. +67. `stochasticProcessesCompareMartingaleCandidate(left, right)` - Compare two martingale candidate values under the conventions of Stochastic Processes. +68. `stochasticProcessesCombineMartingaleCandidate(left, right)` - Combine two martingale candidate values with the natural operation for Stochastic Processes. +69. `stochasticProcessesDecomposeMartingaleCandidate(value)` - Decompose a martingale candidate into simpler or canonical components. +70. `stochasticProcessesEvaluateMartingaleCandidate(value, point=None)` - Evaluate a martingale candidate at a point, sample, or finite model. +71. `stochasticProcessesComputeMartingaleCandidate(value)` - Compute the central numerical or symbolic data of a martingale candidate. +72. `stochasticProcessesEstimateMartingaleCandidate(value, samples=None)` - Estimate a martingale candidate property from finite samples or approximations. +73. `stochasticProcessesApproximateMartingaleCandidate(value, tolerance=1e-9)` - Approximate a martingale candidate with explicit tolerance controls. +74. `stochasticProcessesTransformMartingaleCandidate(value, mapping)` - Transform a martingale candidate through a map, operator, or representation change. +75. `stochasticProcessesSimplifyMartingaleCandidate(value)` - Simplify a martingale candidate without changing its mathematical meaning. +76. `stochasticProcessesEnumerateMartingaleCandidate(value, limit=None)` - Enumerate finite members, cases, or derived objects for a martingale candidate. +77. `stochasticProcessesClassifyMartingaleCandidate(value)` - Classify a martingale candidate by its standard Stochastic Processes invariants. +78. `stochasticProcessesTestEquivalenceMartingaleCandidate(left, right)` - Test whether two martingale candidate values are equivalent in Stochastic Processes. +79. `stochasticProcessesGenerateExampleMartingaleCandidate(size=3)` - Generate a small documented example of a martingale candidate. +80. `stochasticProcessesDocumentMartingaleCandidate(value)` - Return a structured explanation of a martingale candidate and related assumptions. +81. `stochasticProcessesValidateHittingEvent(value)` - Validate the hitting event representation and domain rules for Stochastic Processes. +82. `stochasticProcessesConstructHittingEvent(*args)` - Construct a hitting event from explicit inputs for Stochastic Processes. +83. `stochasticProcessesNormalizeHittingEvent(value)` - Normalize a hitting event into the standard Stochastic Processes representation. +84. `stochasticProcessesCanonicalizeHittingEvent(value)` - Canonicalize a hitting event so equivalent inputs share one form. +85. `stochasticProcessesParseHittingEvent(text)` - Parse a text or structured value into a hitting event. +86. `stochasticProcessesFormatHittingEvent(value)` - Format a hitting event for deterministic user-facing output. +87. `stochasticProcessesCompareHittingEvent(left, right)` - Compare two hitting event values under the conventions of Stochastic Processes. +88. `stochasticProcessesCombineHittingEvent(left, right)` - Combine two hitting event values with the natural operation for Stochastic Processes. +89. `stochasticProcessesDecomposeHittingEvent(value)` - Decompose a hitting event into simpler or canonical components. +90. `stochasticProcessesEvaluateHittingEvent(value, point=None)` - Evaluate a hitting event at a point, sample, or finite model. +91. `stochasticProcessesComputeHittingEvent(value)` - Compute the central numerical or symbolic data of a hitting event. +92. `stochasticProcessesEstimateHittingEvent(value, samples=None)` - Estimate a hitting event property from finite samples or approximations. +93. `stochasticProcessesApproximateHittingEvent(value, tolerance=1e-9)` - Approximate a hitting event with explicit tolerance controls. +94. `stochasticProcessesTransformHittingEvent(value, mapping)` - Transform a hitting event through a map, operator, or representation change. +95. `stochasticProcessesSimplifyHittingEvent(value)` - Simplify a hitting event without changing its mathematical meaning. +96. `stochasticProcessesEnumerateHittingEvent(value, limit=None)` - Enumerate finite members, cases, or derived objects for a hitting event. +97. `stochasticProcessesClassifyHittingEvent(value)` - Classify a hitting event by its standard Stochastic Processes invariants. +98. `stochasticProcessesTestEquivalenceHittingEvent(left, right)` - Test whether two hitting event values are equivalent in Stochastic Processes. +99. `stochasticProcessesGenerateExampleHittingEvent(size=3)` - Generate a small documented example of a hitting event. +100. `stochasticProcessesDocumentHittingEvent(value)` - Return a structured explanation of a hitting event and related assumptions. + +### Stochastic Calculus + +Core object families: + +- brownian path +- stochastic integral +- sde model +- quadratic variation +- diffusion process + +Candidate functions: + +1. `stochasticCalculusValidateBrownianPath(value)` - Validate the brownian path representation and domain rules for Stochastic Calculus. +2. `stochasticCalculusConstructBrownianPath(*args)` - Construct a brownian path from explicit inputs for Stochastic Calculus. +3. `stochasticCalculusNormalizeBrownianPath(value)` - Normalize a brownian path into the standard Stochastic Calculus representation. +4. `stochasticCalculusCanonicalizeBrownianPath(value)` - Canonicalize a brownian path so equivalent inputs share one form. +5. `stochasticCalculusParseBrownianPath(text)` - Parse a text or structured value into a brownian path. +6. `stochasticCalculusFormatBrownianPath(value)` - Format a brownian path for deterministic user-facing output. +7. `stochasticCalculusCompareBrownianPath(left, right)` - Compare two brownian path values under the conventions of Stochastic Calculus. +8. `stochasticCalculusCombineBrownianPath(left, right)` - Combine two brownian path values with the natural operation for Stochastic Calculus. +9. `stochasticCalculusDecomposeBrownianPath(value)` - Decompose a brownian path into simpler or canonical components. +10. `stochasticCalculusEvaluateBrownianPath(value, point=None)` - Evaluate a brownian path at a point, sample, or finite model. +11. `stochasticCalculusComputeBrownianPath(value)` - Compute the central numerical or symbolic data of a brownian path. +12. `stochasticCalculusEstimateBrownianPath(value, samples=None)` - Estimate a brownian path property from finite samples or approximations. +13. `stochasticCalculusApproximateBrownianPath(value, tolerance=1e-9)` - Approximate a brownian path with explicit tolerance controls. +14. `stochasticCalculusTransformBrownianPath(value, mapping)` - Transform a brownian path through a map, operator, or representation change. +15. `stochasticCalculusSimplifyBrownianPath(value)` - Simplify a brownian path without changing its mathematical meaning. +16. `stochasticCalculusEnumerateBrownianPath(value, limit=None)` - Enumerate finite members, cases, or derived objects for a brownian path. +17. `stochasticCalculusClassifyBrownianPath(value)` - Classify a brownian path by its standard Stochastic Calculus invariants. +18. `stochasticCalculusTestEquivalenceBrownianPath(left, right)` - Test whether two brownian path values are equivalent in Stochastic Calculus. +19. `stochasticCalculusGenerateExampleBrownianPath(size=3)` - Generate a small documented example of a brownian path. +20. `stochasticCalculusDocumentBrownianPath(value)` - Return a structured explanation of a brownian path and related assumptions. +21. `stochasticCalculusValidateStochasticIntegral(value)` - Validate the stochastic integral representation and domain rules for Stochastic Calculus. +22. `stochasticCalculusConstructStochasticIntegral(*args)` - Construct a stochastic integral from explicit inputs for Stochastic Calculus. +23. `stochasticCalculusNormalizeStochasticIntegral(value)` - Normalize a stochastic integral into the standard Stochastic Calculus representation. +24. `stochasticCalculusCanonicalizeStochasticIntegral(value)` - Canonicalize a stochastic integral so equivalent inputs share one form. +25. `stochasticCalculusParseStochasticIntegral(text)` - Parse a text or structured value into a stochastic integral. +26. `stochasticCalculusFormatStochasticIntegral(value)` - Format a stochastic integral for deterministic user-facing output. +27. `stochasticCalculusCompareStochasticIntegral(left, right)` - Compare two stochastic integral values under the conventions of Stochastic Calculus. +28. `stochasticCalculusCombineStochasticIntegral(left, right)` - Combine two stochastic integral values with the natural operation for Stochastic Calculus. +29. `stochasticCalculusDecomposeStochasticIntegral(value)` - Decompose a stochastic integral into simpler or canonical components. +30. `stochasticCalculusEvaluateStochasticIntegral(value, point=None)` - Evaluate a stochastic integral at a point, sample, or finite model. +31. `stochasticCalculusComputeStochasticIntegral(value)` - Compute the central numerical or symbolic data of a stochastic integral. +32. `stochasticCalculusEstimateStochasticIntegral(value, samples=None)` - Estimate a stochastic integral property from finite samples or approximations. +33. `stochasticCalculusApproximateStochasticIntegral(value, tolerance=1e-9)` - Approximate a stochastic integral with explicit tolerance controls. +34. `stochasticCalculusTransformStochasticIntegral(value, mapping)` - Transform a stochastic integral through a map, operator, or representation change. +35. `stochasticCalculusSimplifyStochasticIntegral(value)` - Simplify a stochastic integral without changing its mathematical meaning. +36. `stochasticCalculusEnumerateStochasticIntegral(value, limit=None)` - Enumerate finite members, cases, or derived objects for a stochastic integral. +37. `stochasticCalculusClassifyStochasticIntegral(value)` - Classify a stochastic integral by its standard Stochastic Calculus invariants. +38. `stochasticCalculusTestEquivalenceStochasticIntegral(left, right)` - Test whether two stochastic integral values are equivalent in Stochastic Calculus. +39. `stochasticCalculusGenerateExampleStochasticIntegral(size=3)` - Generate a small documented example of a stochastic integral. +40. `stochasticCalculusDocumentStochasticIntegral(value)` - Return a structured explanation of a stochastic integral and related assumptions. +41. `stochasticCalculusValidateSdeModel(value)` - Validate the sde model representation and domain rules for Stochastic Calculus. +42. `stochasticCalculusConstructSdeModel(*args)` - Construct a sde model from explicit inputs for Stochastic Calculus. +43. `stochasticCalculusNormalizeSdeModel(value)` - Normalize a sde model into the standard Stochastic Calculus representation. +44. `stochasticCalculusCanonicalizeSdeModel(value)` - Canonicalize a sde model so equivalent inputs share one form. +45. `stochasticCalculusParseSdeModel(text)` - Parse a text or structured value into a sde model. +46. `stochasticCalculusFormatSdeModel(value)` - Format a sde model for deterministic user-facing output. +47. `stochasticCalculusCompareSdeModel(left, right)` - Compare two sde model values under the conventions of Stochastic Calculus. +48. `stochasticCalculusCombineSdeModel(left, right)` - Combine two sde model values with the natural operation for Stochastic Calculus. +49. `stochasticCalculusDecomposeSdeModel(value)` - Decompose a sde model into simpler or canonical components. +50. `stochasticCalculusEvaluateSdeModel(value, point=None)` - Evaluate a sde model at a point, sample, or finite model. +51. `stochasticCalculusComputeSdeModel(value)` - Compute the central numerical or symbolic data of a sde model. +52. `stochasticCalculusEstimateSdeModel(value, samples=None)` - Estimate a sde model property from finite samples or approximations. +53. `stochasticCalculusApproximateSdeModel(value, tolerance=1e-9)` - Approximate a sde model with explicit tolerance controls. +54. `stochasticCalculusTransformSdeModel(value, mapping)` - Transform a sde model through a map, operator, or representation change. +55. `stochasticCalculusSimplifySdeModel(value)` - Simplify a sde model without changing its mathematical meaning. +56. `stochasticCalculusEnumerateSdeModel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a sde model. +57. `stochasticCalculusClassifySdeModel(value)` - Classify a sde model by its standard Stochastic Calculus invariants. +58. `stochasticCalculusTestEquivalenceSdeModel(left, right)` - Test whether two sde model values are equivalent in Stochastic Calculus. +59. `stochasticCalculusGenerateExampleSdeModel(size=3)` - Generate a small documented example of a sde model. +60. `stochasticCalculusDocumentSdeModel(value)` - Return a structured explanation of a sde model and related assumptions. +61. `stochasticCalculusValidateQuadraticVariation(value)` - Validate the quadratic variation representation and domain rules for Stochastic Calculus. +62. `stochasticCalculusConstructQuadraticVariation(*args)` - Construct a quadratic variation from explicit inputs for Stochastic Calculus. +63. `stochasticCalculusNormalizeQuadraticVariation(value)` - Normalize a quadratic variation into the standard Stochastic Calculus representation. +64. `stochasticCalculusCanonicalizeQuadraticVariation(value)` - Canonicalize a quadratic variation so equivalent inputs share one form. +65. `stochasticCalculusParseQuadraticVariation(text)` - Parse a text or structured value into a quadratic variation. +66. `stochasticCalculusFormatQuadraticVariation(value)` - Format a quadratic variation for deterministic user-facing output. +67. `stochasticCalculusCompareQuadraticVariation(left, right)` - Compare two quadratic variation values under the conventions of Stochastic Calculus. +68. `stochasticCalculusCombineQuadraticVariation(left, right)` - Combine two quadratic variation values with the natural operation for Stochastic Calculus. +69. `stochasticCalculusDecomposeQuadraticVariation(value)` - Decompose a quadratic variation into simpler or canonical components. +70. `stochasticCalculusEvaluateQuadraticVariation(value, point=None)` - Evaluate a quadratic variation at a point, sample, or finite model. +71. `stochasticCalculusComputeQuadraticVariation(value)` - Compute the central numerical or symbolic data of a quadratic variation. +72. `stochasticCalculusEstimateQuadraticVariation(value, samples=None)` - Estimate a quadratic variation property from finite samples or approximations. +73. `stochasticCalculusApproximateQuadraticVariation(value, tolerance=1e-9)` - Approximate a quadratic variation with explicit tolerance controls. +74. `stochasticCalculusTransformQuadraticVariation(value, mapping)` - Transform a quadratic variation through a map, operator, or representation change. +75. `stochasticCalculusSimplifyQuadraticVariation(value)` - Simplify a quadratic variation without changing its mathematical meaning. +76. `stochasticCalculusEnumerateQuadraticVariation(value, limit=None)` - Enumerate finite members, cases, or derived objects for a quadratic variation. +77. `stochasticCalculusClassifyQuadraticVariation(value)` - Classify a quadratic variation by its standard Stochastic Calculus invariants. +78. `stochasticCalculusTestEquivalenceQuadraticVariation(left, right)` - Test whether two quadratic variation values are equivalent in Stochastic Calculus. +79. `stochasticCalculusGenerateExampleQuadraticVariation(size=3)` - Generate a small documented example of a quadratic variation. +80. `stochasticCalculusDocumentQuadraticVariation(value)` - Return a structured explanation of a quadratic variation and related assumptions. +81. `stochasticCalculusValidateDiffusionProcess(value)` - Validate the diffusion process representation and domain rules for Stochastic Calculus. +82. `stochasticCalculusConstructDiffusionProcess(*args)` - Construct a diffusion process from explicit inputs for Stochastic Calculus. +83. `stochasticCalculusNormalizeDiffusionProcess(value)` - Normalize a diffusion process into the standard Stochastic Calculus representation. +84. `stochasticCalculusCanonicalizeDiffusionProcess(value)` - Canonicalize a diffusion process so equivalent inputs share one form. +85. `stochasticCalculusParseDiffusionProcess(text)` - Parse a text or structured value into a diffusion process. +86. `stochasticCalculusFormatDiffusionProcess(value)` - Format a diffusion process for deterministic user-facing output. +87. `stochasticCalculusCompareDiffusionProcess(left, right)` - Compare two diffusion process values under the conventions of Stochastic Calculus. +88. `stochasticCalculusCombineDiffusionProcess(left, right)` - Combine two diffusion process values with the natural operation for Stochastic Calculus. +89. `stochasticCalculusDecomposeDiffusionProcess(value)` - Decompose a diffusion process into simpler or canonical components. +90. `stochasticCalculusEvaluateDiffusionProcess(value, point=None)` - Evaluate a diffusion process at a point, sample, or finite model. +91. `stochasticCalculusComputeDiffusionProcess(value)` - Compute the central numerical or symbolic data of a diffusion process. +92. `stochasticCalculusEstimateDiffusionProcess(value, samples=None)` - Estimate a diffusion process property from finite samples or approximations. +93. `stochasticCalculusApproximateDiffusionProcess(value, tolerance=1e-9)` - Approximate a diffusion process with explicit tolerance controls. +94. `stochasticCalculusTransformDiffusionProcess(value, mapping)` - Transform a diffusion process through a map, operator, or representation change. +95. `stochasticCalculusSimplifyDiffusionProcess(value)` - Simplify a diffusion process without changing its mathematical meaning. +96. `stochasticCalculusEnumerateDiffusionProcess(value, limit=None)` - Enumerate finite members, cases, or derived objects for a diffusion process. +97. `stochasticCalculusClassifyDiffusionProcess(value)` - Classify a diffusion process by its standard Stochastic Calculus invariants. +98. `stochasticCalculusTestEquivalenceDiffusionProcess(left, right)` - Test whether two diffusion process values are equivalent in Stochastic Calculus. +99. `stochasticCalculusGenerateExampleDiffusionProcess(size=3)` - Generate a small documented example of a diffusion process. +100. `stochasticCalculusDocumentDiffusionProcess(value)` - Return a structured explanation of a diffusion process and related assumptions. + +### Time Series Analysis + +Core object families: + +- time series +- lag structure +- trend model +- seasonal profile +- forecast model + +Candidate functions: + +1. `timeSeriesAnalysisValidateTimeSeries(value)` - Validate the time series representation and domain rules for Time Series Analysis. +2. `timeSeriesAnalysisConstructTimeSeries(*args)` - Construct a time series from explicit inputs for Time Series Analysis. +3. `timeSeriesAnalysisNormalizeTimeSeries(value)` - Normalize a time series into the standard Time Series Analysis representation. +4. `timeSeriesAnalysisCanonicalizeTimeSeries(value)` - Canonicalize a time series so equivalent inputs share one form. +5. `timeSeriesAnalysisParseTimeSeries(text)` - Parse a text or structured value into a time series. +6. `timeSeriesAnalysisFormatTimeSeries(value)` - Format a time series for deterministic user-facing output. +7. `timeSeriesAnalysisCompareTimeSeries(left, right)` - Compare two time series values under the conventions of Time Series Analysis. +8. `timeSeriesAnalysisCombineTimeSeries(left, right)` - Combine two time series values with the natural operation for Time Series Analysis. +9. `timeSeriesAnalysisDecomposeTimeSeries(value)` - Decompose a time series into simpler or canonical components. +10. `timeSeriesAnalysisEvaluateTimeSeries(value, point=None)` - Evaluate a time series at a point, sample, or finite model. +11. `timeSeriesAnalysisComputeTimeSeries(value)` - Compute the central numerical or symbolic data of a time series. +12. `timeSeriesAnalysisEstimateTimeSeries(value, samples=None)` - Estimate a time series property from finite samples or approximations. +13. `timeSeriesAnalysisApproximateTimeSeries(value, tolerance=1e-9)` - Approximate a time series with explicit tolerance controls. +14. `timeSeriesAnalysisTransformTimeSeries(value, mapping)` - Transform a time series through a map, operator, or representation change. +15. `timeSeriesAnalysisSimplifyTimeSeries(value)` - Simplify a time series without changing its mathematical meaning. +16. `timeSeriesAnalysisEnumerateTimeSeries(value, limit=None)` - Enumerate finite members, cases, or derived objects for a time series. +17. `timeSeriesAnalysisClassifyTimeSeries(value)` - Classify a time series by its standard Time Series Analysis invariants. +18. `timeSeriesAnalysisTestEquivalenceTimeSeries(left, right)` - Test whether two time series values are equivalent in Time Series Analysis. +19. `timeSeriesAnalysisGenerateExampleTimeSeries(size=3)` - Generate a small documented example of a time series. +20. `timeSeriesAnalysisDocumentTimeSeries(value)` - Return a structured explanation of a time series and related assumptions. +21. `timeSeriesAnalysisValidateLagStructure(value)` - Validate the lag structure representation and domain rules for Time Series Analysis. +22. `timeSeriesAnalysisConstructLagStructure(*args)` - Construct a lag structure from explicit inputs for Time Series Analysis. +23. `timeSeriesAnalysisNormalizeLagStructure(value)` - Normalize a lag structure into the standard Time Series Analysis representation. +24. `timeSeriesAnalysisCanonicalizeLagStructure(value)` - Canonicalize a lag structure so equivalent inputs share one form. +25. `timeSeriesAnalysisParseLagStructure(text)` - Parse a text or structured value into a lag structure. +26. `timeSeriesAnalysisFormatLagStructure(value)` - Format a lag structure for deterministic user-facing output. +27. `timeSeriesAnalysisCompareLagStructure(left, right)` - Compare two lag structure values under the conventions of Time Series Analysis. +28. `timeSeriesAnalysisCombineLagStructure(left, right)` - Combine two lag structure values with the natural operation for Time Series Analysis. +29. `timeSeriesAnalysisDecomposeLagStructure(value)` - Decompose a lag structure into simpler or canonical components. +30. `timeSeriesAnalysisEvaluateLagStructure(value, point=None)` - Evaluate a lag structure at a point, sample, or finite model. +31. `timeSeriesAnalysisComputeLagStructure(value)` - Compute the central numerical or symbolic data of a lag structure. +32. `timeSeriesAnalysisEstimateLagStructure(value, samples=None)` - Estimate a lag structure property from finite samples or approximations. +33. `timeSeriesAnalysisApproximateLagStructure(value, tolerance=1e-9)` - Approximate a lag structure with explicit tolerance controls. +34. `timeSeriesAnalysisTransformLagStructure(value, mapping)` - Transform a lag structure through a map, operator, or representation change. +35. `timeSeriesAnalysisSimplifyLagStructure(value)` - Simplify a lag structure without changing its mathematical meaning. +36. `timeSeriesAnalysisEnumerateLagStructure(value, limit=None)` - Enumerate finite members, cases, or derived objects for a lag structure. +37. `timeSeriesAnalysisClassifyLagStructure(value)` - Classify a lag structure by its standard Time Series Analysis invariants. +38. `timeSeriesAnalysisTestEquivalenceLagStructure(left, right)` - Test whether two lag structure values are equivalent in Time Series Analysis. +39. `timeSeriesAnalysisGenerateExampleLagStructure(size=3)` - Generate a small documented example of a lag structure. +40. `timeSeriesAnalysisDocumentLagStructure(value)` - Return a structured explanation of a lag structure and related assumptions. +41. `timeSeriesAnalysisValidateTrendModel(value)` - Validate the trend model representation and domain rules for Time Series Analysis. +42. `timeSeriesAnalysisConstructTrendModel(*args)` - Construct a trend model from explicit inputs for Time Series Analysis. +43. `timeSeriesAnalysisNormalizeTrendModel(value)` - Normalize a trend model into the standard Time Series Analysis representation. +44. `timeSeriesAnalysisCanonicalizeTrendModel(value)` - Canonicalize a trend model so equivalent inputs share one form. +45. `timeSeriesAnalysisParseTrendModel(text)` - Parse a text or structured value into a trend model. +46. `timeSeriesAnalysisFormatTrendModel(value)` - Format a trend model for deterministic user-facing output. +47. `timeSeriesAnalysisCompareTrendModel(left, right)` - Compare two trend model values under the conventions of Time Series Analysis. +48. `timeSeriesAnalysisCombineTrendModel(left, right)` - Combine two trend model values with the natural operation for Time Series Analysis. +49. `timeSeriesAnalysisDecomposeTrendModel(value)` - Decompose a trend model into simpler or canonical components. +50. `timeSeriesAnalysisEvaluateTrendModel(value, point=None)` - Evaluate a trend model at a point, sample, or finite model. +51. `timeSeriesAnalysisComputeTrendModel(value)` - Compute the central numerical or symbolic data of a trend model. +52. `timeSeriesAnalysisEstimateTrendModel(value, samples=None)` - Estimate a trend model property from finite samples or approximations. +53. `timeSeriesAnalysisApproximateTrendModel(value, tolerance=1e-9)` - Approximate a trend model with explicit tolerance controls. +54. `timeSeriesAnalysisTransformTrendModel(value, mapping)` - Transform a trend model through a map, operator, or representation change. +55. `timeSeriesAnalysisSimplifyTrendModel(value)` - Simplify a trend model without changing its mathematical meaning. +56. `timeSeriesAnalysisEnumerateTrendModel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a trend model. +57. `timeSeriesAnalysisClassifyTrendModel(value)` - Classify a trend model by its standard Time Series Analysis invariants. +58. `timeSeriesAnalysisTestEquivalenceTrendModel(left, right)` - Test whether two trend model values are equivalent in Time Series Analysis. +59. `timeSeriesAnalysisGenerateExampleTrendModel(size=3)` - Generate a small documented example of a trend model. +60. `timeSeriesAnalysisDocumentTrendModel(value)` - Return a structured explanation of a trend model and related assumptions. +61. `timeSeriesAnalysisValidateSeasonalProfile(value)` - Validate the seasonal profile representation and domain rules for Time Series Analysis. +62. `timeSeriesAnalysisConstructSeasonalProfile(*args)` - Construct a seasonal profile from explicit inputs for Time Series Analysis. +63. `timeSeriesAnalysisNormalizeSeasonalProfile(value)` - Normalize a seasonal profile into the standard Time Series Analysis representation. +64. `timeSeriesAnalysisCanonicalizeSeasonalProfile(value)` - Canonicalize a seasonal profile so equivalent inputs share one form. +65. `timeSeriesAnalysisParseSeasonalProfile(text)` - Parse a text or structured value into a seasonal profile. +66. `timeSeriesAnalysisFormatSeasonalProfile(value)` - Format a seasonal profile for deterministic user-facing output. +67. `timeSeriesAnalysisCompareSeasonalProfile(left, right)` - Compare two seasonal profile values under the conventions of Time Series Analysis. +68. `timeSeriesAnalysisCombineSeasonalProfile(left, right)` - Combine two seasonal profile values with the natural operation for Time Series Analysis. +69. `timeSeriesAnalysisDecomposeSeasonalProfile(value)` - Decompose a seasonal profile into simpler or canonical components. +70. `timeSeriesAnalysisEvaluateSeasonalProfile(value, point=None)` - Evaluate a seasonal profile at a point, sample, or finite model. +71. `timeSeriesAnalysisComputeSeasonalProfile(value)` - Compute the central numerical or symbolic data of a seasonal profile. +72. `timeSeriesAnalysisEstimateSeasonalProfile(value, samples=None)` - Estimate a seasonal profile property from finite samples or approximations. +73. `timeSeriesAnalysisApproximateSeasonalProfile(value, tolerance=1e-9)` - Approximate a seasonal profile with explicit tolerance controls. +74. `timeSeriesAnalysisTransformSeasonalProfile(value, mapping)` - Transform a seasonal profile through a map, operator, or representation change. +75. `timeSeriesAnalysisSimplifySeasonalProfile(value)` - Simplify a seasonal profile without changing its mathematical meaning. +76. `timeSeriesAnalysisEnumerateSeasonalProfile(value, limit=None)` - Enumerate finite members, cases, or derived objects for a seasonal profile. +77. `timeSeriesAnalysisClassifySeasonalProfile(value)` - Classify a seasonal profile by its standard Time Series Analysis invariants. +78. `timeSeriesAnalysisTestEquivalenceSeasonalProfile(left, right)` - Test whether two seasonal profile values are equivalent in Time Series Analysis. +79. `timeSeriesAnalysisGenerateExampleSeasonalProfile(size=3)` - Generate a small documented example of a seasonal profile. +80. `timeSeriesAnalysisDocumentSeasonalProfile(value)` - Return a structured explanation of a seasonal profile and related assumptions. +81. `timeSeriesAnalysisValidateForecastModel(value)` - Validate the forecast model representation and domain rules for Time Series Analysis. +82. `timeSeriesAnalysisConstructForecastModel(*args)` - Construct a forecast model from explicit inputs for Time Series Analysis. +83. `timeSeriesAnalysisNormalizeForecastModel(value)` - Normalize a forecast model into the standard Time Series Analysis representation. +84. `timeSeriesAnalysisCanonicalizeForecastModel(value)` - Canonicalize a forecast model so equivalent inputs share one form. +85. `timeSeriesAnalysisParseForecastModel(text)` - Parse a text or structured value into a forecast model. +86. `timeSeriesAnalysisFormatForecastModel(value)` - Format a forecast model for deterministic user-facing output. +87. `timeSeriesAnalysisCompareForecastModel(left, right)` - Compare two forecast model values under the conventions of Time Series Analysis. +88. `timeSeriesAnalysisCombineForecastModel(left, right)` - Combine two forecast model values with the natural operation for Time Series Analysis. +89. `timeSeriesAnalysisDecomposeForecastModel(value)` - Decompose a forecast model into simpler or canonical components. +90. `timeSeriesAnalysisEvaluateForecastModel(value, point=None)` - Evaluate a forecast model at a point, sample, or finite model. +91. `timeSeriesAnalysisComputeForecastModel(value)` - Compute the central numerical or symbolic data of a forecast model. +92. `timeSeriesAnalysisEstimateForecastModel(value, samples=None)` - Estimate a forecast model property from finite samples or approximations. +93. `timeSeriesAnalysisApproximateForecastModel(value, tolerance=1e-9)` - Approximate a forecast model with explicit tolerance controls. +94. `timeSeriesAnalysisTransformForecastModel(value, mapping)` - Transform a forecast model through a map, operator, or representation change. +95. `timeSeriesAnalysisSimplifyForecastModel(value)` - Simplify a forecast model without changing its mathematical meaning. +96. `timeSeriesAnalysisEnumerateForecastModel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a forecast model. +97. `timeSeriesAnalysisClassifyForecastModel(value)` - Classify a forecast model by its standard Time Series Analysis invariants. +98. `timeSeriesAnalysisTestEquivalenceForecastModel(left, right)` - Test whether two forecast model values are equivalent in Time Series Analysis. +99. `timeSeriesAnalysisGenerateExampleForecastModel(size=3)` - Generate a small documented example of a forecast model. +100. `timeSeriesAnalysisDocumentForecastModel(value)` - Return a structured explanation of a forecast model and related assumptions. + +### Bayesian Statistics + +Core object families: + +- prior +- likelihood +- posterior +- conjugate model +- credible set + +Candidate functions: + +1. `bayesianStatisticsValidatePrior(value)` - Validate the prior representation and domain rules for Bayesian Statistics. +2. `bayesianStatisticsConstructPrior(*args)` - Construct a prior from explicit inputs for Bayesian Statistics. +3. `bayesianStatisticsNormalizePrior(value)` - Normalize a prior into the standard Bayesian Statistics representation. +4. `bayesianStatisticsCanonicalizePrior(value)` - Canonicalize a prior so equivalent inputs share one form. +5. `bayesianStatisticsParsePrior(text)` - Parse a text or structured value into a prior. +6. `bayesianStatisticsFormatPrior(value)` - Format a prior for deterministic user-facing output. +7. `bayesianStatisticsComparePrior(left, right)` - Compare two prior values under the conventions of Bayesian Statistics. +8. `bayesianStatisticsCombinePrior(left, right)` - Combine two prior values with the natural operation for Bayesian Statistics. +9. `bayesianStatisticsDecomposePrior(value)` - Decompose a prior into simpler or canonical components. +10. `bayesianStatisticsEvaluatePrior(value, point=None)` - Evaluate a prior at a point, sample, or finite model. +11. `bayesianStatisticsComputePrior(value)` - Compute the central numerical or symbolic data of a prior. +12. `bayesianStatisticsEstimatePrior(value, samples=None)` - Estimate a prior property from finite samples or approximations. +13. `bayesianStatisticsApproximatePrior(value, tolerance=1e-9)` - Approximate a prior with explicit tolerance controls. +14. `bayesianStatisticsTransformPrior(value, mapping)` - Transform a prior through a map, operator, or representation change. +15. `bayesianStatisticsSimplifyPrior(value)` - Simplify a prior without changing its mathematical meaning. +16. `bayesianStatisticsEnumeratePrior(value, limit=None)` - Enumerate finite members, cases, or derived objects for a prior. +17. `bayesianStatisticsClassifyPrior(value)` - Classify a prior by its standard Bayesian Statistics invariants. +18. `bayesianStatisticsTestEquivalencePrior(left, right)` - Test whether two prior values are equivalent in Bayesian Statistics. +19. `bayesianStatisticsGenerateExamplePrior(size=3)` - Generate a small documented example of a prior. +20. `bayesianStatisticsDocumentPrior(value)` - Return a structured explanation of a prior and related assumptions. +21. `bayesianStatisticsValidateLikelihood(value)` - Validate the likelihood representation and domain rules for Bayesian Statistics. +22. `bayesianStatisticsConstructLikelihood(*args)` - Construct a likelihood from explicit inputs for Bayesian Statistics. +23. `bayesianStatisticsNormalizeLikelihood(value)` - Normalize a likelihood into the standard Bayesian Statistics representation. +24. `bayesianStatisticsCanonicalizeLikelihood(value)` - Canonicalize a likelihood so equivalent inputs share one form. +25. `bayesianStatisticsParseLikelihood(text)` - Parse a text or structured value into a likelihood. +26. `bayesianStatisticsFormatLikelihood(value)` - Format a likelihood for deterministic user-facing output. +27. `bayesianStatisticsCompareLikelihood(left, right)` - Compare two likelihood values under the conventions of Bayesian Statistics. +28. `bayesianStatisticsCombineLikelihood(left, right)` - Combine two likelihood values with the natural operation for Bayesian Statistics. +29. `bayesianStatisticsDecomposeLikelihood(value)` - Decompose a likelihood into simpler or canonical components. +30. `bayesianStatisticsEvaluateLikelihood(value, point=None)` - Evaluate a likelihood at a point, sample, or finite model. +31. `bayesianStatisticsComputeLikelihood(value)` - Compute the central numerical or symbolic data of a likelihood. +32. `bayesianStatisticsEstimateLikelihood(value, samples=None)` - Estimate a likelihood property from finite samples or approximations. +33. `bayesianStatisticsApproximateLikelihood(value, tolerance=1e-9)` - Approximate a likelihood with explicit tolerance controls. +34. `bayesianStatisticsTransformLikelihood(value, mapping)` - Transform a likelihood through a map, operator, or representation change. +35. `bayesianStatisticsSimplifyLikelihood(value)` - Simplify a likelihood without changing its mathematical meaning. +36. `bayesianStatisticsEnumerateLikelihood(value, limit=None)` - Enumerate finite members, cases, or derived objects for a likelihood. +37. `bayesianStatisticsClassifyLikelihood(value)` - Classify a likelihood by its standard Bayesian Statistics invariants. +38. `bayesianStatisticsTestEquivalenceLikelihood(left, right)` - Test whether two likelihood values are equivalent in Bayesian Statistics. +39. `bayesianStatisticsGenerateExampleLikelihood(size=3)` - Generate a small documented example of a likelihood. +40. `bayesianStatisticsDocumentLikelihood(value)` - Return a structured explanation of a likelihood and related assumptions. +41. `bayesianStatisticsValidatePosterior(value)` - Validate the posterior representation and domain rules for Bayesian Statistics. +42. `bayesianStatisticsConstructPosterior(*args)` - Construct a posterior from explicit inputs for Bayesian Statistics. +43. `bayesianStatisticsNormalizePosterior(value)` - Normalize a posterior into the standard Bayesian Statistics representation. +44. `bayesianStatisticsCanonicalizePosterior(value)` - Canonicalize a posterior so equivalent inputs share one form. +45. `bayesianStatisticsParsePosterior(text)` - Parse a text or structured value into a posterior. +46. `bayesianStatisticsFormatPosterior(value)` - Format a posterior for deterministic user-facing output. +47. `bayesianStatisticsComparePosterior(left, right)` - Compare two posterior values under the conventions of Bayesian Statistics. +48. `bayesianStatisticsCombinePosterior(left, right)` - Combine two posterior values with the natural operation for Bayesian Statistics. +49. `bayesianStatisticsDecomposePosterior(value)` - Decompose a posterior into simpler or canonical components. +50. `bayesianStatisticsEvaluatePosterior(value, point=None)` - Evaluate a posterior at a point, sample, or finite model. +51. `bayesianStatisticsComputePosterior(value)` - Compute the central numerical or symbolic data of a posterior. +52. `bayesianStatisticsEstimatePosterior(value, samples=None)` - Estimate a posterior property from finite samples or approximations. +53. `bayesianStatisticsApproximatePosterior(value, tolerance=1e-9)` - Approximate a posterior with explicit tolerance controls. +54. `bayesianStatisticsTransformPosterior(value, mapping)` - Transform a posterior through a map, operator, or representation change. +55. `bayesianStatisticsSimplifyPosterior(value)` - Simplify a posterior without changing its mathematical meaning. +56. `bayesianStatisticsEnumeratePosterior(value, limit=None)` - Enumerate finite members, cases, or derived objects for a posterior. +57. `bayesianStatisticsClassifyPosterior(value)` - Classify a posterior by its standard Bayesian Statistics invariants. +58. `bayesianStatisticsTestEquivalencePosterior(left, right)` - Test whether two posterior values are equivalent in Bayesian Statistics. +59. `bayesianStatisticsGenerateExamplePosterior(size=3)` - Generate a small documented example of a posterior. +60. `bayesianStatisticsDocumentPosterior(value)` - Return a structured explanation of a posterior and related assumptions. +61. `bayesianStatisticsValidateConjugateModel(value)` - Validate the conjugate model representation and domain rules for Bayesian Statistics. +62. `bayesianStatisticsConstructConjugateModel(*args)` - Construct a conjugate model from explicit inputs for Bayesian Statistics. +63. `bayesianStatisticsNormalizeConjugateModel(value)` - Normalize a conjugate model into the standard Bayesian Statistics representation. +64. `bayesianStatisticsCanonicalizeConjugateModel(value)` - Canonicalize a conjugate model so equivalent inputs share one form. +65. `bayesianStatisticsParseConjugateModel(text)` - Parse a text or structured value into a conjugate model. +66. `bayesianStatisticsFormatConjugateModel(value)` - Format a conjugate model for deterministic user-facing output. +67. `bayesianStatisticsCompareConjugateModel(left, right)` - Compare two conjugate model values under the conventions of Bayesian Statistics. +68. `bayesianStatisticsCombineConjugateModel(left, right)` - Combine two conjugate model values with the natural operation for Bayesian Statistics. +69. `bayesianStatisticsDecomposeConjugateModel(value)` - Decompose a conjugate model into simpler or canonical components. +70. `bayesianStatisticsEvaluateConjugateModel(value, point=None)` - Evaluate a conjugate model at a point, sample, or finite model. +71. `bayesianStatisticsComputeConjugateModel(value)` - Compute the central numerical or symbolic data of a conjugate model. +72. `bayesianStatisticsEstimateConjugateModel(value, samples=None)` - Estimate a conjugate model property from finite samples or approximations. +73. `bayesianStatisticsApproximateConjugateModel(value, tolerance=1e-9)` - Approximate a conjugate model with explicit tolerance controls. +74. `bayesianStatisticsTransformConjugateModel(value, mapping)` - Transform a conjugate model through a map, operator, or representation change. +75. `bayesianStatisticsSimplifyConjugateModel(value)` - Simplify a conjugate model without changing its mathematical meaning. +76. `bayesianStatisticsEnumerateConjugateModel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a conjugate model. +77. `bayesianStatisticsClassifyConjugateModel(value)` - Classify a conjugate model by its standard Bayesian Statistics invariants. +78. `bayesianStatisticsTestEquivalenceConjugateModel(left, right)` - Test whether two conjugate model values are equivalent in Bayesian Statistics. +79. `bayesianStatisticsGenerateExampleConjugateModel(size=3)` - Generate a small documented example of a conjugate model. +80. `bayesianStatisticsDocumentConjugateModel(value)` - Return a structured explanation of a conjugate model and related assumptions. +81. `bayesianStatisticsValidateCredibleSet(value)` - Validate the credible set representation and domain rules for Bayesian Statistics. +82. `bayesianStatisticsConstructCredibleSet(*args)` - Construct a credible set from explicit inputs for Bayesian Statistics. +83. `bayesianStatisticsNormalizeCredibleSet(value)` - Normalize a credible set into the standard Bayesian Statistics representation. +84. `bayesianStatisticsCanonicalizeCredibleSet(value)` - Canonicalize a credible set so equivalent inputs share one form. +85. `bayesianStatisticsParseCredibleSet(text)` - Parse a text or structured value into a credible set. +86. `bayesianStatisticsFormatCredibleSet(value)` - Format a credible set for deterministic user-facing output. +87. `bayesianStatisticsCompareCredibleSet(left, right)` - Compare two credible set values under the conventions of Bayesian Statistics. +88. `bayesianStatisticsCombineCredibleSet(left, right)` - Combine two credible set values with the natural operation for Bayesian Statistics. +89. `bayesianStatisticsDecomposeCredibleSet(value)` - Decompose a credible set into simpler or canonical components. +90. `bayesianStatisticsEvaluateCredibleSet(value, point=None)` - Evaluate a credible set at a point, sample, or finite model. +91. `bayesianStatisticsComputeCredibleSet(value)` - Compute the central numerical or symbolic data of a credible set. +92. `bayesianStatisticsEstimateCredibleSet(value, samples=None)` - Estimate a credible set property from finite samples or approximations. +93. `bayesianStatisticsApproximateCredibleSet(value, tolerance=1e-9)` - Approximate a credible set with explicit tolerance controls. +94. `bayesianStatisticsTransformCredibleSet(value, mapping)` - Transform a credible set through a map, operator, or representation change. +95. `bayesianStatisticsSimplifyCredibleSet(value)` - Simplify a credible set without changing its mathematical meaning. +96. `bayesianStatisticsEnumerateCredibleSet(value, limit=None)` - Enumerate finite members, cases, or derived objects for a credible set. +97. `bayesianStatisticsClassifyCredibleSet(value)` - Classify a credible set by its standard Bayesian Statistics invariants. +98. `bayesianStatisticsTestEquivalenceCredibleSet(left, right)` - Test whether two credible set values are equivalent in Bayesian Statistics. +99. `bayesianStatisticsGenerateExampleCredibleSet(size=3)` - Generate a small documented example of a credible set. +100. `bayesianStatisticsDocumentCredibleSet(value)` - Return a structured explanation of a credible set and related assumptions. + +### Statistical Inference + +Core object families: + +- estimator +- confidence interval +- test statistic +- hypothesis test +- sampling distribution + +Candidate functions: + +1. `statisticalInferenceValidateEstimator(value)` - Validate the estimator representation and domain rules for Statistical Inference. +2. `statisticalInferenceConstructEstimator(*args)` - Construct a estimator from explicit inputs for Statistical Inference. +3. `statisticalInferenceNormalizeEstimator(value)` - Normalize a estimator into the standard Statistical Inference representation. +4. `statisticalInferenceCanonicalizeEstimator(value)` - Canonicalize a estimator so equivalent inputs share one form. +5. `statisticalInferenceParseEstimator(text)` - Parse a text or structured value into a estimator. +6. `statisticalInferenceFormatEstimator(value)` - Format a estimator for deterministic user-facing output. +7. `statisticalInferenceCompareEstimator(left, right)` - Compare two estimator values under the conventions of Statistical Inference. +8. `statisticalInferenceCombineEstimator(left, right)` - Combine two estimator values with the natural operation for Statistical Inference. +9. `statisticalInferenceDecomposeEstimator(value)` - Decompose a estimator into simpler or canonical components. +10. `statisticalInferenceEvaluateEstimator(value, point=None)` - Evaluate a estimator at a point, sample, or finite model. +11. `statisticalInferenceComputeEstimator(value)` - Compute the central numerical or symbolic data of a estimator. +12. `statisticalInferenceEstimateEstimator(value, samples=None)` - Estimate a estimator property from finite samples or approximations. +13. `statisticalInferenceApproximateEstimator(value, tolerance=1e-9)` - Approximate a estimator with explicit tolerance controls. +14. `statisticalInferenceTransformEstimator(value, mapping)` - Transform a estimator through a map, operator, or representation change. +15. `statisticalInferenceSimplifyEstimator(value)` - Simplify a estimator without changing its mathematical meaning. +16. `statisticalInferenceEnumerateEstimator(value, limit=None)` - Enumerate finite members, cases, or derived objects for a estimator. +17. `statisticalInferenceClassifyEstimator(value)` - Classify a estimator by its standard Statistical Inference invariants. +18. `statisticalInferenceTestEquivalenceEstimator(left, right)` - Test whether two estimator values are equivalent in Statistical Inference. +19. `statisticalInferenceGenerateExampleEstimator(size=3)` - Generate a small documented example of a estimator. +20. `statisticalInferenceDocumentEstimator(value)` - Return a structured explanation of a estimator and related assumptions. +21. `statisticalInferenceValidateConfidenceInterval(value)` - Validate the confidence interval representation and domain rules for Statistical Inference. +22. `statisticalInferenceConstructConfidenceInterval(*args)` - Construct a confidence interval from explicit inputs for Statistical Inference. +23. `statisticalInferenceNormalizeConfidenceInterval(value)` - Normalize a confidence interval into the standard Statistical Inference representation. +24. `statisticalInferenceCanonicalizeConfidenceInterval(value)` - Canonicalize a confidence interval so equivalent inputs share one form. +25. `statisticalInferenceParseConfidenceInterval(text)` - Parse a text or structured value into a confidence interval. +26. `statisticalInferenceFormatConfidenceInterval(value)` - Format a confidence interval for deterministic user-facing output. +27. `statisticalInferenceCompareConfidenceInterval(left, right)` - Compare two confidence interval values under the conventions of Statistical Inference. +28. `statisticalInferenceCombineConfidenceInterval(left, right)` - Combine two confidence interval values with the natural operation for Statistical Inference. +29. `statisticalInferenceDecomposeConfidenceInterval(value)` - Decompose a confidence interval into simpler or canonical components. +30. `statisticalInferenceEvaluateConfidenceInterval(value, point=None)` - Evaluate a confidence interval at a point, sample, or finite model. +31. `statisticalInferenceComputeConfidenceInterval(value)` - Compute the central numerical or symbolic data of a confidence interval. +32. `statisticalInferenceEstimateConfidenceInterval(value, samples=None)` - Estimate a confidence interval property from finite samples or approximations. +33. `statisticalInferenceApproximateConfidenceInterval(value, tolerance=1e-9)` - Approximate a confidence interval with explicit tolerance controls. +34. `statisticalInferenceTransformConfidenceInterval(value, mapping)` - Transform a confidence interval through a map, operator, or representation change. +35. `statisticalInferenceSimplifyConfidenceInterval(value)` - Simplify a confidence interval without changing its mathematical meaning. +36. `statisticalInferenceEnumerateConfidenceInterval(value, limit=None)` - Enumerate finite members, cases, or derived objects for a confidence interval. +37. `statisticalInferenceClassifyConfidenceInterval(value)` - Classify a confidence interval by its standard Statistical Inference invariants. +38. `statisticalInferenceTestEquivalenceConfidenceInterval(left, right)` - Test whether two confidence interval values are equivalent in Statistical Inference. +39. `statisticalInferenceGenerateExampleConfidenceInterval(size=3)` - Generate a small documented example of a confidence interval. +40. `statisticalInferenceDocumentConfidenceInterval(value)` - Return a structured explanation of a confidence interval and related assumptions. +41. `statisticalInferenceValidateTestStatistic(value)` - Validate the test statistic representation and domain rules for Statistical Inference. +42. `statisticalInferenceConstructTestStatistic(*args)` - Construct a test statistic from explicit inputs for Statistical Inference. +43. `statisticalInferenceNormalizeTestStatistic(value)` - Normalize a test statistic into the standard Statistical Inference representation. +44. `statisticalInferenceCanonicalizeTestStatistic(value)` - Canonicalize a test statistic so equivalent inputs share one form. +45. `statisticalInferenceParseTestStatistic(text)` - Parse a text or structured value into a test statistic. +46. `statisticalInferenceFormatTestStatistic(value)` - Format a test statistic for deterministic user-facing output. +47. `statisticalInferenceCompareTestStatistic(left, right)` - Compare two test statistic values under the conventions of Statistical Inference. +48. `statisticalInferenceCombineTestStatistic(left, right)` - Combine two test statistic values with the natural operation for Statistical Inference. +49. `statisticalInferenceDecomposeTestStatistic(value)` - Decompose a test statistic into simpler or canonical components. +50. `statisticalInferenceEvaluateTestStatistic(value, point=None)` - Evaluate a test statistic at a point, sample, or finite model. +51. `statisticalInferenceComputeTestStatistic(value)` - Compute the central numerical or symbolic data of a test statistic. +52. `statisticalInferenceEstimateTestStatistic(value, samples=None)` - Estimate a test statistic property from finite samples or approximations. +53. `statisticalInferenceApproximateTestStatistic(value, tolerance=1e-9)` - Approximate a test statistic with explicit tolerance controls. +54. `statisticalInferenceTransformTestStatistic(value, mapping)` - Transform a test statistic through a map, operator, or representation change. +55. `statisticalInferenceSimplifyTestStatistic(value)` - Simplify a test statistic without changing its mathematical meaning. +56. `statisticalInferenceEnumerateTestStatistic(value, limit=None)` - Enumerate finite members, cases, or derived objects for a test statistic. +57. `statisticalInferenceClassifyTestStatistic(value)` - Classify a test statistic by its standard Statistical Inference invariants. +58. `statisticalInferenceTestEquivalenceTestStatistic(left, right)` - Test whether two test statistic values are equivalent in Statistical Inference. +59. `statisticalInferenceGenerateExampleTestStatistic(size=3)` - Generate a small documented example of a test statistic. +60. `statisticalInferenceDocumentTestStatistic(value)` - Return a structured explanation of a test statistic and related assumptions. +61. `statisticalInferenceValidateHypothesisTest(value)` - Validate the hypothesis test representation and domain rules for Statistical Inference. +62. `statisticalInferenceConstructHypothesisTest(*args)` - Construct a hypothesis test from explicit inputs for Statistical Inference. +63. `statisticalInferenceNormalizeHypothesisTest(value)` - Normalize a hypothesis test into the standard Statistical Inference representation. +64. `statisticalInferenceCanonicalizeHypothesisTest(value)` - Canonicalize a hypothesis test so equivalent inputs share one form. +65. `statisticalInferenceParseHypothesisTest(text)` - Parse a text or structured value into a hypothesis test. +66. `statisticalInferenceFormatHypothesisTest(value)` - Format a hypothesis test for deterministic user-facing output. +67. `statisticalInferenceCompareHypothesisTest(left, right)` - Compare two hypothesis test values under the conventions of Statistical Inference. +68. `statisticalInferenceCombineHypothesisTest(left, right)` - Combine two hypothesis test values with the natural operation for Statistical Inference. +69. `statisticalInferenceDecomposeHypothesisTest(value)` - Decompose a hypothesis test into simpler or canonical components. +70. `statisticalInferenceEvaluateHypothesisTest(value, point=None)` - Evaluate a hypothesis test at a point, sample, or finite model. +71. `statisticalInferenceComputeHypothesisTest(value)` - Compute the central numerical or symbolic data of a hypothesis test. +72. `statisticalInferenceEstimateHypothesisTest(value, samples=None)` - Estimate a hypothesis test property from finite samples or approximations. +73. `statisticalInferenceApproximateHypothesisTest(value, tolerance=1e-9)` - Approximate a hypothesis test with explicit tolerance controls. +74. `statisticalInferenceTransformHypothesisTest(value, mapping)` - Transform a hypothesis test through a map, operator, or representation change. +75. `statisticalInferenceSimplifyHypothesisTest(value)` - Simplify a hypothesis test without changing its mathematical meaning. +76. `statisticalInferenceEnumerateHypothesisTest(value, limit=None)` - Enumerate finite members, cases, or derived objects for a hypothesis test. +77. `statisticalInferenceClassifyHypothesisTest(value)` - Classify a hypothesis test by its standard Statistical Inference invariants. +78. `statisticalInferenceTestEquivalenceHypothesisTest(left, right)` - Test whether two hypothesis test values are equivalent in Statistical Inference. +79. `statisticalInferenceGenerateExampleHypothesisTest(size=3)` - Generate a small documented example of a hypothesis test. +80. `statisticalInferenceDocumentHypothesisTest(value)` - Return a structured explanation of a hypothesis test and related assumptions. +81. `statisticalInferenceValidateSamplingDistribution(value)` - Validate the sampling distribution representation and domain rules for Statistical Inference. +82. `statisticalInferenceConstructSamplingDistribution(*args)` - Construct a sampling distribution from explicit inputs for Statistical Inference. +83. `statisticalInferenceNormalizeSamplingDistribution(value)` - Normalize a sampling distribution into the standard Statistical Inference representation. +84. `statisticalInferenceCanonicalizeSamplingDistribution(value)` - Canonicalize a sampling distribution so equivalent inputs share one form. +85. `statisticalInferenceParseSamplingDistribution(text)` - Parse a text or structured value into a sampling distribution. +86. `statisticalInferenceFormatSamplingDistribution(value)` - Format a sampling distribution for deterministic user-facing output. +87. `statisticalInferenceCompareSamplingDistribution(left, right)` - Compare two sampling distribution values under the conventions of Statistical Inference. +88. `statisticalInferenceCombineSamplingDistribution(left, right)` - Combine two sampling distribution values with the natural operation for Statistical Inference. +89. `statisticalInferenceDecomposeSamplingDistribution(value)` - Decompose a sampling distribution into simpler or canonical components. +90. `statisticalInferenceEvaluateSamplingDistribution(value, point=None)` - Evaluate a sampling distribution at a point, sample, or finite model. +91. `statisticalInferenceComputeSamplingDistribution(value)` - Compute the central numerical or symbolic data of a sampling distribution. +92. `statisticalInferenceEstimateSamplingDistribution(value, samples=None)` - Estimate a sampling distribution property from finite samples or approximations. +93. `statisticalInferenceApproximateSamplingDistribution(value, tolerance=1e-9)` - Approximate a sampling distribution with explicit tolerance controls. +94. `statisticalInferenceTransformSamplingDistribution(value, mapping)` - Transform a sampling distribution through a map, operator, or representation change. +95. `statisticalInferenceSimplifySamplingDistribution(value)` - Simplify a sampling distribution without changing its mathematical meaning. +96. `statisticalInferenceEnumerateSamplingDistribution(value, limit=None)` - Enumerate finite members, cases, or derived objects for a sampling distribution. +97. `statisticalInferenceClassifySamplingDistribution(value)` - Classify a sampling distribution by its standard Statistical Inference invariants. +98. `statisticalInferenceTestEquivalenceSamplingDistribution(left, right)` - Test whether two sampling distribution values are equivalent in Statistical Inference. +99. `statisticalInferenceGenerateExampleSamplingDistribution(size=3)` - Generate a small documented example of a sampling distribution. +100. `statisticalInferenceDocumentSamplingDistribution(value)` - Return a structured explanation of a sampling distribution and related assumptions. + +### Experimental Design + +Core object families: + +- treatment plan +- block design +- factorial design +- assignment rule +- anova table + +Candidate functions: + +1. `experimentalDesignValidateTreatmentPlan(value)` - Validate the treatment plan representation and domain rules for Experimental Design. +2. `experimentalDesignConstructTreatmentPlan(*args)` - Construct a treatment plan from explicit inputs for Experimental Design. +3. `experimentalDesignNormalizeTreatmentPlan(value)` - Normalize a treatment plan into the standard Experimental Design representation. +4. `experimentalDesignCanonicalizeTreatmentPlan(value)` - Canonicalize a treatment plan so equivalent inputs share one form. +5. `experimentalDesignParseTreatmentPlan(text)` - Parse a text or structured value into a treatment plan. +6. `experimentalDesignFormatTreatmentPlan(value)` - Format a treatment plan for deterministic user-facing output. +7. `experimentalDesignCompareTreatmentPlan(left, right)` - Compare two treatment plan values under the conventions of Experimental Design. +8. `experimentalDesignCombineTreatmentPlan(left, right)` - Combine two treatment plan values with the natural operation for Experimental Design. +9. `experimentalDesignDecomposeTreatmentPlan(value)` - Decompose a treatment plan into simpler or canonical components. +10. `experimentalDesignEvaluateTreatmentPlan(value, point=None)` - Evaluate a treatment plan at a point, sample, or finite model. +11. `experimentalDesignComputeTreatmentPlan(value)` - Compute the central numerical or symbolic data of a treatment plan. +12. `experimentalDesignEstimateTreatmentPlan(value, samples=None)` - Estimate a treatment plan property from finite samples or approximations. +13. `experimentalDesignApproximateTreatmentPlan(value, tolerance=1e-9)` - Approximate a treatment plan with explicit tolerance controls. +14. `experimentalDesignTransformTreatmentPlan(value, mapping)` - Transform a treatment plan through a map, operator, or representation change. +15. `experimentalDesignSimplifyTreatmentPlan(value)` - Simplify a treatment plan without changing its mathematical meaning. +16. `experimentalDesignEnumerateTreatmentPlan(value, limit=None)` - Enumerate finite members, cases, or derived objects for a treatment plan. +17. `experimentalDesignClassifyTreatmentPlan(value)` - Classify a treatment plan by its standard Experimental Design invariants. +18. `experimentalDesignTestEquivalenceTreatmentPlan(left, right)` - Test whether two treatment plan values are equivalent in Experimental Design. +19. `experimentalDesignGenerateExampleTreatmentPlan(size=3)` - Generate a small documented example of a treatment plan. +20. `experimentalDesignDocumentTreatmentPlan(value)` - Return a structured explanation of a treatment plan and related assumptions. +21. `experimentalDesignValidateBlockDesign(value)` - Validate the block design representation and domain rules for Experimental Design. +22. `experimentalDesignConstructBlockDesign(*args)` - Construct a block design from explicit inputs for Experimental Design. +23. `experimentalDesignNormalizeBlockDesign(value)` - Normalize a block design into the standard Experimental Design representation. +24. `experimentalDesignCanonicalizeBlockDesign(value)` - Canonicalize a block design so equivalent inputs share one form. +25. `experimentalDesignParseBlockDesign(text)` - Parse a text or structured value into a block design. +26. `experimentalDesignFormatBlockDesign(value)` - Format a block design for deterministic user-facing output. +27. `experimentalDesignCompareBlockDesign(left, right)` - Compare two block design values under the conventions of Experimental Design. +28. `experimentalDesignCombineBlockDesign(left, right)` - Combine two block design values with the natural operation for Experimental Design. +29. `experimentalDesignDecomposeBlockDesign(value)` - Decompose a block design into simpler or canonical components. +30. `experimentalDesignEvaluateBlockDesign(value, point=None)` - Evaluate a block design at a point, sample, or finite model. +31. `experimentalDesignComputeBlockDesign(value)` - Compute the central numerical or symbolic data of a block design. +32. `experimentalDesignEstimateBlockDesign(value, samples=None)` - Estimate a block design property from finite samples or approximations. +33. `experimentalDesignApproximateBlockDesign(value, tolerance=1e-9)` - Approximate a block design with explicit tolerance controls. +34. `experimentalDesignTransformBlockDesign(value, mapping)` - Transform a block design through a map, operator, or representation change. +35. `experimentalDesignSimplifyBlockDesign(value)` - Simplify a block design without changing its mathematical meaning. +36. `experimentalDesignEnumerateBlockDesign(value, limit=None)` - Enumerate finite members, cases, or derived objects for a block design. +37. `experimentalDesignClassifyBlockDesign(value)` - Classify a block design by its standard Experimental Design invariants. +38. `experimentalDesignTestEquivalenceBlockDesign(left, right)` - Test whether two block design values are equivalent in Experimental Design. +39. `experimentalDesignGenerateExampleBlockDesign(size=3)` - Generate a small documented example of a block design. +40. `experimentalDesignDocumentBlockDesign(value)` - Return a structured explanation of a block design and related assumptions. +41. `experimentalDesignValidateFactorialDesign(value)` - Validate the factorial design representation and domain rules for Experimental Design. +42. `experimentalDesignConstructFactorialDesign(*args)` - Construct a factorial design from explicit inputs for Experimental Design. +43. `experimentalDesignNormalizeFactorialDesign(value)` - Normalize a factorial design into the standard Experimental Design representation. +44. `experimentalDesignCanonicalizeFactorialDesign(value)` - Canonicalize a factorial design so equivalent inputs share one form. +45. `experimentalDesignParseFactorialDesign(text)` - Parse a text or structured value into a factorial design. +46. `experimentalDesignFormatFactorialDesign(value)` - Format a factorial design for deterministic user-facing output. +47. `experimentalDesignCompareFactorialDesign(left, right)` - Compare two factorial design values under the conventions of Experimental Design. +48. `experimentalDesignCombineFactorialDesign(left, right)` - Combine two factorial design values with the natural operation for Experimental Design. +49. `experimentalDesignDecomposeFactorialDesign(value)` - Decompose a factorial design into simpler or canonical components. +50. `experimentalDesignEvaluateFactorialDesign(value, point=None)` - Evaluate a factorial design at a point, sample, or finite model. +51. `experimentalDesignComputeFactorialDesign(value)` - Compute the central numerical or symbolic data of a factorial design. +52. `experimentalDesignEstimateFactorialDesign(value, samples=None)` - Estimate a factorial design property from finite samples or approximations. +53. `experimentalDesignApproximateFactorialDesign(value, tolerance=1e-9)` - Approximate a factorial design with explicit tolerance controls. +54. `experimentalDesignTransformFactorialDesign(value, mapping)` - Transform a factorial design through a map, operator, or representation change. +55. `experimentalDesignSimplifyFactorialDesign(value)` - Simplify a factorial design without changing its mathematical meaning. +56. `experimentalDesignEnumerateFactorialDesign(value, limit=None)` - Enumerate finite members, cases, or derived objects for a factorial design. +57. `experimentalDesignClassifyFactorialDesign(value)` - Classify a factorial design by its standard Experimental Design invariants. +58. `experimentalDesignTestEquivalenceFactorialDesign(left, right)` - Test whether two factorial design values are equivalent in Experimental Design. +59. `experimentalDesignGenerateExampleFactorialDesign(size=3)` - Generate a small documented example of a factorial design. +60. `experimentalDesignDocumentFactorialDesign(value)` - Return a structured explanation of a factorial design and related assumptions. +61. `experimentalDesignValidateAssignmentRule(value)` - Validate the assignment rule representation and domain rules for Experimental Design. +62. `experimentalDesignConstructAssignmentRule(*args)` - Construct a assignment rule from explicit inputs for Experimental Design. +63. `experimentalDesignNormalizeAssignmentRule(value)` - Normalize a assignment rule into the standard Experimental Design representation. +64. `experimentalDesignCanonicalizeAssignmentRule(value)` - Canonicalize a assignment rule so equivalent inputs share one form. +65. `experimentalDesignParseAssignmentRule(text)` - Parse a text or structured value into a assignment rule. +66. `experimentalDesignFormatAssignmentRule(value)` - Format a assignment rule for deterministic user-facing output. +67. `experimentalDesignCompareAssignmentRule(left, right)` - Compare two assignment rule values under the conventions of Experimental Design. +68. `experimentalDesignCombineAssignmentRule(left, right)` - Combine two assignment rule values with the natural operation for Experimental Design. +69. `experimentalDesignDecomposeAssignmentRule(value)` - Decompose a assignment rule into simpler or canonical components. +70. `experimentalDesignEvaluateAssignmentRule(value, point=None)` - Evaluate a assignment rule at a point, sample, or finite model. +71. `experimentalDesignComputeAssignmentRule(value)` - Compute the central numerical or symbolic data of a assignment rule. +72. `experimentalDesignEstimateAssignmentRule(value, samples=None)` - Estimate a assignment rule property from finite samples or approximations. +73. `experimentalDesignApproximateAssignmentRule(value, tolerance=1e-9)` - Approximate a assignment rule with explicit tolerance controls. +74. `experimentalDesignTransformAssignmentRule(value, mapping)` - Transform a assignment rule through a map, operator, or representation change. +75. `experimentalDesignSimplifyAssignmentRule(value)` - Simplify a assignment rule without changing its mathematical meaning. +76. `experimentalDesignEnumerateAssignmentRule(value, limit=None)` - Enumerate finite members, cases, or derived objects for a assignment rule. +77. `experimentalDesignClassifyAssignmentRule(value)` - Classify a assignment rule by its standard Experimental Design invariants. +78. `experimentalDesignTestEquivalenceAssignmentRule(left, right)` - Test whether two assignment rule values are equivalent in Experimental Design. +79. `experimentalDesignGenerateExampleAssignmentRule(size=3)` - Generate a small documented example of a assignment rule. +80. `experimentalDesignDocumentAssignmentRule(value)` - Return a structured explanation of a assignment rule and related assumptions. +81. `experimentalDesignValidateAnovaTable(value)` - Validate the anova table representation and domain rules for Experimental Design. +82. `experimentalDesignConstructAnovaTable(*args)` - Construct a anova table from explicit inputs for Experimental Design. +83. `experimentalDesignNormalizeAnovaTable(value)` - Normalize a anova table into the standard Experimental Design representation. +84. `experimentalDesignCanonicalizeAnovaTable(value)` - Canonicalize a anova table so equivalent inputs share one form. +85. `experimentalDesignParseAnovaTable(text)` - Parse a text or structured value into a anova table. +86. `experimentalDesignFormatAnovaTable(value)` - Format a anova table for deterministic user-facing output. +87. `experimentalDesignCompareAnovaTable(left, right)` - Compare two anova table values under the conventions of Experimental Design. +88. `experimentalDesignCombineAnovaTable(left, right)` - Combine two anova table values with the natural operation for Experimental Design. +89. `experimentalDesignDecomposeAnovaTable(value)` - Decompose a anova table into simpler or canonical components. +90. `experimentalDesignEvaluateAnovaTable(value, point=None)` - Evaluate a anova table at a point, sample, or finite model. +91. `experimentalDesignComputeAnovaTable(value)` - Compute the central numerical or symbolic data of a anova table. +92. `experimentalDesignEstimateAnovaTable(value, samples=None)` - Estimate a anova table property from finite samples or approximations. +93. `experimentalDesignApproximateAnovaTable(value, tolerance=1e-9)` - Approximate a anova table with explicit tolerance controls. +94. `experimentalDesignTransformAnovaTable(value, mapping)` - Transform a anova table through a map, operator, or representation change. +95. `experimentalDesignSimplifyAnovaTable(value)` - Simplify a anova table without changing its mathematical meaning. +96. `experimentalDesignEnumerateAnovaTable(value, limit=None)` - Enumerate finite members, cases, or derived objects for a anova table. +97. `experimentalDesignClassifyAnovaTable(value)` - Classify a anova table by its standard Experimental Design invariants. +98. `experimentalDesignTestEquivalenceAnovaTable(left, right)` - Test whether two anova table values are equivalent in Experimental Design. +99. `experimentalDesignGenerateExampleAnovaTable(size=3)` - Generate a small documented example of a anova table. +100. `experimentalDesignDocumentAnovaTable(value)` - Return a structured explanation of a anova table and related assumptions. + +### Computational Geometry + +Core object families: + +- point set +- line segment +- polygon mesh +- convex hull +- spatial query + +Candidate functions: + +1. `computationalGeometryValidatePointSet(value)` - Validate the point set representation and domain rules for Computational Geometry. +2. `computationalGeometryConstructPointSet(*args)` - Construct a point set from explicit inputs for Computational Geometry. +3. `computationalGeometryNormalizePointSet(value)` - Normalize a point set into the standard Computational Geometry representation. +4. `computationalGeometryCanonicalizePointSet(value)` - Canonicalize a point set so equivalent inputs share one form. +5. `computationalGeometryParsePointSet(text)` - Parse a text or structured value into a point set. +6. `computationalGeometryFormatPointSet(value)` - Format a point set for deterministic user-facing output. +7. `computationalGeometryComparePointSet(left, right)` - Compare two point set values under the conventions of Computational Geometry. +8. `computationalGeometryCombinePointSet(left, right)` - Combine two point set values with the natural operation for Computational Geometry. +9. `computationalGeometryDecomposePointSet(value)` - Decompose a point set into simpler or canonical components. +10. `computationalGeometryEvaluatePointSet(value, point=None)` - Evaluate a point set at a point, sample, or finite model. +11. `computationalGeometryComputePointSet(value)` - Compute the central numerical or symbolic data of a point set. +12. `computationalGeometryEstimatePointSet(value, samples=None)` - Estimate a point set property from finite samples or approximations. +13. `computationalGeometryApproximatePointSet(value, tolerance=1e-9)` - Approximate a point set with explicit tolerance controls. +14. `computationalGeometryTransformPointSet(value, mapping)` - Transform a point set through a map, operator, or representation change. +15. `computationalGeometrySimplifyPointSet(value)` - Simplify a point set without changing its mathematical meaning. +16. `computationalGeometryEnumeratePointSet(value, limit=None)` - Enumerate finite members, cases, or derived objects for a point set. +17. `computationalGeometryClassifyPointSet(value)` - Classify a point set by its standard Computational Geometry invariants. +18. `computationalGeometryTestEquivalencePointSet(left, right)` - Test whether two point set values are equivalent in Computational Geometry. +19. `computationalGeometryGenerateExamplePointSet(size=3)` - Generate a small documented example of a point set. +20. `computationalGeometryDocumentPointSet(value)` - Return a structured explanation of a point set and related assumptions. +21. `computationalGeometryValidateLineSegment(value)` - Validate the line segment representation and domain rules for Computational Geometry. +22. `computationalGeometryConstructLineSegment(*args)` - Construct a line segment from explicit inputs for Computational Geometry. +23. `computationalGeometryNormalizeLineSegment(value)` - Normalize a line segment into the standard Computational Geometry representation. +24. `computationalGeometryCanonicalizeLineSegment(value)` - Canonicalize a line segment so equivalent inputs share one form. +25. `computationalGeometryParseLineSegment(text)` - Parse a text or structured value into a line segment. +26. `computationalGeometryFormatLineSegment(value)` - Format a line segment for deterministic user-facing output. +27. `computationalGeometryCompareLineSegment(left, right)` - Compare two line segment values under the conventions of Computational Geometry. +28. `computationalGeometryCombineLineSegment(left, right)` - Combine two line segment values with the natural operation for Computational Geometry. +29. `computationalGeometryDecomposeLineSegment(value)` - Decompose a line segment into simpler or canonical components. +30. `computationalGeometryEvaluateLineSegment(value, point=None)` - Evaluate a line segment at a point, sample, or finite model. +31. `computationalGeometryComputeLineSegment(value)` - Compute the central numerical or symbolic data of a line segment. +32. `computationalGeometryEstimateLineSegment(value, samples=None)` - Estimate a line segment property from finite samples or approximations. +33. `computationalGeometryApproximateLineSegment(value, tolerance=1e-9)` - Approximate a line segment with explicit tolerance controls. +34. `computationalGeometryTransformLineSegment(value, mapping)` - Transform a line segment through a map, operator, or representation change. +35. `computationalGeometrySimplifyLineSegment(value)` - Simplify a line segment without changing its mathematical meaning. +36. `computationalGeometryEnumerateLineSegment(value, limit=None)` - Enumerate finite members, cases, or derived objects for a line segment. +37. `computationalGeometryClassifyLineSegment(value)` - Classify a line segment by its standard Computational Geometry invariants. +38. `computationalGeometryTestEquivalenceLineSegment(left, right)` - Test whether two line segment values are equivalent in Computational Geometry. +39. `computationalGeometryGenerateExampleLineSegment(size=3)` - Generate a small documented example of a line segment. +40. `computationalGeometryDocumentLineSegment(value)` - Return a structured explanation of a line segment and related assumptions. +41. `computationalGeometryValidatePolygonMesh(value)` - Validate the polygon mesh representation and domain rules for Computational Geometry. +42. `computationalGeometryConstructPolygonMesh(*args)` - Construct a polygon mesh from explicit inputs for Computational Geometry. +43. `computationalGeometryNormalizePolygonMesh(value)` - Normalize a polygon mesh into the standard Computational Geometry representation. +44. `computationalGeometryCanonicalizePolygonMesh(value)` - Canonicalize a polygon mesh so equivalent inputs share one form. +45. `computationalGeometryParsePolygonMesh(text)` - Parse a text or structured value into a polygon mesh. +46. `computationalGeometryFormatPolygonMesh(value)` - Format a polygon mesh for deterministic user-facing output. +47. `computationalGeometryComparePolygonMesh(left, right)` - Compare two polygon mesh values under the conventions of Computational Geometry. +48. `computationalGeometryCombinePolygonMesh(left, right)` - Combine two polygon mesh values with the natural operation for Computational Geometry. +49. `computationalGeometryDecomposePolygonMesh(value)` - Decompose a polygon mesh into simpler or canonical components. +50. `computationalGeometryEvaluatePolygonMesh(value, point=None)` - Evaluate a polygon mesh at a point, sample, or finite model. +51. `computationalGeometryComputePolygonMesh(value)` - Compute the central numerical or symbolic data of a polygon mesh. +52. `computationalGeometryEstimatePolygonMesh(value, samples=None)` - Estimate a polygon mesh property from finite samples or approximations. +53. `computationalGeometryApproximatePolygonMesh(value, tolerance=1e-9)` - Approximate a polygon mesh with explicit tolerance controls. +54. `computationalGeometryTransformPolygonMesh(value, mapping)` - Transform a polygon mesh through a map, operator, or representation change. +55. `computationalGeometrySimplifyPolygonMesh(value)` - Simplify a polygon mesh without changing its mathematical meaning. +56. `computationalGeometryEnumeratePolygonMesh(value, limit=None)` - Enumerate finite members, cases, or derived objects for a polygon mesh. +57. `computationalGeometryClassifyPolygonMesh(value)` - Classify a polygon mesh by its standard Computational Geometry invariants. +58. `computationalGeometryTestEquivalencePolygonMesh(left, right)` - Test whether two polygon mesh values are equivalent in Computational Geometry. +59. `computationalGeometryGenerateExamplePolygonMesh(size=3)` - Generate a small documented example of a polygon mesh. +60. `computationalGeometryDocumentPolygonMesh(value)` - Return a structured explanation of a polygon mesh and related assumptions. +61. `computationalGeometryValidateConvexHull(value)` - Validate the convex hull representation and domain rules for Computational Geometry. +62. `computationalGeometryConstructConvexHull(*args)` - Construct a convex hull from explicit inputs for Computational Geometry. +63. `computationalGeometryNormalizeConvexHull(value)` - Normalize a convex hull into the standard Computational Geometry representation. +64. `computationalGeometryCanonicalizeConvexHull(value)` - Canonicalize a convex hull so equivalent inputs share one form. +65. `computationalGeometryParseConvexHull(text)` - Parse a text or structured value into a convex hull. +66. `computationalGeometryFormatConvexHull(value)` - Format a convex hull for deterministic user-facing output. +67. `computationalGeometryCompareConvexHull(left, right)` - Compare two convex hull values under the conventions of Computational Geometry. +68. `computationalGeometryCombineConvexHull(left, right)` - Combine two convex hull values with the natural operation for Computational Geometry. +69. `computationalGeometryDecomposeConvexHull(value)` - Decompose a convex hull into simpler or canonical components. +70. `computationalGeometryEvaluateConvexHull(value, point=None)` - Evaluate a convex hull at a point, sample, or finite model. +71. `computationalGeometryComputeConvexHull(value)` - Compute the central numerical or symbolic data of a convex hull. +72. `computationalGeometryEstimateConvexHull(value, samples=None)` - Estimate a convex hull property from finite samples or approximations. +73. `computationalGeometryApproximateConvexHull(value, tolerance=1e-9)` - Approximate a convex hull with explicit tolerance controls. +74. `computationalGeometryTransformConvexHull(value, mapping)` - Transform a convex hull through a map, operator, or representation change. +75. `computationalGeometrySimplifyConvexHull(value)` - Simplify a convex hull without changing its mathematical meaning. +76. `computationalGeometryEnumerateConvexHull(value, limit=None)` - Enumerate finite members, cases, or derived objects for a convex hull. +77. `computationalGeometryClassifyConvexHull(value)` - Classify a convex hull by its standard Computational Geometry invariants. +78. `computationalGeometryTestEquivalenceConvexHull(left, right)` - Test whether two convex hull values are equivalent in Computational Geometry. +79. `computationalGeometryGenerateExampleConvexHull(size=3)` - Generate a small documented example of a convex hull. +80. `computationalGeometryDocumentConvexHull(value)` - Return a structured explanation of a convex hull and related assumptions. +81. `computationalGeometryValidateSpatialQuery(value)` - Validate the spatial query representation and domain rules for Computational Geometry. +82. `computationalGeometryConstructSpatialQuery(*args)` - Construct a spatial query from explicit inputs for Computational Geometry. +83. `computationalGeometryNormalizeSpatialQuery(value)` - Normalize a spatial query into the standard Computational Geometry representation. +84. `computationalGeometryCanonicalizeSpatialQuery(value)` - Canonicalize a spatial query so equivalent inputs share one form. +85. `computationalGeometryParseSpatialQuery(text)` - Parse a text or structured value into a spatial query. +86. `computationalGeometryFormatSpatialQuery(value)` - Format a spatial query for deterministic user-facing output. +87. `computationalGeometryCompareSpatialQuery(left, right)` - Compare two spatial query values under the conventions of Computational Geometry. +88. `computationalGeometryCombineSpatialQuery(left, right)` - Combine two spatial query values with the natural operation for Computational Geometry. +89. `computationalGeometryDecomposeSpatialQuery(value)` - Decompose a spatial query into simpler or canonical components. +90. `computationalGeometryEvaluateSpatialQuery(value, point=None)` - Evaluate a spatial query at a point, sample, or finite model. +91. `computationalGeometryComputeSpatialQuery(value)` - Compute the central numerical or symbolic data of a spatial query. +92. `computationalGeometryEstimateSpatialQuery(value, samples=None)` - Estimate a spatial query property from finite samples or approximations. +93. `computationalGeometryApproximateSpatialQuery(value, tolerance=1e-9)` - Approximate a spatial query with explicit tolerance controls. +94. `computationalGeometryTransformSpatialQuery(value, mapping)` - Transform a spatial query through a map, operator, or representation change. +95. `computationalGeometrySimplifySpatialQuery(value)` - Simplify a spatial query without changing its mathematical meaning. +96. `computationalGeometryEnumerateSpatialQuery(value, limit=None)` - Enumerate finite members, cases, or derived objects for a spatial query. +97. `computationalGeometryClassifySpatialQuery(value)` - Classify a spatial query by its standard Computational Geometry invariants. +98. `computationalGeometryTestEquivalenceSpatialQuery(left, right)` - Test whether two spatial query values are equivalent in Computational Geometry. +99. `computationalGeometryGenerateExampleSpatialQuery(size=3)` - Generate a small documented example of a spatial query. +100. `computationalGeometryDocumentSpatialQuery(value)` - Return a structured explanation of a spatial query and related assumptions. + +### Differential Geometry + +Core object families: + +- parametric curve +- parametric surface +- curvature profile +- frame field +- geodesic sample + +Candidate functions: + +1. `differentialGeometryValidateParametricCurve(value)` - Validate the parametric curve representation and domain rules for Differential Geometry. +2. `differentialGeometryConstructParametricCurve(*args)` - Construct a parametric curve from explicit inputs for Differential Geometry. +3. `differentialGeometryNormalizeParametricCurve(value)` - Normalize a parametric curve into the standard Differential Geometry representation. +4. `differentialGeometryCanonicalizeParametricCurve(value)` - Canonicalize a parametric curve so equivalent inputs share one form. +5. `differentialGeometryParseParametricCurve(text)` - Parse a text or structured value into a parametric curve. +6. `differentialGeometryFormatParametricCurve(value)` - Format a parametric curve for deterministic user-facing output. +7. `differentialGeometryCompareParametricCurve(left, right)` - Compare two parametric curve values under the conventions of Differential Geometry. +8. `differentialGeometryCombineParametricCurve(left, right)` - Combine two parametric curve values with the natural operation for Differential Geometry. +9. `differentialGeometryDecomposeParametricCurve(value)` - Decompose a parametric curve into simpler or canonical components. +10. `differentialGeometryEvaluateParametricCurve(value, point=None)` - Evaluate a parametric curve at a point, sample, or finite model. +11. `differentialGeometryComputeParametricCurve(value)` - Compute the central numerical or symbolic data of a parametric curve. +12. `differentialGeometryEstimateParametricCurve(value, samples=None)` - Estimate a parametric curve property from finite samples or approximations. +13. `differentialGeometryApproximateParametricCurve(value, tolerance=1e-9)` - Approximate a parametric curve with explicit tolerance controls. +14. `differentialGeometryTransformParametricCurve(value, mapping)` - Transform a parametric curve through a map, operator, or representation change. +15. `differentialGeometrySimplifyParametricCurve(value)` - Simplify a parametric curve without changing its mathematical meaning. +16. `differentialGeometryEnumerateParametricCurve(value, limit=None)` - Enumerate finite members, cases, or derived objects for a parametric curve. +17. `differentialGeometryClassifyParametricCurve(value)` - Classify a parametric curve by its standard Differential Geometry invariants. +18. `differentialGeometryTestEquivalenceParametricCurve(left, right)` - Test whether two parametric curve values are equivalent in Differential Geometry. +19. `differentialGeometryGenerateExampleParametricCurve(size=3)` - Generate a small documented example of a parametric curve. +20. `differentialGeometryDocumentParametricCurve(value)` - Return a structured explanation of a parametric curve and related assumptions. +21. `differentialGeometryValidateParametricSurface(value)` - Validate the parametric surface representation and domain rules for Differential Geometry. +22. `differentialGeometryConstructParametricSurface(*args)` - Construct a parametric surface from explicit inputs for Differential Geometry. +23. `differentialGeometryNormalizeParametricSurface(value)` - Normalize a parametric surface into the standard Differential Geometry representation. +24. `differentialGeometryCanonicalizeParametricSurface(value)` - Canonicalize a parametric surface so equivalent inputs share one form. +25. `differentialGeometryParseParametricSurface(text)` - Parse a text or structured value into a parametric surface. +26. `differentialGeometryFormatParametricSurface(value)` - Format a parametric surface for deterministic user-facing output. +27. `differentialGeometryCompareParametricSurface(left, right)` - Compare two parametric surface values under the conventions of Differential Geometry. +28. `differentialGeometryCombineParametricSurface(left, right)` - Combine two parametric surface values with the natural operation for Differential Geometry. +29. `differentialGeometryDecomposeParametricSurface(value)` - Decompose a parametric surface into simpler or canonical components. +30. `differentialGeometryEvaluateParametricSurface(value, point=None)` - Evaluate a parametric surface at a point, sample, or finite model. +31. `differentialGeometryComputeParametricSurface(value)` - Compute the central numerical or symbolic data of a parametric surface. +32. `differentialGeometryEstimateParametricSurface(value, samples=None)` - Estimate a parametric surface property from finite samples or approximations. +33. `differentialGeometryApproximateParametricSurface(value, tolerance=1e-9)` - Approximate a parametric surface with explicit tolerance controls. +34. `differentialGeometryTransformParametricSurface(value, mapping)` - Transform a parametric surface through a map, operator, or representation change. +35. `differentialGeometrySimplifyParametricSurface(value)` - Simplify a parametric surface without changing its mathematical meaning. +36. `differentialGeometryEnumerateParametricSurface(value, limit=None)` - Enumerate finite members, cases, or derived objects for a parametric surface. +37. `differentialGeometryClassifyParametricSurface(value)` - Classify a parametric surface by its standard Differential Geometry invariants. +38. `differentialGeometryTestEquivalenceParametricSurface(left, right)` - Test whether two parametric surface values are equivalent in Differential Geometry. +39. `differentialGeometryGenerateExampleParametricSurface(size=3)` - Generate a small documented example of a parametric surface. +40. `differentialGeometryDocumentParametricSurface(value)` - Return a structured explanation of a parametric surface and related assumptions. +41. `differentialGeometryValidateCurvatureProfile(value)` - Validate the curvature profile representation and domain rules for Differential Geometry. +42. `differentialGeometryConstructCurvatureProfile(*args)` - Construct a curvature profile from explicit inputs for Differential Geometry. +43. `differentialGeometryNormalizeCurvatureProfile(value)` - Normalize a curvature profile into the standard Differential Geometry representation. +44. `differentialGeometryCanonicalizeCurvatureProfile(value)` - Canonicalize a curvature profile so equivalent inputs share one form. +45. `differentialGeometryParseCurvatureProfile(text)` - Parse a text or structured value into a curvature profile. +46. `differentialGeometryFormatCurvatureProfile(value)` - Format a curvature profile for deterministic user-facing output. +47. `differentialGeometryCompareCurvatureProfile(left, right)` - Compare two curvature profile values under the conventions of Differential Geometry. +48. `differentialGeometryCombineCurvatureProfile(left, right)` - Combine two curvature profile values with the natural operation for Differential Geometry. +49. `differentialGeometryDecomposeCurvatureProfile(value)` - Decompose a curvature profile into simpler or canonical components. +50. `differentialGeometryEvaluateCurvatureProfile(value, point=None)` - Evaluate a curvature profile at a point, sample, or finite model. +51. `differentialGeometryComputeCurvatureProfile(value)` - Compute the central numerical or symbolic data of a curvature profile. +52. `differentialGeometryEstimateCurvatureProfile(value, samples=None)` - Estimate a curvature profile property from finite samples or approximations. +53. `differentialGeometryApproximateCurvatureProfile(value, tolerance=1e-9)` - Approximate a curvature profile with explicit tolerance controls. +54. `differentialGeometryTransformCurvatureProfile(value, mapping)` - Transform a curvature profile through a map, operator, or representation change. +55. `differentialGeometrySimplifyCurvatureProfile(value)` - Simplify a curvature profile without changing its mathematical meaning. +56. `differentialGeometryEnumerateCurvatureProfile(value, limit=None)` - Enumerate finite members, cases, or derived objects for a curvature profile. +57. `differentialGeometryClassifyCurvatureProfile(value)` - Classify a curvature profile by its standard Differential Geometry invariants. +58. `differentialGeometryTestEquivalenceCurvatureProfile(left, right)` - Test whether two curvature profile values are equivalent in Differential Geometry. +59. `differentialGeometryGenerateExampleCurvatureProfile(size=3)` - Generate a small documented example of a curvature profile. +60. `differentialGeometryDocumentCurvatureProfile(value)` - Return a structured explanation of a curvature profile and related assumptions. +61. `differentialGeometryValidateFrameField(value)` - Validate the frame field representation and domain rules for Differential Geometry. +62. `differentialGeometryConstructFrameField(*args)` - Construct a frame field from explicit inputs for Differential Geometry. +63. `differentialGeometryNormalizeFrameField(value)` - Normalize a frame field into the standard Differential Geometry representation. +64. `differentialGeometryCanonicalizeFrameField(value)` - Canonicalize a frame field so equivalent inputs share one form. +65. `differentialGeometryParseFrameField(text)` - Parse a text or structured value into a frame field. +66. `differentialGeometryFormatFrameField(value)` - Format a frame field for deterministic user-facing output. +67. `differentialGeometryCompareFrameField(left, right)` - Compare two frame field values under the conventions of Differential Geometry. +68. `differentialGeometryCombineFrameField(left, right)` - Combine two frame field values with the natural operation for Differential Geometry. +69. `differentialGeometryDecomposeFrameField(value)` - Decompose a frame field into simpler or canonical components. +70. `differentialGeometryEvaluateFrameField(value, point=None)` - Evaluate a frame field at a point, sample, or finite model. +71. `differentialGeometryComputeFrameField(value)` - Compute the central numerical or symbolic data of a frame field. +72. `differentialGeometryEstimateFrameField(value, samples=None)` - Estimate a frame field property from finite samples or approximations. +73. `differentialGeometryApproximateFrameField(value, tolerance=1e-9)` - Approximate a frame field with explicit tolerance controls. +74. `differentialGeometryTransformFrameField(value, mapping)` - Transform a frame field through a map, operator, or representation change. +75. `differentialGeometrySimplifyFrameField(value)` - Simplify a frame field without changing its mathematical meaning. +76. `differentialGeometryEnumerateFrameField(value, limit=None)` - Enumerate finite members, cases, or derived objects for a frame field. +77. `differentialGeometryClassifyFrameField(value)` - Classify a frame field by its standard Differential Geometry invariants. +78. `differentialGeometryTestEquivalenceFrameField(left, right)` - Test whether two frame field values are equivalent in Differential Geometry. +79. `differentialGeometryGenerateExampleFrameField(size=3)` - Generate a small documented example of a frame field. +80. `differentialGeometryDocumentFrameField(value)` - Return a structured explanation of a frame field and related assumptions. +81. `differentialGeometryValidateGeodesicSample(value)` - Validate the geodesic sample representation and domain rules for Differential Geometry. +82. `differentialGeometryConstructGeodesicSample(*args)` - Construct a geodesic sample from explicit inputs for Differential Geometry. +83. `differentialGeometryNormalizeGeodesicSample(value)` - Normalize a geodesic sample into the standard Differential Geometry representation. +84. `differentialGeometryCanonicalizeGeodesicSample(value)` - Canonicalize a geodesic sample so equivalent inputs share one form. +85. `differentialGeometryParseGeodesicSample(text)` - Parse a text or structured value into a geodesic sample. +86. `differentialGeometryFormatGeodesicSample(value)` - Format a geodesic sample for deterministic user-facing output. +87. `differentialGeometryCompareGeodesicSample(left, right)` - Compare two geodesic sample values under the conventions of Differential Geometry. +88. `differentialGeometryCombineGeodesicSample(left, right)` - Combine two geodesic sample values with the natural operation for Differential Geometry. +89. `differentialGeometryDecomposeGeodesicSample(value)` - Decompose a geodesic sample into simpler or canonical components. +90. `differentialGeometryEvaluateGeodesicSample(value, point=None)` - Evaluate a geodesic sample at a point, sample, or finite model. +91. `differentialGeometryComputeGeodesicSample(value)` - Compute the central numerical or symbolic data of a geodesic sample. +92. `differentialGeometryEstimateGeodesicSample(value, samples=None)` - Estimate a geodesic sample property from finite samples or approximations. +93. `differentialGeometryApproximateGeodesicSample(value, tolerance=1e-9)` - Approximate a geodesic sample with explicit tolerance controls. +94. `differentialGeometryTransformGeodesicSample(value, mapping)` - Transform a geodesic sample through a map, operator, or representation change. +95. `differentialGeometrySimplifyGeodesicSample(value)` - Simplify a geodesic sample without changing its mathematical meaning. +96. `differentialGeometryEnumerateGeodesicSample(value, limit=None)` - Enumerate finite members, cases, or derived objects for a geodesic sample. +97. `differentialGeometryClassifyGeodesicSample(value)` - Classify a geodesic sample by its standard Differential Geometry invariants. +98. `differentialGeometryTestEquivalenceGeodesicSample(left, right)` - Test whether two geodesic sample values are equivalent in Differential Geometry. +99. `differentialGeometryGenerateExampleGeodesicSample(size=3)` - Generate a small documented example of a geodesic sample. +100. `differentialGeometryDocumentGeodesicSample(value)` - Return a structured explanation of a geodesic sample and related assumptions. + +### Riemannian Geometry + +Core object families: + +- metric tensor +- connection +- geodesic +- curvature tensor +- manifold chart + +Candidate functions: + +1. `riemannianGeometryValidateMetricTensor(value)` - Validate the metric tensor representation and domain rules for Riemannian Geometry. +2. `riemannianGeometryConstructMetricTensor(*args)` - Construct a metric tensor from explicit inputs for Riemannian Geometry. +3. `riemannianGeometryNormalizeMetricTensor(value)` - Normalize a metric tensor into the standard Riemannian Geometry representation. +4. `riemannianGeometryCanonicalizeMetricTensor(value)` - Canonicalize a metric tensor so equivalent inputs share one form. +5. `riemannianGeometryParseMetricTensor(text)` - Parse a text or structured value into a metric tensor. +6. `riemannianGeometryFormatMetricTensor(value)` - Format a metric tensor for deterministic user-facing output. +7. `riemannianGeometryCompareMetricTensor(left, right)` - Compare two metric tensor values under the conventions of Riemannian Geometry. +8. `riemannianGeometryCombineMetricTensor(left, right)` - Combine two metric tensor values with the natural operation for Riemannian Geometry. +9. `riemannianGeometryDecomposeMetricTensor(value)` - Decompose a metric tensor into simpler or canonical components. +10. `riemannianGeometryEvaluateMetricTensor(value, point=None)` - Evaluate a metric tensor at a point, sample, or finite model. +11. `riemannianGeometryComputeMetricTensor(value)` - Compute the central numerical or symbolic data of a metric tensor. +12. `riemannianGeometryEstimateMetricTensor(value, samples=None)` - Estimate a metric tensor property from finite samples or approximations. +13. `riemannianGeometryApproximateMetricTensor(value, tolerance=1e-9)` - Approximate a metric tensor with explicit tolerance controls. +14. `riemannianGeometryTransformMetricTensor(value, mapping)` - Transform a metric tensor through a map, operator, or representation change. +15. `riemannianGeometrySimplifyMetricTensor(value)` - Simplify a metric tensor without changing its mathematical meaning. +16. `riemannianGeometryEnumerateMetricTensor(value, limit=None)` - Enumerate finite members, cases, or derived objects for a metric tensor. +17. `riemannianGeometryClassifyMetricTensor(value)` - Classify a metric tensor by its standard Riemannian Geometry invariants. +18. `riemannianGeometryTestEquivalenceMetricTensor(left, right)` - Test whether two metric tensor values are equivalent in Riemannian Geometry. +19. `riemannianGeometryGenerateExampleMetricTensor(size=3)` - Generate a small documented example of a metric tensor. +20. `riemannianGeometryDocumentMetricTensor(value)` - Return a structured explanation of a metric tensor and related assumptions. +21. `riemannianGeometryValidateConnection(value)` - Validate the connection representation and domain rules for Riemannian Geometry. +22. `riemannianGeometryConstructConnection(*args)` - Construct a connection from explicit inputs for Riemannian Geometry. +23. `riemannianGeometryNormalizeConnection(value)` - Normalize a connection into the standard Riemannian Geometry representation. +24. `riemannianGeometryCanonicalizeConnection(value)` - Canonicalize a connection so equivalent inputs share one form. +25. `riemannianGeometryParseConnection(text)` - Parse a text or structured value into a connection. +26. `riemannianGeometryFormatConnection(value)` - Format a connection for deterministic user-facing output. +27. `riemannianGeometryCompareConnection(left, right)` - Compare two connection values under the conventions of Riemannian Geometry. +28. `riemannianGeometryCombineConnection(left, right)` - Combine two connection values with the natural operation for Riemannian Geometry. +29. `riemannianGeometryDecomposeConnection(value)` - Decompose a connection into simpler or canonical components. +30. `riemannianGeometryEvaluateConnection(value, point=None)` - Evaluate a connection at a point, sample, or finite model. +31. `riemannianGeometryComputeConnection(value)` - Compute the central numerical or symbolic data of a connection. +32. `riemannianGeometryEstimateConnection(value, samples=None)` - Estimate a connection property from finite samples or approximations. +33. `riemannianGeometryApproximateConnection(value, tolerance=1e-9)` - Approximate a connection with explicit tolerance controls. +34. `riemannianGeometryTransformConnection(value, mapping)` - Transform a connection through a map, operator, or representation change. +35. `riemannianGeometrySimplifyConnection(value)` - Simplify a connection without changing its mathematical meaning. +36. `riemannianGeometryEnumerateConnection(value, limit=None)` - Enumerate finite members, cases, or derived objects for a connection. +37. `riemannianGeometryClassifyConnection(value)` - Classify a connection by its standard Riemannian Geometry invariants. +38. `riemannianGeometryTestEquivalenceConnection(left, right)` - Test whether two connection values are equivalent in Riemannian Geometry. +39. `riemannianGeometryGenerateExampleConnection(size=3)` - Generate a small documented example of a connection. +40. `riemannianGeometryDocumentConnection(value)` - Return a structured explanation of a connection and related assumptions. +41. `riemannianGeometryValidateGeodesic(value)` - Validate the geodesic representation and domain rules for Riemannian Geometry. +42. `riemannianGeometryConstructGeodesic(*args)` - Construct a geodesic from explicit inputs for Riemannian Geometry. +43. `riemannianGeometryNormalizeGeodesic(value)` - Normalize a geodesic into the standard Riemannian Geometry representation. +44. `riemannianGeometryCanonicalizeGeodesic(value)` - Canonicalize a geodesic so equivalent inputs share one form. +45. `riemannianGeometryParseGeodesic(text)` - Parse a text or structured value into a geodesic. +46. `riemannianGeometryFormatGeodesic(value)` - Format a geodesic for deterministic user-facing output. +47. `riemannianGeometryCompareGeodesic(left, right)` - Compare two geodesic values under the conventions of Riemannian Geometry. +48. `riemannianGeometryCombineGeodesic(left, right)` - Combine two geodesic values with the natural operation for Riemannian Geometry. +49. `riemannianGeometryDecomposeGeodesic(value)` - Decompose a geodesic into simpler or canonical components. +50. `riemannianGeometryEvaluateGeodesic(value, point=None)` - Evaluate a geodesic at a point, sample, or finite model. +51. `riemannianGeometryComputeGeodesic(value)` - Compute the central numerical or symbolic data of a geodesic. +52. `riemannianGeometryEstimateGeodesic(value, samples=None)` - Estimate a geodesic property from finite samples or approximations. +53. `riemannianGeometryApproximateGeodesic(value, tolerance=1e-9)` - Approximate a geodesic with explicit tolerance controls. +54. `riemannianGeometryTransformGeodesic(value, mapping)` - Transform a geodesic through a map, operator, or representation change. +55. `riemannianGeometrySimplifyGeodesic(value)` - Simplify a geodesic without changing its mathematical meaning. +56. `riemannianGeometryEnumerateGeodesic(value, limit=None)` - Enumerate finite members, cases, or derived objects for a geodesic. +57. `riemannianGeometryClassifyGeodesic(value)` - Classify a geodesic by its standard Riemannian Geometry invariants. +58. `riemannianGeometryTestEquivalenceGeodesic(left, right)` - Test whether two geodesic values are equivalent in Riemannian Geometry. +59. `riemannianGeometryGenerateExampleGeodesic(size=3)` - Generate a small documented example of a geodesic. +60. `riemannianGeometryDocumentGeodesic(value)` - Return a structured explanation of a geodesic and related assumptions. +61. `riemannianGeometryValidateCurvatureTensor(value)` - Validate the curvature tensor representation and domain rules for Riemannian Geometry. +62. `riemannianGeometryConstructCurvatureTensor(*args)` - Construct a curvature tensor from explicit inputs for Riemannian Geometry. +63. `riemannianGeometryNormalizeCurvatureTensor(value)` - Normalize a curvature tensor into the standard Riemannian Geometry representation. +64. `riemannianGeometryCanonicalizeCurvatureTensor(value)` - Canonicalize a curvature tensor so equivalent inputs share one form. +65. `riemannianGeometryParseCurvatureTensor(text)` - Parse a text or structured value into a curvature tensor. +66. `riemannianGeometryFormatCurvatureTensor(value)` - Format a curvature tensor for deterministic user-facing output. +67. `riemannianGeometryCompareCurvatureTensor(left, right)` - Compare two curvature tensor values under the conventions of Riemannian Geometry. +68. `riemannianGeometryCombineCurvatureTensor(left, right)` - Combine two curvature tensor values with the natural operation for Riemannian Geometry. +69. `riemannianGeometryDecomposeCurvatureTensor(value)` - Decompose a curvature tensor into simpler or canonical components. +70. `riemannianGeometryEvaluateCurvatureTensor(value, point=None)` - Evaluate a curvature tensor at a point, sample, or finite model. +71. `riemannianGeometryComputeCurvatureTensor(value)` - Compute the central numerical or symbolic data of a curvature tensor. +72. `riemannianGeometryEstimateCurvatureTensor(value, samples=None)` - Estimate a curvature tensor property from finite samples or approximations. +73. `riemannianGeometryApproximateCurvatureTensor(value, tolerance=1e-9)` - Approximate a curvature tensor with explicit tolerance controls. +74. `riemannianGeometryTransformCurvatureTensor(value, mapping)` - Transform a curvature tensor through a map, operator, or representation change. +75. `riemannianGeometrySimplifyCurvatureTensor(value)` - Simplify a curvature tensor without changing its mathematical meaning. +76. `riemannianGeometryEnumerateCurvatureTensor(value, limit=None)` - Enumerate finite members, cases, or derived objects for a curvature tensor. +77. `riemannianGeometryClassifyCurvatureTensor(value)` - Classify a curvature tensor by its standard Riemannian Geometry invariants. +78. `riemannianGeometryTestEquivalenceCurvatureTensor(left, right)` - Test whether two curvature tensor values are equivalent in Riemannian Geometry. +79. `riemannianGeometryGenerateExampleCurvatureTensor(size=3)` - Generate a small documented example of a curvature tensor. +80. `riemannianGeometryDocumentCurvatureTensor(value)` - Return a structured explanation of a curvature tensor and related assumptions. +81. `riemannianGeometryValidateManifoldChart(value)` - Validate the manifold chart representation and domain rules for Riemannian Geometry. +82. `riemannianGeometryConstructManifoldChart(*args)` - Construct a manifold chart from explicit inputs for Riemannian Geometry. +83. `riemannianGeometryNormalizeManifoldChart(value)` - Normalize a manifold chart into the standard Riemannian Geometry representation. +84. `riemannianGeometryCanonicalizeManifoldChart(value)` - Canonicalize a manifold chart so equivalent inputs share one form. +85. `riemannianGeometryParseManifoldChart(text)` - Parse a text or structured value into a manifold chart. +86. `riemannianGeometryFormatManifoldChart(value)` - Format a manifold chart for deterministic user-facing output. +87. `riemannianGeometryCompareManifoldChart(left, right)` - Compare two manifold chart values under the conventions of Riemannian Geometry. +88. `riemannianGeometryCombineManifoldChart(left, right)` - Combine two manifold chart values with the natural operation for Riemannian Geometry. +89. `riemannianGeometryDecomposeManifoldChart(value)` - Decompose a manifold chart into simpler or canonical components. +90. `riemannianGeometryEvaluateManifoldChart(value, point=None)` - Evaluate a manifold chart at a point, sample, or finite model. +91. `riemannianGeometryComputeManifoldChart(value)` - Compute the central numerical or symbolic data of a manifold chart. +92. `riemannianGeometryEstimateManifoldChart(value, samples=None)` - Estimate a manifold chart property from finite samples or approximations. +93. `riemannianGeometryApproximateManifoldChart(value, tolerance=1e-9)` - Approximate a manifold chart with explicit tolerance controls. +94. `riemannianGeometryTransformManifoldChart(value, mapping)` - Transform a manifold chart through a map, operator, or representation change. +95. `riemannianGeometrySimplifyManifoldChart(value)` - Simplify a manifold chart without changing its mathematical meaning. +96. `riemannianGeometryEnumerateManifoldChart(value, limit=None)` - Enumerate finite members, cases, or derived objects for a manifold chart. +97. `riemannianGeometryClassifyManifoldChart(value)` - Classify a manifold chart by its standard Riemannian Geometry invariants. +98. `riemannianGeometryTestEquivalenceManifoldChart(left, right)` - Test whether two manifold chart values are equivalent in Riemannian Geometry. +99. `riemannianGeometryGenerateExampleManifoldChart(size=3)` - Generate a small documented example of a manifold chart. +100. `riemannianGeometryDocumentManifoldChart(value)` - Return a structured explanation of a manifold chart and related assumptions. + +### Algebraic Geometry + +Core object families: + +- polynomial system +- affine variety +- ideal +- monomial order +- coordinate ring + +Candidate functions: + +1. `algebraicGeometryValidatePolynomialSystem(value)` - Validate the polynomial system representation and domain rules for Algebraic Geometry. +2. `algebraicGeometryConstructPolynomialSystem(*args)` - Construct a polynomial system from explicit inputs for Algebraic Geometry. +3. `algebraicGeometryNormalizePolynomialSystem(value)` - Normalize a polynomial system into the standard Algebraic Geometry representation. +4. `algebraicGeometryCanonicalizePolynomialSystem(value)` - Canonicalize a polynomial system so equivalent inputs share one form. +5. `algebraicGeometryParsePolynomialSystem(text)` - Parse a text or structured value into a polynomial system. +6. `algebraicGeometryFormatPolynomialSystem(value)` - Format a polynomial system for deterministic user-facing output. +7. `algebraicGeometryComparePolynomialSystem(left, right)` - Compare two polynomial system values under the conventions of Algebraic Geometry. +8. `algebraicGeometryCombinePolynomialSystem(left, right)` - Combine two polynomial system values with the natural operation for Algebraic Geometry. +9. `algebraicGeometryDecomposePolynomialSystem(value)` - Decompose a polynomial system into simpler or canonical components. +10. `algebraicGeometryEvaluatePolynomialSystem(value, point=None)` - Evaluate a polynomial system at a point, sample, or finite model. +11. `algebraicGeometryComputePolynomialSystem(value)` - Compute the central numerical or symbolic data of a polynomial system. +12. `algebraicGeometryEstimatePolynomialSystem(value, samples=None)` - Estimate a polynomial system property from finite samples or approximations. +13. `algebraicGeometryApproximatePolynomialSystem(value, tolerance=1e-9)` - Approximate a polynomial system with explicit tolerance controls. +14. `algebraicGeometryTransformPolynomialSystem(value, mapping)` - Transform a polynomial system through a map, operator, or representation change. +15. `algebraicGeometrySimplifyPolynomialSystem(value)` - Simplify a polynomial system without changing its mathematical meaning. +16. `algebraicGeometryEnumeratePolynomialSystem(value, limit=None)` - Enumerate finite members, cases, or derived objects for a polynomial system. +17. `algebraicGeometryClassifyPolynomialSystem(value)` - Classify a polynomial system by its standard Algebraic Geometry invariants. +18. `algebraicGeometryTestEquivalencePolynomialSystem(left, right)` - Test whether two polynomial system values are equivalent in Algebraic Geometry. +19. `algebraicGeometryGenerateExamplePolynomialSystem(size=3)` - Generate a small documented example of a polynomial system. +20. `algebraicGeometryDocumentPolynomialSystem(value)` - Return a structured explanation of a polynomial system and related assumptions. +21. `algebraicGeometryValidateAffineVariety(value)` - Validate the affine variety representation and domain rules for Algebraic Geometry. +22. `algebraicGeometryConstructAffineVariety(*args)` - Construct a affine variety from explicit inputs for Algebraic Geometry. +23. `algebraicGeometryNormalizeAffineVariety(value)` - Normalize a affine variety into the standard Algebraic Geometry representation. +24. `algebraicGeometryCanonicalizeAffineVariety(value)` - Canonicalize a affine variety so equivalent inputs share one form. +25. `algebraicGeometryParseAffineVariety(text)` - Parse a text or structured value into a affine variety. +26. `algebraicGeometryFormatAffineVariety(value)` - Format a affine variety for deterministic user-facing output. +27. `algebraicGeometryCompareAffineVariety(left, right)` - Compare two affine variety values under the conventions of Algebraic Geometry. +28. `algebraicGeometryCombineAffineVariety(left, right)` - Combine two affine variety values with the natural operation for Algebraic Geometry. +29. `algebraicGeometryDecomposeAffineVariety(value)` - Decompose a affine variety into simpler or canonical components. +30. `algebraicGeometryEvaluateAffineVariety(value, point=None)` - Evaluate a affine variety at a point, sample, or finite model. +31. `algebraicGeometryComputeAffineVariety(value)` - Compute the central numerical or symbolic data of a affine variety. +32. `algebraicGeometryEstimateAffineVariety(value, samples=None)` - Estimate a affine variety property from finite samples or approximations. +33. `algebraicGeometryApproximateAffineVariety(value, tolerance=1e-9)` - Approximate a affine variety with explicit tolerance controls. +34. `algebraicGeometryTransformAffineVariety(value, mapping)` - Transform a affine variety through a map, operator, or representation change. +35. `algebraicGeometrySimplifyAffineVariety(value)` - Simplify a affine variety without changing its mathematical meaning. +36. `algebraicGeometryEnumerateAffineVariety(value, limit=None)` - Enumerate finite members, cases, or derived objects for a affine variety. +37. `algebraicGeometryClassifyAffineVariety(value)` - Classify a affine variety by its standard Algebraic Geometry invariants. +38. `algebraicGeometryTestEquivalenceAffineVariety(left, right)` - Test whether two affine variety values are equivalent in Algebraic Geometry. +39. `algebraicGeometryGenerateExampleAffineVariety(size=3)` - Generate a small documented example of a affine variety. +40. `algebraicGeometryDocumentAffineVariety(value)` - Return a structured explanation of a affine variety and related assumptions. +41. `algebraicGeometryValidateIdeal(value)` - Validate the ideal representation and domain rules for Algebraic Geometry. +42. `algebraicGeometryConstructIdeal(*args)` - Construct a ideal from explicit inputs for Algebraic Geometry. +43. `algebraicGeometryNormalizeIdeal(value)` - Normalize a ideal into the standard Algebraic Geometry representation. +44. `algebraicGeometryCanonicalizeIdeal(value)` - Canonicalize a ideal so equivalent inputs share one form. +45. `algebraicGeometryParseIdeal(text)` - Parse a text or structured value into a ideal. +46. `algebraicGeometryFormatIdeal(value)` - Format a ideal for deterministic user-facing output. +47. `algebraicGeometryCompareIdeal(left, right)` - Compare two ideal values under the conventions of Algebraic Geometry. +48. `algebraicGeometryCombineIdeal(left, right)` - Combine two ideal values with the natural operation for Algebraic Geometry. +49. `algebraicGeometryDecomposeIdeal(value)` - Decompose a ideal into simpler or canonical components. +50. `algebraicGeometryEvaluateIdeal(value, point=None)` - Evaluate a ideal at a point, sample, or finite model. +51. `algebraicGeometryComputeIdeal(value)` - Compute the central numerical or symbolic data of a ideal. +52. `algebraicGeometryEstimateIdeal(value, samples=None)` - Estimate a ideal property from finite samples or approximations. +53. `algebraicGeometryApproximateIdeal(value, tolerance=1e-9)` - Approximate a ideal with explicit tolerance controls. +54. `algebraicGeometryTransformIdeal(value, mapping)` - Transform a ideal through a map, operator, or representation change. +55. `algebraicGeometrySimplifyIdeal(value)` - Simplify a ideal without changing its mathematical meaning. +56. `algebraicGeometryEnumerateIdeal(value, limit=None)` - Enumerate finite members, cases, or derived objects for a ideal. +57. `algebraicGeometryClassifyIdeal(value)` - Classify a ideal by its standard Algebraic Geometry invariants. +58. `algebraicGeometryTestEquivalenceIdeal(left, right)` - Test whether two ideal values are equivalent in Algebraic Geometry. +59. `algebraicGeometryGenerateExampleIdeal(size=3)` - Generate a small documented example of a ideal. +60. `algebraicGeometryDocumentIdeal(value)` - Return a structured explanation of a ideal and related assumptions. +61. `algebraicGeometryValidateMonomialOrder(value)` - Validate the monomial order representation and domain rules for Algebraic Geometry. +62. `algebraicGeometryConstructMonomialOrder(*args)` - Construct a monomial order from explicit inputs for Algebraic Geometry. +63. `algebraicGeometryNormalizeMonomialOrder(value)` - Normalize a monomial order into the standard Algebraic Geometry representation. +64. `algebraicGeometryCanonicalizeMonomialOrder(value)` - Canonicalize a monomial order so equivalent inputs share one form. +65. `algebraicGeometryParseMonomialOrder(text)` - Parse a text or structured value into a monomial order. +66. `algebraicGeometryFormatMonomialOrder(value)` - Format a monomial order for deterministic user-facing output. +67. `algebraicGeometryCompareMonomialOrder(left, right)` - Compare two monomial order values under the conventions of Algebraic Geometry. +68. `algebraicGeometryCombineMonomialOrder(left, right)` - Combine two monomial order values with the natural operation for Algebraic Geometry. +69. `algebraicGeometryDecomposeMonomialOrder(value)` - Decompose a monomial order into simpler or canonical components. +70. `algebraicGeometryEvaluateMonomialOrder(value, point=None)` - Evaluate a monomial order at a point, sample, or finite model. +71. `algebraicGeometryComputeMonomialOrder(value)` - Compute the central numerical or symbolic data of a monomial order. +72. `algebraicGeometryEstimateMonomialOrder(value, samples=None)` - Estimate a monomial order property from finite samples or approximations. +73. `algebraicGeometryApproximateMonomialOrder(value, tolerance=1e-9)` - Approximate a monomial order with explicit tolerance controls. +74. `algebraicGeometryTransformMonomialOrder(value, mapping)` - Transform a monomial order through a map, operator, or representation change. +75. `algebraicGeometrySimplifyMonomialOrder(value)` - Simplify a monomial order without changing its mathematical meaning. +76. `algebraicGeometryEnumerateMonomialOrder(value, limit=None)` - Enumerate finite members, cases, or derived objects for a monomial order. +77. `algebraicGeometryClassifyMonomialOrder(value)` - Classify a monomial order by its standard Algebraic Geometry invariants. +78. `algebraicGeometryTestEquivalenceMonomialOrder(left, right)` - Test whether two monomial order values are equivalent in Algebraic Geometry. +79. `algebraicGeometryGenerateExampleMonomialOrder(size=3)` - Generate a small documented example of a monomial order. +80. `algebraicGeometryDocumentMonomialOrder(value)` - Return a structured explanation of a monomial order and related assumptions. +81. `algebraicGeometryValidateCoordinateRing(value)` - Validate the coordinate ring representation and domain rules for Algebraic Geometry. +82. `algebraicGeometryConstructCoordinateRing(*args)` - Construct a coordinate ring from explicit inputs for Algebraic Geometry. +83. `algebraicGeometryNormalizeCoordinateRing(value)` - Normalize a coordinate ring into the standard Algebraic Geometry representation. +84. `algebraicGeometryCanonicalizeCoordinateRing(value)` - Canonicalize a coordinate ring so equivalent inputs share one form. +85. `algebraicGeometryParseCoordinateRing(text)` - Parse a text or structured value into a coordinate ring. +86. `algebraicGeometryFormatCoordinateRing(value)` - Format a coordinate ring for deterministic user-facing output. +87. `algebraicGeometryCompareCoordinateRing(left, right)` - Compare two coordinate ring values under the conventions of Algebraic Geometry. +88. `algebraicGeometryCombineCoordinateRing(left, right)` - Combine two coordinate ring values with the natural operation for Algebraic Geometry. +89. `algebraicGeometryDecomposeCoordinateRing(value)` - Decompose a coordinate ring into simpler or canonical components. +90. `algebraicGeometryEvaluateCoordinateRing(value, point=None)` - Evaluate a coordinate ring at a point, sample, or finite model. +91. `algebraicGeometryComputeCoordinateRing(value)` - Compute the central numerical or symbolic data of a coordinate ring. +92. `algebraicGeometryEstimateCoordinateRing(value, samples=None)` - Estimate a coordinate ring property from finite samples or approximations. +93. `algebraicGeometryApproximateCoordinateRing(value, tolerance=1e-9)` - Approximate a coordinate ring with explicit tolerance controls. +94. `algebraicGeometryTransformCoordinateRing(value, mapping)` - Transform a coordinate ring through a map, operator, or representation change. +95. `algebraicGeometrySimplifyCoordinateRing(value)` - Simplify a coordinate ring without changing its mathematical meaning. +96. `algebraicGeometryEnumerateCoordinateRing(value, limit=None)` - Enumerate finite members, cases, or derived objects for a coordinate ring. +97. `algebraicGeometryClassifyCoordinateRing(value)` - Classify a coordinate ring by its standard Algebraic Geometry invariants. +98. `algebraicGeometryTestEquivalenceCoordinateRing(left, right)` - Test whether two coordinate ring values are equivalent in Algebraic Geometry. +99. `algebraicGeometryGenerateExampleCoordinateRing(size=3)` - Generate a small documented example of a coordinate ring. +100. `algebraicGeometryDocumentCoordinateRing(value)` - Return a structured explanation of a coordinate ring and related assumptions. + +### Arithmetic Geometry + +Core object families: + +- elliptic curve +- finite field point +- rational point +- height function +- curve reduction + +Candidate functions: + +1. `arithmeticGeometryValidateEllipticCurve(value)` - Validate the elliptic curve representation and domain rules for Arithmetic Geometry. +2. `arithmeticGeometryConstructEllipticCurve(*args)` - Construct a elliptic curve from explicit inputs for Arithmetic Geometry. +3. `arithmeticGeometryNormalizeEllipticCurve(value)` - Normalize a elliptic curve into the standard Arithmetic Geometry representation. +4. `arithmeticGeometryCanonicalizeEllipticCurve(value)` - Canonicalize a elliptic curve so equivalent inputs share one form. +5. `arithmeticGeometryParseEllipticCurve(text)` - Parse a text or structured value into a elliptic curve. +6. `arithmeticGeometryFormatEllipticCurve(value)` - Format a elliptic curve for deterministic user-facing output. +7. `arithmeticGeometryCompareEllipticCurve(left, right)` - Compare two elliptic curve values under the conventions of Arithmetic Geometry. +8. `arithmeticGeometryCombineEllipticCurve(left, right)` - Combine two elliptic curve values with the natural operation for Arithmetic Geometry. +9. `arithmeticGeometryDecomposeEllipticCurve(value)` - Decompose a elliptic curve into simpler or canonical components. +10. `arithmeticGeometryEvaluateEllipticCurve(value, point=None)` - Evaluate a elliptic curve at a point, sample, or finite model. +11. `arithmeticGeometryComputeEllipticCurve(value)` - Compute the central numerical or symbolic data of a elliptic curve. +12. `arithmeticGeometryEstimateEllipticCurve(value, samples=None)` - Estimate a elliptic curve property from finite samples or approximations. +13. `arithmeticGeometryApproximateEllipticCurve(value, tolerance=1e-9)` - Approximate a elliptic curve with explicit tolerance controls. +14. `arithmeticGeometryTransformEllipticCurve(value, mapping)` - Transform a elliptic curve through a map, operator, or representation change. +15. `arithmeticGeometrySimplifyEllipticCurve(value)` - Simplify a elliptic curve without changing its mathematical meaning. +16. `arithmeticGeometryEnumerateEllipticCurve(value, limit=None)` - Enumerate finite members, cases, or derived objects for a elliptic curve. +17. `arithmeticGeometryClassifyEllipticCurve(value)` - Classify a elliptic curve by its standard Arithmetic Geometry invariants. +18. `arithmeticGeometryTestEquivalenceEllipticCurve(left, right)` - Test whether two elliptic curve values are equivalent in Arithmetic Geometry. +19. `arithmeticGeometryGenerateExampleEllipticCurve(size=3)` - Generate a small documented example of a elliptic curve. +20. `arithmeticGeometryDocumentEllipticCurve(value)` - Return a structured explanation of a elliptic curve and related assumptions. +21. `arithmeticGeometryValidateFiniteFieldPoint(value)` - Validate the finite field point representation and domain rules for Arithmetic Geometry. +22. `arithmeticGeometryConstructFiniteFieldPoint(*args)` - Construct a finite field point from explicit inputs for Arithmetic Geometry. +23. `arithmeticGeometryNormalizeFiniteFieldPoint(value)` - Normalize a finite field point into the standard Arithmetic Geometry representation. +24. `arithmeticGeometryCanonicalizeFiniteFieldPoint(value)` - Canonicalize a finite field point so equivalent inputs share one form. +25. `arithmeticGeometryParseFiniteFieldPoint(text)` - Parse a text or structured value into a finite field point. +26. `arithmeticGeometryFormatFiniteFieldPoint(value)` - Format a finite field point for deterministic user-facing output. +27. `arithmeticGeometryCompareFiniteFieldPoint(left, right)` - Compare two finite field point values under the conventions of Arithmetic Geometry. +28. `arithmeticGeometryCombineFiniteFieldPoint(left, right)` - Combine two finite field point values with the natural operation for Arithmetic Geometry. +29. `arithmeticGeometryDecomposeFiniteFieldPoint(value)` - Decompose a finite field point into simpler or canonical components. +30. `arithmeticGeometryEvaluateFiniteFieldPoint(value, point=None)` - Evaluate a finite field point at a point, sample, or finite model. +31. `arithmeticGeometryComputeFiniteFieldPoint(value)` - Compute the central numerical or symbolic data of a finite field point. +32. `arithmeticGeometryEstimateFiniteFieldPoint(value, samples=None)` - Estimate a finite field point property from finite samples or approximations. +33. `arithmeticGeometryApproximateFiniteFieldPoint(value, tolerance=1e-9)` - Approximate a finite field point with explicit tolerance controls. +34. `arithmeticGeometryTransformFiniteFieldPoint(value, mapping)` - Transform a finite field point through a map, operator, or representation change. +35. `arithmeticGeometrySimplifyFiniteFieldPoint(value)` - Simplify a finite field point without changing its mathematical meaning. +36. `arithmeticGeometryEnumerateFiniteFieldPoint(value, limit=None)` - Enumerate finite members, cases, or derived objects for a finite field point. +37. `arithmeticGeometryClassifyFiniteFieldPoint(value)` - Classify a finite field point by its standard Arithmetic Geometry invariants. +38. `arithmeticGeometryTestEquivalenceFiniteFieldPoint(left, right)` - Test whether two finite field point values are equivalent in Arithmetic Geometry. +39. `arithmeticGeometryGenerateExampleFiniteFieldPoint(size=3)` - Generate a small documented example of a finite field point. +40. `arithmeticGeometryDocumentFiniteFieldPoint(value)` - Return a structured explanation of a finite field point and related assumptions. +41. `arithmeticGeometryValidateRationalPoint(value)` - Validate the rational point representation and domain rules for Arithmetic Geometry. +42. `arithmeticGeometryConstructRationalPoint(*args)` - Construct a rational point from explicit inputs for Arithmetic Geometry. +43. `arithmeticGeometryNormalizeRationalPoint(value)` - Normalize a rational point into the standard Arithmetic Geometry representation. +44. `arithmeticGeometryCanonicalizeRationalPoint(value)` - Canonicalize a rational point so equivalent inputs share one form. +45. `arithmeticGeometryParseRationalPoint(text)` - Parse a text or structured value into a rational point. +46. `arithmeticGeometryFormatRationalPoint(value)` - Format a rational point for deterministic user-facing output. +47. `arithmeticGeometryCompareRationalPoint(left, right)` - Compare two rational point values under the conventions of Arithmetic Geometry. +48. `arithmeticGeometryCombineRationalPoint(left, right)` - Combine two rational point values with the natural operation for Arithmetic Geometry. +49. `arithmeticGeometryDecomposeRationalPoint(value)` - Decompose a rational point into simpler or canonical components. +50. `arithmeticGeometryEvaluateRationalPoint(value, point=None)` - Evaluate a rational point at a point, sample, or finite model. +51. `arithmeticGeometryComputeRationalPoint(value)` - Compute the central numerical or symbolic data of a rational point. +52. `arithmeticGeometryEstimateRationalPoint(value, samples=None)` - Estimate a rational point property from finite samples or approximations. +53. `arithmeticGeometryApproximateRationalPoint(value, tolerance=1e-9)` - Approximate a rational point with explicit tolerance controls. +54. `arithmeticGeometryTransformRationalPoint(value, mapping)` - Transform a rational point through a map, operator, or representation change. +55. `arithmeticGeometrySimplifyRationalPoint(value)` - Simplify a rational point without changing its mathematical meaning. +56. `arithmeticGeometryEnumerateRationalPoint(value, limit=None)` - Enumerate finite members, cases, or derived objects for a rational point. +57. `arithmeticGeometryClassifyRationalPoint(value)` - Classify a rational point by its standard Arithmetic Geometry invariants. +58. `arithmeticGeometryTestEquivalenceRationalPoint(left, right)` - Test whether two rational point values are equivalent in Arithmetic Geometry. +59. `arithmeticGeometryGenerateExampleRationalPoint(size=3)` - Generate a small documented example of a rational point. +60. `arithmeticGeometryDocumentRationalPoint(value)` - Return a structured explanation of a rational point and related assumptions. +61. `arithmeticGeometryValidateHeightFunction(value)` - Validate the height function representation and domain rules for Arithmetic Geometry. +62. `arithmeticGeometryConstructHeightFunction(*args)` - Construct a height function from explicit inputs for Arithmetic Geometry. +63. `arithmeticGeometryNormalizeHeightFunction(value)` - Normalize a height function into the standard Arithmetic Geometry representation. +64. `arithmeticGeometryCanonicalizeHeightFunction(value)` - Canonicalize a height function so equivalent inputs share one form. +65. `arithmeticGeometryParseHeightFunction(text)` - Parse a text or structured value into a height function. +66. `arithmeticGeometryFormatHeightFunction(value)` - Format a height function for deterministic user-facing output. +67. `arithmeticGeometryCompareHeightFunction(left, right)` - Compare two height function values under the conventions of Arithmetic Geometry. +68. `arithmeticGeometryCombineHeightFunction(left, right)` - Combine two height function values with the natural operation for Arithmetic Geometry. +69. `arithmeticGeometryDecomposeHeightFunction(value)` - Decompose a height function into simpler or canonical components. +70. `arithmeticGeometryEvaluateHeightFunction(value, point=None)` - Evaluate a height function at a point, sample, or finite model. +71. `arithmeticGeometryComputeHeightFunction(value)` - Compute the central numerical or symbolic data of a height function. +72. `arithmeticGeometryEstimateHeightFunction(value, samples=None)` - Estimate a height function property from finite samples or approximations. +73. `arithmeticGeometryApproximateHeightFunction(value, tolerance=1e-9)` - Approximate a height function with explicit tolerance controls. +74. `arithmeticGeometryTransformHeightFunction(value, mapping)` - Transform a height function through a map, operator, or representation change. +75. `arithmeticGeometrySimplifyHeightFunction(value)` - Simplify a height function without changing its mathematical meaning. +76. `arithmeticGeometryEnumerateHeightFunction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a height function. +77. `arithmeticGeometryClassifyHeightFunction(value)` - Classify a height function by its standard Arithmetic Geometry invariants. +78. `arithmeticGeometryTestEquivalenceHeightFunction(left, right)` - Test whether two height function values are equivalent in Arithmetic Geometry. +79. `arithmeticGeometryGenerateExampleHeightFunction(size=3)` - Generate a small documented example of a height function. +80. `arithmeticGeometryDocumentHeightFunction(value)` - Return a structured explanation of a height function and related assumptions. +81. `arithmeticGeometryValidateCurveReduction(value)` - Validate the curve reduction representation and domain rules for Arithmetic Geometry. +82. `arithmeticGeometryConstructCurveReduction(*args)` - Construct a curve reduction from explicit inputs for Arithmetic Geometry. +83. `arithmeticGeometryNormalizeCurveReduction(value)` - Normalize a curve reduction into the standard Arithmetic Geometry representation. +84. `arithmeticGeometryCanonicalizeCurveReduction(value)` - Canonicalize a curve reduction so equivalent inputs share one form. +85. `arithmeticGeometryParseCurveReduction(text)` - Parse a text or structured value into a curve reduction. +86. `arithmeticGeometryFormatCurveReduction(value)` - Format a curve reduction for deterministic user-facing output. +87. `arithmeticGeometryCompareCurveReduction(left, right)` - Compare two curve reduction values under the conventions of Arithmetic Geometry. +88. `arithmeticGeometryCombineCurveReduction(left, right)` - Combine two curve reduction values with the natural operation for Arithmetic Geometry. +89. `arithmeticGeometryDecomposeCurveReduction(value)` - Decompose a curve reduction into simpler or canonical components. +90. `arithmeticGeometryEvaluateCurveReduction(value, point=None)` - Evaluate a curve reduction at a point, sample, or finite model. +91. `arithmeticGeometryComputeCurveReduction(value)` - Compute the central numerical or symbolic data of a curve reduction. +92. `arithmeticGeometryEstimateCurveReduction(value, samples=None)` - Estimate a curve reduction property from finite samples or approximations. +93. `arithmeticGeometryApproximateCurveReduction(value, tolerance=1e-9)` - Approximate a curve reduction with explicit tolerance controls. +94. `arithmeticGeometryTransformCurveReduction(value, mapping)` - Transform a curve reduction through a map, operator, or representation change. +95. `arithmeticGeometrySimplifyCurveReduction(value)` - Simplify a curve reduction without changing its mathematical meaning. +96. `arithmeticGeometryEnumerateCurveReduction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a curve reduction. +97. `arithmeticGeometryClassifyCurveReduction(value)` - Classify a curve reduction by its standard Arithmetic Geometry invariants. +98. `arithmeticGeometryTestEquivalenceCurveReduction(left, right)` - Test whether two curve reduction values are equivalent in Arithmetic Geometry. +99. `arithmeticGeometryGenerateExampleCurveReduction(size=3)` - Generate a small documented example of a curve reduction. +100. `arithmeticGeometryDocumentCurveReduction(value)` - Return a structured explanation of a curve reduction and related assumptions. + +### Algebraic Topology + +Core object families: + +- chain complex +- simplex +- boundary map +- homology group +- betti profile + +Candidate functions: + +1. `algebraicTopologyValidateChainComplex(value)` - Validate the chain complex representation and domain rules for Algebraic Topology. +2. `algebraicTopologyConstructChainComplex(*args)` - Construct a chain complex from explicit inputs for Algebraic Topology. +3. `algebraicTopologyNormalizeChainComplex(value)` - Normalize a chain complex into the standard Algebraic Topology representation. +4. `algebraicTopologyCanonicalizeChainComplex(value)` - Canonicalize a chain complex so equivalent inputs share one form. +5. `algebraicTopologyParseChainComplex(text)` - Parse a text or structured value into a chain complex. +6. `algebraicTopologyFormatChainComplex(value)` - Format a chain complex for deterministic user-facing output. +7. `algebraicTopologyCompareChainComplex(left, right)` - Compare two chain complex values under the conventions of Algebraic Topology. +8. `algebraicTopologyCombineChainComplex(left, right)` - Combine two chain complex values with the natural operation for Algebraic Topology. +9. `algebraicTopologyDecomposeChainComplex(value)` - Decompose a chain complex into simpler or canonical components. +10. `algebraicTopologyEvaluateChainComplex(value, point=None)` - Evaluate a chain complex at a point, sample, or finite model. +11. `algebraicTopologyComputeChainComplex(value)` - Compute the central numerical or symbolic data of a chain complex. +12. `algebraicTopologyEstimateChainComplex(value, samples=None)` - Estimate a chain complex property from finite samples or approximations. +13. `algebraicTopologyApproximateChainComplex(value, tolerance=1e-9)` - Approximate a chain complex with explicit tolerance controls. +14. `algebraicTopologyTransformChainComplex(value, mapping)` - Transform a chain complex through a map, operator, or representation change. +15. `algebraicTopologySimplifyChainComplex(value)` - Simplify a chain complex without changing its mathematical meaning. +16. `algebraicTopologyEnumerateChainComplex(value, limit=None)` - Enumerate finite members, cases, or derived objects for a chain complex. +17. `algebraicTopologyClassifyChainComplex(value)` - Classify a chain complex by its standard Algebraic Topology invariants. +18. `algebraicTopologyTestEquivalenceChainComplex(left, right)` - Test whether two chain complex values are equivalent in Algebraic Topology. +19. `algebraicTopologyGenerateExampleChainComplex(size=3)` - Generate a small documented example of a chain complex. +20. `algebraicTopologyDocumentChainComplex(value)` - Return a structured explanation of a chain complex and related assumptions. +21. `algebraicTopologyValidateSimplex(value)` - Validate the simplex representation and domain rules for Algebraic Topology. +22. `algebraicTopologyConstructSimplex(*args)` - Construct a simplex from explicit inputs for Algebraic Topology. +23. `algebraicTopologyNormalizeSimplex(value)` - Normalize a simplex into the standard Algebraic Topology representation. +24. `algebraicTopologyCanonicalizeSimplex(value)` - Canonicalize a simplex so equivalent inputs share one form. +25. `algebraicTopologyParseSimplex(text)` - Parse a text or structured value into a simplex. +26. `algebraicTopologyFormatSimplex(value)` - Format a simplex for deterministic user-facing output. +27. `algebraicTopologyCompareSimplex(left, right)` - Compare two simplex values under the conventions of Algebraic Topology. +28. `algebraicTopologyCombineSimplex(left, right)` - Combine two simplex values with the natural operation for Algebraic Topology. +29. `algebraicTopologyDecomposeSimplex(value)` - Decompose a simplex into simpler or canonical components. +30. `algebraicTopologyEvaluateSimplex(value, point=None)` - Evaluate a simplex at a point, sample, or finite model. +31. `algebraicTopologyComputeSimplex(value)` - Compute the central numerical or symbolic data of a simplex. +32. `algebraicTopologyEstimateSimplex(value, samples=None)` - Estimate a simplex property from finite samples or approximations. +33. `algebraicTopologyApproximateSimplex(value, tolerance=1e-9)` - Approximate a simplex with explicit tolerance controls. +34. `algebraicTopologyTransformSimplex(value, mapping)` - Transform a simplex through a map, operator, or representation change. +35. `algebraicTopologySimplifySimplex(value)` - Simplify a simplex without changing its mathematical meaning. +36. `algebraicTopologyEnumerateSimplex(value, limit=None)` - Enumerate finite members, cases, or derived objects for a simplex. +37. `algebraicTopologyClassifySimplex(value)` - Classify a simplex by its standard Algebraic Topology invariants. +38. `algebraicTopologyTestEquivalenceSimplex(left, right)` - Test whether two simplex values are equivalent in Algebraic Topology. +39. `algebraicTopologyGenerateExampleSimplex(size=3)` - Generate a small documented example of a simplex. +40. `algebraicTopologyDocumentSimplex(value)` - Return a structured explanation of a simplex and related assumptions. +41. `algebraicTopologyValidateBoundaryMap(value)` - Validate the boundary map representation and domain rules for Algebraic Topology. +42. `algebraicTopologyConstructBoundaryMap(*args)` - Construct a boundary map from explicit inputs for Algebraic Topology. +43. `algebraicTopologyNormalizeBoundaryMap(value)` - Normalize a boundary map into the standard Algebraic Topology representation. +44. `algebraicTopologyCanonicalizeBoundaryMap(value)` - Canonicalize a boundary map so equivalent inputs share one form. +45. `algebraicTopologyParseBoundaryMap(text)` - Parse a text or structured value into a boundary map. +46. `algebraicTopologyFormatBoundaryMap(value)` - Format a boundary map for deterministic user-facing output. +47. `algebraicTopologyCompareBoundaryMap(left, right)` - Compare two boundary map values under the conventions of Algebraic Topology. +48. `algebraicTopologyCombineBoundaryMap(left, right)` - Combine two boundary map values with the natural operation for Algebraic Topology. +49. `algebraicTopologyDecomposeBoundaryMap(value)` - Decompose a boundary map into simpler or canonical components. +50. `algebraicTopologyEvaluateBoundaryMap(value, point=None)` - Evaluate a boundary map at a point, sample, or finite model. +51. `algebraicTopologyComputeBoundaryMap(value)` - Compute the central numerical or symbolic data of a boundary map. +52. `algebraicTopologyEstimateBoundaryMap(value, samples=None)` - Estimate a boundary map property from finite samples or approximations. +53. `algebraicTopologyApproximateBoundaryMap(value, tolerance=1e-9)` - Approximate a boundary map with explicit tolerance controls. +54. `algebraicTopologyTransformBoundaryMap(value, mapping)` - Transform a boundary map through a map, operator, or representation change. +55. `algebraicTopologySimplifyBoundaryMap(value)` - Simplify a boundary map without changing its mathematical meaning. +56. `algebraicTopologyEnumerateBoundaryMap(value, limit=None)` - Enumerate finite members, cases, or derived objects for a boundary map. +57. `algebraicTopologyClassifyBoundaryMap(value)` - Classify a boundary map by its standard Algebraic Topology invariants. +58. `algebraicTopologyTestEquivalenceBoundaryMap(left, right)` - Test whether two boundary map values are equivalent in Algebraic Topology. +59. `algebraicTopologyGenerateExampleBoundaryMap(size=3)` - Generate a small documented example of a boundary map. +60. `algebraicTopologyDocumentBoundaryMap(value)` - Return a structured explanation of a boundary map and related assumptions. +61. `algebraicTopologyValidateHomologyGroup(value)` - Validate the homology group representation and domain rules for Algebraic Topology. +62. `algebraicTopologyConstructHomologyGroup(*args)` - Construct a homology group from explicit inputs for Algebraic Topology. +63. `algebraicTopologyNormalizeHomologyGroup(value)` - Normalize a homology group into the standard Algebraic Topology representation. +64. `algebraicTopologyCanonicalizeHomologyGroup(value)` - Canonicalize a homology group so equivalent inputs share one form. +65. `algebraicTopologyParseHomologyGroup(text)` - Parse a text or structured value into a homology group. +66. `algebraicTopologyFormatHomologyGroup(value)` - Format a homology group for deterministic user-facing output. +67. `algebraicTopologyCompareHomologyGroup(left, right)` - Compare two homology group values under the conventions of Algebraic Topology. +68. `algebraicTopologyCombineHomologyGroup(left, right)` - Combine two homology group values with the natural operation for Algebraic Topology. +69. `algebraicTopologyDecomposeHomologyGroup(value)` - Decompose a homology group into simpler or canonical components. +70. `algebraicTopologyEvaluateHomologyGroup(value, point=None)` - Evaluate a homology group at a point, sample, or finite model. +71. `algebraicTopologyComputeHomologyGroup(value)` - Compute the central numerical or symbolic data of a homology group. +72. `algebraicTopologyEstimateHomologyGroup(value, samples=None)` - Estimate a homology group property from finite samples or approximations. +73. `algebraicTopologyApproximateHomologyGroup(value, tolerance=1e-9)` - Approximate a homology group with explicit tolerance controls. +74. `algebraicTopologyTransformHomologyGroup(value, mapping)` - Transform a homology group through a map, operator, or representation change. +75. `algebraicTopologySimplifyHomologyGroup(value)` - Simplify a homology group without changing its mathematical meaning. +76. `algebraicTopologyEnumerateHomologyGroup(value, limit=None)` - Enumerate finite members, cases, or derived objects for a homology group. +77. `algebraicTopologyClassifyHomologyGroup(value)` - Classify a homology group by its standard Algebraic Topology invariants. +78. `algebraicTopologyTestEquivalenceHomologyGroup(left, right)` - Test whether two homology group values are equivalent in Algebraic Topology. +79. `algebraicTopologyGenerateExampleHomologyGroup(size=3)` - Generate a small documented example of a homology group. +80. `algebraicTopologyDocumentHomologyGroup(value)` - Return a structured explanation of a homology group and related assumptions. +81. `algebraicTopologyValidateBettiProfile(value)` - Validate the betti profile representation and domain rules for Algebraic Topology. +82. `algebraicTopologyConstructBettiProfile(*args)` - Construct a betti profile from explicit inputs for Algebraic Topology. +83. `algebraicTopologyNormalizeBettiProfile(value)` - Normalize a betti profile into the standard Algebraic Topology representation. +84. `algebraicTopologyCanonicalizeBettiProfile(value)` - Canonicalize a betti profile so equivalent inputs share one form. +85. `algebraicTopologyParseBettiProfile(text)` - Parse a text or structured value into a betti profile. +86. `algebraicTopologyFormatBettiProfile(value)` - Format a betti profile for deterministic user-facing output. +87. `algebraicTopologyCompareBettiProfile(left, right)` - Compare two betti profile values under the conventions of Algebraic Topology. +88. `algebraicTopologyCombineBettiProfile(left, right)` - Combine two betti profile values with the natural operation for Algebraic Topology. +89. `algebraicTopologyDecomposeBettiProfile(value)` - Decompose a betti profile into simpler or canonical components. +90. `algebraicTopologyEvaluateBettiProfile(value, point=None)` - Evaluate a betti profile at a point, sample, or finite model. +91. `algebraicTopologyComputeBettiProfile(value)` - Compute the central numerical or symbolic data of a betti profile. +92. `algebraicTopologyEstimateBettiProfile(value, samples=None)` - Estimate a betti profile property from finite samples or approximations. +93. `algebraicTopologyApproximateBettiProfile(value, tolerance=1e-9)` - Approximate a betti profile with explicit tolerance controls. +94. `algebraicTopologyTransformBettiProfile(value, mapping)` - Transform a betti profile through a map, operator, or representation change. +95. `algebraicTopologySimplifyBettiProfile(value)` - Simplify a betti profile without changing its mathematical meaning. +96. `algebraicTopologyEnumerateBettiProfile(value, limit=None)` - Enumerate finite members, cases, or derived objects for a betti profile. +97. `algebraicTopologyClassifyBettiProfile(value)` - Classify a betti profile by its standard Algebraic Topology invariants. +98. `algebraicTopologyTestEquivalenceBettiProfile(left, right)` - Test whether two betti profile values are equivalent in Algebraic Topology. +99. `algebraicTopologyGenerateExampleBettiProfile(size=3)` - Generate a small documented example of a betti profile. +100. `algebraicTopologyDocumentBettiProfile(value)` - Return a structured explanation of a betti profile and related assumptions. + +### Geometric Topology + +Core object families: + +- triangulated surface +- manifold complex +- handle decomposition +- surface invariant +- embedding model + +Candidate functions: + +1. `geometricTopologyValidateTriangulatedSurface(value)` - Validate the triangulated surface representation and domain rules for Geometric Topology. +2. `geometricTopologyConstructTriangulatedSurface(*args)` - Construct a triangulated surface from explicit inputs for Geometric Topology. +3. `geometricTopologyNormalizeTriangulatedSurface(value)` - Normalize a triangulated surface into the standard Geometric Topology representation. +4. `geometricTopologyCanonicalizeTriangulatedSurface(value)` - Canonicalize a triangulated surface so equivalent inputs share one form. +5. `geometricTopologyParseTriangulatedSurface(text)` - Parse a text or structured value into a triangulated surface. +6. `geometricTopologyFormatTriangulatedSurface(value)` - Format a triangulated surface for deterministic user-facing output. +7. `geometricTopologyCompareTriangulatedSurface(left, right)` - Compare two triangulated surface values under the conventions of Geometric Topology. +8. `geometricTopologyCombineTriangulatedSurface(left, right)` - Combine two triangulated surface values with the natural operation for Geometric Topology. +9. `geometricTopologyDecomposeTriangulatedSurface(value)` - Decompose a triangulated surface into simpler or canonical components. +10. `geometricTopologyEvaluateTriangulatedSurface(value, point=None)` - Evaluate a triangulated surface at a point, sample, or finite model. +11. `geometricTopologyComputeTriangulatedSurface(value)` - Compute the central numerical or symbolic data of a triangulated surface. +12. `geometricTopologyEstimateTriangulatedSurface(value, samples=None)` - Estimate a triangulated surface property from finite samples or approximations. +13. `geometricTopologyApproximateTriangulatedSurface(value, tolerance=1e-9)` - Approximate a triangulated surface with explicit tolerance controls. +14. `geometricTopologyTransformTriangulatedSurface(value, mapping)` - Transform a triangulated surface through a map, operator, or representation change. +15. `geometricTopologySimplifyTriangulatedSurface(value)` - Simplify a triangulated surface without changing its mathematical meaning. +16. `geometricTopologyEnumerateTriangulatedSurface(value, limit=None)` - Enumerate finite members, cases, or derived objects for a triangulated surface. +17. `geometricTopologyClassifyTriangulatedSurface(value)` - Classify a triangulated surface by its standard Geometric Topology invariants. +18. `geometricTopologyTestEquivalenceTriangulatedSurface(left, right)` - Test whether two triangulated surface values are equivalent in Geometric Topology. +19. `geometricTopologyGenerateExampleTriangulatedSurface(size=3)` - Generate a small documented example of a triangulated surface. +20. `geometricTopologyDocumentTriangulatedSurface(value)` - Return a structured explanation of a triangulated surface and related assumptions. +21. `geometricTopologyValidateManifoldComplex(value)` - Validate the manifold complex representation and domain rules for Geometric Topology. +22. `geometricTopologyConstructManifoldComplex(*args)` - Construct a manifold complex from explicit inputs for Geometric Topology. +23. `geometricTopologyNormalizeManifoldComplex(value)` - Normalize a manifold complex into the standard Geometric Topology representation. +24. `geometricTopologyCanonicalizeManifoldComplex(value)` - Canonicalize a manifold complex so equivalent inputs share one form. +25. `geometricTopologyParseManifoldComplex(text)` - Parse a text or structured value into a manifold complex. +26. `geometricTopologyFormatManifoldComplex(value)` - Format a manifold complex for deterministic user-facing output. +27. `geometricTopologyCompareManifoldComplex(left, right)` - Compare two manifold complex values under the conventions of Geometric Topology. +28. `geometricTopologyCombineManifoldComplex(left, right)` - Combine two manifold complex values with the natural operation for Geometric Topology. +29. `geometricTopologyDecomposeManifoldComplex(value)` - Decompose a manifold complex into simpler or canonical components. +30. `geometricTopologyEvaluateManifoldComplex(value, point=None)` - Evaluate a manifold complex at a point, sample, or finite model. +31. `geometricTopologyComputeManifoldComplex(value)` - Compute the central numerical or symbolic data of a manifold complex. +32. `geometricTopologyEstimateManifoldComplex(value, samples=None)` - Estimate a manifold complex property from finite samples or approximations. +33. `geometricTopologyApproximateManifoldComplex(value, tolerance=1e-9)` - Approximate a manifold complex with explicit tolerance controls. +34. `geometricTopologyTransformManifoldComplex(value, mapping)` - Transform a manifold complex through a map, operator, or representation change. +35. `geometricTopologySimplifyManifoldComplex(value)` - Simplify a manifold complex without changing its mathematical meaning. +36. `geometricTopologyEnumerateManifoldComplex(value, limit=None)` - Enumerate finite members, cases, or derived objects for a manifold complex. +37. `geometricTopologyClassifyManifoldComplex(value)` - Classify a manifold complex by its standard Geometric Topology invariants. +38. `geometricTopologyTestEquivalenceManifoldComplex(left, right)` - Test whether two manifold complex values are equivalent in Geometric Topology. +39. `geometricTopologyGenerateExampleManifoldComplex(size=3)` - Generate a small documented example of a manifold complex. +40. `geometricTopologyDocumentManifoldComplex(value)` - Return a structured explanation of a manifold complex and related assumptions. +41. `geometricTopologyValidateHandleDecomposition(value)` - Validate the handle decomposition representation and domain rules for Geometric Topology. +42. `geometricTopologyConstructHandleDecomposition(*args)` - Construct a handle decomposition from explicit inputs for Geometric Topology. +43. `geometricTopologyNormalizeHandleDecomposition(value)` - Normalize a handle decomposition into the standard Geometric Topology representation. +44. `geometricTopologyCanonicalizeHandleDecomposition(value)` - Canonicalize a handle decomposition so equivalent inputs share one form. +45. `geometricTopologyParseHandleDecomposition(text)` - Parse a text or structured value into a handle decomposition. +46. `geometricTopologyFormatHandleDecomposition(value)` - Format a handle decomposition for deterministic user-facing output. +47. `geometricTopologyCompareHandleDecomposition(left, right)` - Compare two handle decomposition values under the conventions of Geometric Topology. +48. `geometricTopologyCombineHandleDecomposition(left, right)` - Combine two handle decomposition values with the natural operation for Geometric Topology. +49. `geometricTopologyDecomposeHandleDecomposition(value)` - Decompose a handle decomposition into simpler or canonical components. +50. `geometricTopologyEvaluateHandleDecomposition(value, point=None)` - Evaluate a handle decomposition at a point, sample, or finite model. +51. `geometricTopologyComputeHandleDecomposition(value)` - Compute the central numerical or symbolic data of a handle decomposition. +52. `geometricTopologyEstimateHandleDecomposition(value, samples=None)` - Estimate a handle decomposition property from finite samples or approximations. +53. `geometricTopologyApproximateHandleDecomposition(value, tolerance=1e-9)` - Approximate a handle decomposition with explicit tolerance controls. +54. `geometricTopologyTransformHandleDecomposition(value, mapping)` - Transform a handle decomposition through a map, operator, or representation change. +55. `geometricTopologySimplifyHandleDecomposition(value)` - Simplify a handle decomposition without changing its mathematical meaning. +56. `geometricTopologyEnumerateHandleDecomposition(value, limit=None)` - Enumerate finite members, cases, or derived objects for a handle decomposition. +57. `geometricTopologyClassifyHandleDecomposition(value)` - Classify a handle decomposition by its standard Geometric Topology invariants. +58. `geometricTopologyTestEquivalenceHandleDecomposition(left, right)` - Test whether two handle decomposition values are equivalent in Geometric Topology. +59. `geometricTopologyGenerateExampleHandleDecomposition(size=3)` - Generate a small documented example of a handle decomposition. +60. `geometricTopologyDocumentHandleDecomposition(value)` - Return a structured explanation of a handle decomposition and related assumptions. +61. `geometricTopologyValidateSurfaceInvariant(value)` - Validate the surface invariant representation and domain rules for Geometric Topology. +62. `geometricTopologyConstructSurfaceInvariant(*args)` - Construct a surface invariant from explicit inputs for Geometric Topology. +63. `geometricTopologyNormalizeSurfaceInvariant(value)` - Normalize a surface invariant into the standard Geometric Topology representation. +64. `geometricTopologyCanonicalizeSurfaceInvariant(value)` - Canonicalize a surface invariant so equivalent inputs share one form. +65. `geometricTopologyParseSurfaceInvariant(text)` - Parse a text or structured value into a surface invariant. +66. `geometricTopologyFormatSurfaceInvariant(value)` - Format a surface invariant for deterministic user-facing output. +67. `geometricTopologyCompareSurfaceInvariant(left, right)` - Compare two surface invariant values under the conventions of Geometric Topology. +68. `geometricTopologyCombineSurfaceInvariant(left, right)` - Combine two surface invariant values with the natural operation for Geometric Topology. +69. `geometricTopologyDecomposeSurfaceInvariant(value)` - Decompose a surface invariant into simpler or canonical components. +70. `geometricTopologyEvaluateSurfaceInvariant(value, point=None)` - Evaluate a surface invariant at a point, sample, or finite model. +71. `geometricTopologyComputeSurfaceInvariant(value)` - Compute the central numerical or symbolic data of a surface invariant. +72. `geometricTopologyEstimateSurfaceInvariant(value, samples=None)` - Estimate a surface invariant property from finite samples or approximations. +73. `geometricTopologyApproximateSurfaceInvariant(value, tolerance=1e-9)` - Approximate a surface invariant with explicit tolerance controls. +74. `geometricTopologyTransformSurfaceInvariant(value, mapping)` - Transform a surface invariant through a map, operator, or representation change. +75. `geometricTopologySimplifySurfaceInvariant(value)` - Simplify a surface invariant without changing its mathematical meaning. +76. `geometricTopologyEnumerateSurfaceInvariant(value, limit=None)` - Enumerate finite members, cases, or derived objects for a surface invariant. +77. `geometricTopologyClassifySurfaceInvariant(value)` - Classify a surface invariant by its standard Geometric Topology invariants. +78. `geometricTopologyTestEquivalenceSurfaceInvariant(left, right)` - Test whether two surface invariant values are equivalent in Geometric Topology. +79. `geometricTopologyGenerateExampleSurfaceInvariant(size=3)` - Generate a small documented example of a surface invariant. +80. `geometricTopologyDocumentSurfaceInvariant(value)` - Return a structured explanation of a surface invariant and related assumptions. +81. `geometricTopologyValidateEmbeddingModel(value)` - Validate the embedding model representation and domain rules for Geometric Topology. +82. `geometricTopologyConstructEmbeddingModel(*args)` - Construct a embedding model from explicit inputs for Geometric Topology. +83. `geometricTopologyNormalizeEmbeddingModel(value)` - Normalize a embedding model into the standard Geometric Topology representation. +84. `geometricTopologyCanonicalizeEmbeddingModel(value)` - Canonicalize a embedding model so equivalent inputs share one form. +85. `geometricTopologyParseEmbeddingModel(text)` - Parse a text or structured value into a embedding model. +86. `geometricTopologyFormatEmbeddingModel(value)` - Format a embedding model for deterministic user-facing output. +87. `geometricTopologyCompareEmbeddingModel(left, right)` - Compare two embedding model values under the conventions of Geometric Topology. +88. `geometricTopologyCombineEmbeddingModel(left, right)` - Combine two embedding model values with the natural operation for Geometric Topology. +89. `geometricTopologyDecomposeEmbeddingModel(value)` - Decompose a embedding model into simpler or canonical components. +90. `geometricTopologyEvaluateEmbeddingModel(value, point=None)` - Evaluate a embedding model at a point, sample, or finite model. +91. `geometricTopologyComputeEmbeddingModel(value)` - Compute the central numerical or symbolic data of a embedding model. +92. `geometricTopologyEstimateEmbeddingModel(value, samples=None)` - Estimate a embedding model property from finite samples or approximations. +93. `geometricTopologyApproximateEmbeddingModel(value, tolerance=1e-9)` - Approximate a embedding model with explicit tolerance controls. +94. `geometricTopologyTransformEmbeddingModel(value, mapping)` - Transform a embedding model through a map, operator, or representation change. +95. `geometricTopologySimplifyEmbeddingModel(value)` - Simplify a embedding model without changing its mathematical meaning. +96. `geometricTopologyEnumerateEmbeddingModel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a embedding model. +97. `geometricTopologyClassifyEmbeddingModel(value)` - Classify a embedding model by its standard Geometric Topology invariants. +98. `geometricTopologyTestEquivalenceEmbeddingModel(left, right)` - Test whether two embedding model values are equivalent in Geometric Topology. +99. `geometricTopologyGenerateExampleEmbeddingModel(size=3)` - Generate a small documented example of a embedding model. +100. `geometricTopologyDocumentEmbeddingModel(value)` - Return a structured explanation of a embedding model and related assumptions. + +### Differential Topology + +Core object families: + +- smooth map +- critical point +- regular value +- diffeomorphism +- transversality sample + +Candidate functions: + +1. `differentialTopologyValidateSmoothMap(value)` - Validate the smooth map representation and domain rules for Differential Topology. +2. `differentialTopologyConstructSmoothMap(*args)` - Construct a smooth map from explicit inputs for Differential Topology. +3. `differentialTopologyNormalizeSmoothMap(value)` - Normalize a smooth map into the standard Differential Topology representation. +4. `differentialTopologyCanonicalizeSmoothMap(value)` - Canonicalize a smooth map so equivalent inputs share one form. +5. `differentialTopologyParseSmoothMap(text)` - Parse a text or structured value into a smooth map. +6. `differentialTopologyFormatSmoothMap(value)` - Format a smooth map for deterministic user-facing output. +7. `differentialTopologyCompareSmoothMap(left, right)` - Compare two smooth map values under the conventions of Differential Topology. +8. `differentialTopologyCombineSmoothMap(left, right)` - Combine two smooth map values with the natural operation for Differential Topology. +9. `differentialTopologyDecomposeSmoothMap(value)` - Decompose a smooth map into simpler or canonical components. +10. `differentialTopologyEvaluateSmoothMap(value, point=None)` - Evaluate a smooth map at a point, sample, or finite model. +11. `differentialTopologyComputeSmoothMap(value)` - Compute the central numerical or symbolic data of a smooth map. +12. `differentialTopologyEstimateSmoothMap(value, samples=None)` - Estimate a smooth map property from finite samples or approximations. +13. `differentialTopologyApproximateSmoothMap(value, tolerance=1e-9)` - Approximate a smooth map with explicit tolerance controls. +14. `differentialTopologyTransformSmoothMap(value, mapping)` - Transform a smooth map through a map, operator, or representation change. +15. `differentialTopologySimplifySmoothMap(value)` - Simplify a smooth map without changing its mathematical meaning. +16. `differentialTopologyEnumerateSmoothMap(value, limit=None)` - Enumerate finite members, cases, or derived objects for a smooth map. +17. `differentialTopologyClassifySmoothMap(value)` - Classify a smooth map by its standard Differential Topology invariants. +18. `differentialTopologyTestEquivalenceSmoothMap(left, right)` - Test whether two smooth map values are equivalent in Differential Topology. +19. `differentialTopologyGenerateExampleSmoothMap(size=3)` - Generate a small documented example of a smooth map. +20. `differentialTopologyDocumentSmoothMap(value)` - Return a structured explanation of a smooth map and related assumptions. +21. `differentialTopologyValidateCriticalPoint(value)` - Validate the critical point representation and domain rules for Differential Topology. +22. `differentialTopologyConstructCriticalPoint(*args)` - Construct a critical point from explicit inputs for Differential Topology. +23. `differentialTopologyNormalizeCriticalPoint(value)` - Normalize a critical point into the standard Differential Topology representation. +24. `differentialTopologyCanonicalizeCriticalPoint(value)` - Canonicalize a critical point so equivalent inputs share one form. +25. `differentialTopologyParseCriticalPoint(text)` - Parse a text or structured value into a critical point. +26. `differentialTopologyFormatCriticalPoint(value)` - Format a critical point for deterministic user-facing output. +27. `differentialTopologyCompareCriticalPoint(left, right)` - Compare two critical point values under the conventions of Differential Topology. +28. `differentialTopologyCombineCriticalPoint(left, right)` - Combine two critical point values with the natural operation for Differential Topology. +29. `differentialTopologyDecomposeCriticalPoint(value)` - Decompose a critical point into simpler or canonical components. +30. `differentialTopologyEvaluateCriticalPoint(value, point=None)` - Evaluate a critical point at a point, sample, or finite model. +31. `differentialTopologyComputeCriticalPoint(value)` - Compute the central numerical or symbolic data of a critical point. +32. `differentialTopologyEstimateCriticalPoint(value, samples=None)` - Estimate a critical point property from finite samples or approximations. +33. `differentialTopologyApproximateCriticalPoint(value, tolerance=1e-9)` - Approximate a critical point with explicit tolerance controls. +34. `differentialTopologyTransformCriticalPoint(value, mapping)` - Transform a critical point through a map, operator, or representation change. +35. `differentialTopologySimplifyCriticalPoint(value)` - Simplify a critical point without changing its mathematical meaning. +36. `differentialTopologyEnumerateCriticalPoint(value, limit=None)` - Enumerate finite members, cases, or derived objects for a critical point. +37. `differentialTopologyClassifyCriticalPoint(value)` - Classify a critical point by its standard Differential Topology invariants. +38. `differentialTopologyTestEquivalenceCriticalPoint(left, right)` - Test whether two critical point values are equivalent in Differential Topology. +39. `differentialTopologyGenerateExampleCriticalPoint(size=3)` - Generate a small documented example of a critical point. +40. `differentialTopologyDocumentCriticalPoint(value)` - Return a structured explanation of a critical point and related assumptions. +41. `differentialTopologyValidateRegularValue(value)` - Validate the regular value representation and domain rules for Differential Topology. +42. `differentialTopologyConstructRegularValue(*args)` - Construct a regular value from explicit inputs for Differential Topology. +43. `differentialTopologyNormalizeRegularValue(value)` - Normalize a regular value into the standard Differential Topology representation. +44. `differentialTopologyCanonicalizeRegularValue(value)` - Canonicalize a regular value so equivalent inputs share one form. +45. `differentialTopologyParseRegularValue(text)` - Parse a text or structured value into a regular value. +46. `differentialTopologyFormatRegularValue(value)` - Format a regular value for deterministic user-facing output. +47. `differentialTopologyCompareRegularValue(left, right)` - Compare two regular value values under the conventions of Differential Topology. +48. `differentialTopologyCombineRegularValue(left, right)` - Combine two regular value values with the natural operation for Differential Topology. +49. `differentialTopologyDecomposeRegularValue(value)` - Decompose a regular value into simpler or canonical components. +50. `differentialTopologyEvaluateRegularValue(value, point=None)` - Evaluate a regular value at a point, sample, or finite model. +51. `differentialTopologyComputeRegularValue(value)` - Compute the central numerical or symbolic data of a regular value. +52. `differentialTopologyEstimateRegularValue(value, samples=None)` - Estimate a regular value property from finite samples or approximations. +53. `differentialTopologyApproximateRegularValue(value, tolerance=1e-9)` - Approximate a regular value with explicit tolerance controls. +54. `differentialTopologyTransformRegularValue(value, mapping)` - Transform a regular value through a map, operator, or representation change. +55. `differentialTopologySimplifyRegularValue(value)` - Simplify a regular value without changing its mathematical meaning. +56. `differentialTopologyEnumerateRegularValue(value, limit=None)` - Enumerate finite members, cases, or derived objects for a regular value. +57. `differentialTopologyClassifyRegularValue(value)` - Classify a regular value by its standard Differential Topology invariants. +58. `differentialTopologyTestEquivalenceRegularValue(left, right)` - Test whether two regular value values are equivalent in Differential Topology. +59. `differentialTopologyGenerateExampleRegularValue(size=3)` - Generate a small documented example of a regular value. +60. `differentialTopologyDocumentRegularValue(value)` - Return a structured explanation of a regular value and related assumptions. +61. `differentialTopologyValidateDiffeomorphism(value)` - Validate the diffeomorphism representation and domain rules for Differential Topology. +62. `differentialTopologyConstructDiffeomorphism(*args)` - Construct a diffeomorphism from explicit inputs for Differential Topology. +63. `differentialTopologyNormalizeDiffeomorphism(value)` - Normalize a diffeomorphism into the standard Differential Topology representation. +64. `differentialTopologyCanonicalizeDiffeomorphism(value)` - Canonicalize a diffeomorphism so equivalent inputs share one form. +65. `differentialTopologyParseDiffeomorphism(text)` - Parse a text or structured value into a diffeomorphism. +66. `differentialTopologyFormatDiffeomorphism(value)` - Format a diffeomorphism for deterministic user-facing output. +67. `differentialTopologyCompareDiffeomorphism(left, right)` - Compare two diffeomorphism values under the conventions of Differential Topology. +68. `differentialTopologyCombineDiffeomorphism(left, right)` - Combine two diffeomorphism values with the natural operation for Differential Topology. +69. `differentialTopologyDecomposeDiffeomorphism(value)` - Decompose a diffeomorphism into simpler or canonical components. +70. `differentialTopologyEvaluateDiffeomorphism(value, point=None)` - Evaluate a diffeomorphism at a point, sample, or finite model. +71. `differentialTopologyComputeDiffeomorphism(value)` - Compute the central numerical or symbolic data of a diffeomorphism. +72. `differentialTopologyEstimateDiffeomorphism(value, samples=None)` - Estimate a diffeomorphism property from finite samples or approximations. +73. `differentialTopologyApproximateDiffeomorphism(value, tolerance=1e-9)` - Approximate a diffeomorphism with explicit tolerance controls. +74. `differentialTopologyTransformDiffeomorphism(value, mapping)` - Transform a diffeomorphism through a map, operator, or representation change. +75. `differentialTopologySimplifyDiffeomorphism(value)` - Simplify a diffeomorphism without changing its mathematical meaning. +76. `differentialTopologyEnumerateDiffeomorphism(value, limit=None)` - Enumerate finite members, cases, or derived objects for a diffeomorphism. +77. `differentialTopologyClassifyDiffeomorphism(value)` - Classify a diffeomorphism by its standard Differential Topology invariants. +78. `differentialTopologyTestEquivalenceDiffeomorphism(left, right)` - Test whether two diffeomorphism values are equivalent in Differential Topology. +79. `differentialTopologyGenerateExampleDiffeomorphism(size=3)` - Generate a small documented example of a diffeomorphism. +80. `differentialTopologyDocumentDiffeomorphism(value)` - Return a structured explanation of a diffeomorphism and related assumptions. +81. `differentialTopologyValidateTransversalitySample(value)` - Validate the transversality sample representation and domain rules for Differential Topology. +82. `differentialTopologyConstructTransversalitySample(*args)` - Construct a transversality sample from explicit inputs for Differential Topology. +83. `differentialTopologyNormalizeTransversalitySample(value)` - Normalize a transversality sample into the standard Differential Topology representation. +84. `differentialTopologyCanonicalizeTransversalitySample(value)` - Canonicalize a transversality sample so equivalent inputs share one form. +85. `differentialTopologyParseTransversalitySample(text)` - Parse a text or structured value into a transversality sample. +86. `differentialTopologyFormatTransversalitySample(value)` - Format a transversality sample for deterministic user-facing output. +87. `differentialTopologyCompareTransversalitySample(left, right)` - Compare two transversality sample values under the conventions of Differential Topology. +88. `differentialTopologyCombineTransversalitySample(left, right)` - Combine two transversality sample values with the natural operation for Differential Topology. +89. `differentialTopologyDecomposeTransversalitySample(value)` - Decompose a transversality sample into simpler or canonical components. +90. `differentialTopologyEvaluateTransversalitySample(value, point=None)` - Evaluate a transversality sample at a point, sample, or finite model. +91. `differentialTopologyComputeTransversalitySample(value)` - Compute the central numerical or symbolic data of a transversality sample. +92. `differentialTopologyEstimateTransversalitySample(value, samples=None)` - Estimate a transversality sample property from finite samples or approximations. +93. `differentialTopologyApproximateTransversalitySample(value, tolerance=1e-9)` - Approximate a transversality sample with explicit tolerance controls. +94. `differentialTopologyTransformTransversalitySample(value, mapping)` - Transform a transversality sample through a map, operator, or representation change. +95. `differentialTopologySimplifyTransversalitySample(value)` - Simplify a transversality sample without changing its mathematical meaning. +96. `differentialTopologyEnumerateTransversalitySample(value, limit=None)` - Enumerate finite members, cases, or derived objects for a transversality sample. +97. `differentialTopologyClassifyTransversalitySample(value)` - Classify a transversality sample by its standard Differential Topology invariants. +98. `differentialTopologyTestEquivalenceTransversalitySample(left, right)` - Test whether two transversality sample values are equivalent in Differential Topology. +99. `differentialTopologyGenerateExampleTransversalitySample(size=3)` - Generate a small documented example of a transversality sample. +100. `differentialTopologyDocumentTransversalitySample(value)` - Return a structured explanation of a transversality sample and related assumptions. + +### Lie Theory + +Core object families: + +- Lie group +- Lie algebra +- bracket +- exponential map +- representation + +Candidate functions: + +1. `lieTheoryValidateLieGroup(value)` - Validate the Lie group representation and domain rules for Lie Theory. +2. `lieTheoryConstructLieGroup(*args)` - Construct a Lie group from explicit inputs for Lie Theory. +3. `lieTheoryNormalizeLieGroup(value)` - Normalize a Lie group into the standard Lie Theory representation. +4. `lieTheoryCanonicalizeLieGroup(value)` - Canonicalize a Lie group so equivalent inputs share one form. +5. `lieTheoryParseLieGroup(text)` - Parse a text or structured value into a Lie group. +6. `lieTheoryFormatLieGroup(value)` - Format a Lie group for deterministic user-facing output. +7. `lieTheoryCompareLieGroup(left, right)` - Compare two Lie group values under the conventions of Lie Theory. +8. `lieTheoryCombineLieGroup(left, right)` - Combine two Lie group values with the natural operation for Lie Theory. +9. `lieTheoryDecomposeLieGroup(value)` - Decompose a Lie group into simpler or canonical components. +10. `lieTheoryEvaluateLieGroup(value, point=None)` - Evaluate a Lie group at a point, sample, or finite model. +11. `lieTheoryComputeLieGroup(value)` - Compute the central numerical or symbolic data of a Lie group. +12. `lieTheoryEstimateLieGroup(value, samples=None)` - Estimate a Lie group property from finite samples or approximations. +13. `lieTheoryApproximateLieGroup(value, tolerance=1e-9)` - Approximate a Lie group with explicit tolerance controls. +14. `lieTheoryTransformLieGroup(value, mapping)` - Transform a Lie group through a map, operator, or representation change. +15. `lieTheorySimplifyLieGroup(value)` - Simplify a Lie group without changing its mathematical meaning. +16. `lieTheoryEnumerateLieGroup(value, limit=None)` - Enumerate finite members, cases, or derived objects for a Lie group. +17. `lieTheoryClassifyLieGroup(value)` - Classify a Lie group by its standard Lie Theory invariants. +18. `lieTheoryTestEquivalenceLieGroup(left, right)` - Test whether two Lie group values are equivalent in Lie Theory. +19. `lieTheoryGenerateExampleLieGroup(size=3)` - Generate a small documented example of a Lie group. +20. `lieTheoryDocumentLieGroup(value)` - Return a structured explanation of a Lie group and related assumptions. +21. `lieTheoryValidateLieAlgebra(value)` - Validate the Lie algebra representation and domain rules for Lie Theory. +22. `lieTheoryConstructLieAlgebra(*args)` - Construct a Lie algebra from explicit inputs for Lie Theory. +23. `lieTheoryNormalizeLieAlgebra(value)` - Normalize a Lie algebra into the standard Lie Theory representation. +24. `lieTheoryCanonicalizeLieAlgebra(value)` - Canonicalize a Lie algebra so equivalent inputs share one form. +25. `lieTheoryParseLieAlgebra(text)` - Parse a text or structured value into a Lie algebra. +26. `lieTheoryFormatLieAlgebra(value)` - Format a Lie algebra for deterministic user-facing output. +27. `lieTheoryCompareLieAlgebra(left, right)` - Compare two Lie algebra values under the conventions of Lie Theory. +28. `lieTheoryCombineLieAlgebra(left, right)` - Combine two Lie algebra values with the natural operation for Lie Theory. +29. `lieTheoryDecomposeLieAlgebra(value)` - Decompose a Lie algebra into simpler or canonical components. +30. `lieTheoryEvaluateLieAlgebra(value, point=None)` - Evaluate a Lie algebra at a point, sample, or finite model. +31. `lieTheoryComputeLieAlgebra(value)` - Compute the central numerical or symbolic data of a Lie algebra. +32. `lieTheoryEstimateLieAlgebra(value, samples=None)` - Estimate a Lie algebra property from finite samples or approximations. +33. `lieTheoryApproximateLieAlgebra(value, tolerance=1e-9)` - Approximate a Lie algebra with explicit tolerance controls. +34. `lieTheoryTransformLieAlgebra(value, mapping)` - Transform a Lie algebra through a map, operator, or representation change. +35. `lieTheorySimplifyLieAlgebra(value)` - Simplify a Lie algebra without changing its mathematical meaning. +36. `lieTheoryEnumerateLieAlgebra(value, limit=None)` - Enumerate finite members, cases, or derived objects for a Lie algebra. +37. `lieTheoryClassifyLieAlgebra(value)` - Classify a Lie algebra by its standard Lie Theory invariants. +38. `lieTheoryTestEquivalenceLieAlgebra(left, right)` - Test whether two Lie algebra values are equivalent in Lie Theory. +39. `lieTheoryGenerateExampleLieAlgebra(size=3)` - Generate a small documented example of a Lie algebra. +40. `lieTheoryDocumentLieAlgebra(value)` - Return a structured explanation of a Lie algebra and related assumptions. +41. `lieTheoryValidateBracket(value)` - Validate the bracket representation and domain rules for Lie Theory. +42. `lieTheoryConstructBracket(*args)` - Construct a bracket from explicit inputs for Lie Theory. +43. `lieTheoryNormalizeBracket(value)` - Normalize a bracket into the standard Lie Theory representation. +44. `lieTheoryCanonicalizeBracket(value)` - Canonicalize a bracket so equivalent inputs share one form. +45. `lieTheoryParseBracket(text)` - Parse a text or structured value into a bracket. +46. `lieTheoryFormatBracket(value)` - Format a bracket for deterministic user-facing output. +47. `lieTheoryCompareBracket(left, right)` - Compare two bracket values under the conventions of Lie Theory. +48. `lieTheoryCombineBracket(left, right)` - Combine two bracket values with the natural operation for Lie Theory. +49. `lieTheoryDecomposeBracket(value)` - Decompose a bracket into simpler or canonical components. +50. `lieTheoryEvaluateBracket(value, point=None)` - Evaluate a bracket at a point, sample, or finite model. +51. `lieTheoryComputeBracket(value)` - Compute the central numerical or symbolic data of a bracket. +52. `lieTheoryEstimateBracket(value, samples=None)` - Estimate a bracket property from finite samples or approximations. +53. `lieTheoryApproximateBracket(value, tolerance=1e-9)` - Approximate a bracket with explicit tolerance controls. +54. `lieTheoryTransformBracket(value, mapping)` - Transform a bracket through a map, operator, or representation change. +55. `lieTheorySimplifyBracket(value)` - Simplify a bracket without changing its mathematical meaning. +56. `lieTheoryEnumerateBracket(value, limit=None)` - Enumerate finite members, cases, or derived objects for a bracket. +57. `lieTheoryClassifyBracket(value)` - Classify a bracket by its standard Lie Theory invariants. +58. `lieTheoryTestEquivalenceBracket(left, right)` - Test whether two bracket values are equivalent in Lie Theory. +59. `lieTheoryGenerateExampleBracket(size=3)` - Generate a small documented example of a bracket. +60. `lieTheoryDocumentBracket(value)` - Return a structured explanation of a bracket and related assumptions. +61. `lieTheoryValidateExponentialMap(value)` - Validate the exponential map representation and domain rules for Lie Theory. +62. `lieTheoryConstructExponentialMap(*args)` - Construct a exponential map from explicit inputs for Lie Theory. +63. `lieTheoryNormalizeExponentialMap(value)` - Normalize a exponential map into the standard Lie Theory representation. +64. `lieTheoryCanonicalizeExponentialMap(value)` - Canonicalize a exponential map so equivalent inputs share one form. +65. `lieTheoryParseExponentialMap(text)` - Parse a text or structured value into a exponential map. +66. `lieTheoryFormatExponentialMap(value)` - Format a exponential map for deterministic user-facing output. +67. `lieTheoryCompareExponentialMap(left, right)` - Compare two exponential map values under the conventions of Lie Theory. +68. `lieTheoryCombineExponentialMap(left, right)` - Combine two exponential map values with the natural operation for Lie Theory. +69. `lieTheoryDecomposeExponentialMap(value)` - Decompose a exponential map into simpler or canonical components. +70. `lieTheoryEvaluateExponentialMap(value, point=None)` - Evaluate a exponential map at a point, sample, or finite model. +71. `lieTheoryComputeExponentialMap(value)` - Compute the central numerical or symbolic data of a exponential map. +72. `lieTheoryEstimateExponentialMap(value, samples=None)` - Estimate a exponential map property from finite samples or approximations. +73. `lieTheoryApproximateExponentialMap(value, tolerance=1e-9)` - Approximate a exponential map with explicit tolerance controls. +74. `lieTheoryTransformExponentialMap(value, mapping)` - Transform a exponential map through a map, operator, or representation change. +75. `lieTheorySimplifyExponentialMap(value)` - Simplify a exponential map without changing its mathematical meaning. +76. `lieTheoryEnumerateExponentialMap(value, limit=None)` - Enumerate finite members, cases, or derived objects for a exponential map. +77. `lieTheoryClassifyExponentialMap(value)` - Classify a exponential map by its standard Lie Theory invariants. +78. `lieTheoryTestEquivalenceExponentialMap(left, right)` - Test whether two exponential map values are equivalent in Lie Theory. +79. `lieTheoryGenerateExampleExponentialMap(size=3)` - Generate a small documented example of a exponential map. +80. `lieTheoryDocumentExponentialMap(value)` - Return a structured explanation of a exponential map and related assumptions. +81. `lieTheoryValidateRepresentation(value)` - Validate the representation representation and domain rules for Lie Theory. +82. `lieTheoryConstructRepresentation(*args)` - Construct a representation from explicit inputs for Lie Theory. +83. `lieTheoryNormalizeRepresentation(value)` - Normalize a representation into the standard Lie Theory representation. +84. `lieTheoryCanonicalizeRepresentation(value)` - Canonicalize a representation so equivalent inputs share one form. +85. `lieTheoryParseRepresentation(text)` - Parse a text or structured value into a representation. +86. `lieTheoryFormatRepresentation(value)` - Format a representation for deterministic user-facing output. +87. `lieTheoryCompareRepresentation(left, right)` - Compare two representation values under the conventions of Lie Theory. +88. `lieTheoryCombineRepresentation(left, right)` - Combine two representation values with the natural operation for Lie Theory. +89. `lieTheoryDecomposeRepresentation(value)` - Decompose a representation into simpler or canonical components. +90. `lieTheoryEvaluateRepresentation(value, point=None)` - Evaluate a representation at a point, sample, or finite model. +91. `lieTheoryComputeRepresentation(value)` - Compute the central numerical or symbolic data of a representation. +92. `lieTheoryEstimateRepresentation(value, samples=None)` - Estimate a representation property from finite samples or approximations. +93. `lieTheoryApproximateRepresentation(value, tolerance=1e-9)` - Approximate a representation with explicit tolerance controls. +94. `lieTheoryTransformRepresentation(value, mapping)` - Transform a representation through a map, operator, or representation change. +95. `lieTheorySimplifyRepresentation(value)` - Simplify a representation without changing its mathematical meaning. +96. `lieTheoryEnumerateRepresentation(value, limit=None)` - Enumerate finite members, cases, or derived objects for a representation. +97. `lieTheoryClassifyRepresentation(value)` - Classify a representation by its standard Lie Theory invariants. +98. `lieTheoryTestEquivalenceRepresentation(left, right)` - Test whether two representation values are equivalent in Lie Theory. +99. `lieTheoryGenerateExampleRepresentation(size=3)` - Generate a small documented example of a representation. +100. `lieTheoryDocumentRepresentation(value)` - Return a structured explanation of a representation and related assumptions. + +### Representation Theory + +Core object families: + +- group action +- representation +- character +- module +- invariant subspace + +Candidate functions: + +1. `representationTheoryValidateGroupAction(value)` - Validate the group action representation and domain rules for Representation Theory. +2. `representationTheoryConstructGroupAction(*args)` - Construct a group action from explicit inputs for Representation Theory. +3. `representationTheoryNormalizeGroupAction(value)` - Normalize a group action into the standard Representation Theory representation. +4. `representationTheoryCanonicalizeGroupAction(value)` - Canonicalize a group action so equivalent inputs share one form. +5. `representationTheoryParseGroupAction(text)` - Parse a text or structured value into a group action. +6. `representationTheoryFormatGroupAction(value)` - Format a group action for deterministic user-facing output. +7. `representationTheoryCompareGroupAction(left, right)` - Compare two group action values under the conventions of Representation Theory. +8. `representationTheoryCombineGroupAction(left, right)` - Combine two group action values with the natural operation for Representation Theory. +9. `representationTheoryDecomposeGroupAction(value)` - Decompose a group action into simpler or canonical components. +10. `representationTheoryEvaluateGroupAction(value, point=None)` - Evaluate a group action at a point, sample, or finite model. +11. `representationTheoryComputeGroupAction(value)` - Compute the central numerical or symbolic data of a group action. +12. `representationTheoryEstimateGroupAction(value, samples=None)` - Estimate a group action property from finite samples or approximations. +13. `representationTheoryApproximateGroupAction(value, tolerance=1e-9)` - Approximate a group action with explicit tolerance controls. +14. `representationTheoryTransformGroupAction(value, mapping)` - Transform a group action through a map, operator, or representation change. +15. `representationTheorySimplifyGroupAction(value)` - Simplify a group action without changing its mathematical meaning. +16. `representationTheoryEnumerateGroupAction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a group action. +17. `representationTheoryClassifyGroupAction(value)` - Classify a group action by its standard Representation Theory invariants. +18. `representationTheoryTestEquivalenceGroupAction(left, right)` - Test whether two group action values are equivalent in Representation Theory. +19. `representationTheoryGenerateExampleGroupAction(size=3)` - Generate a small documented example of a group action. +20. `representationTheoryDocumentGroupAction(value)` - Return a structured explanation of a group action and related assumptions. +21. `representationTheoryValidateRepresentation(value)` - Validate the representation representation and domain rules for Representation Theory. +22. `representationTheoryConstructRepresentation(*args)` - Construct a representation from explicit inputs for Representation Theory. +23. `representationTheoryNormalizeRepresentation(value)` - Normalize a representation into the standard Representation Theory representation. +24. `representationTheoryCanonicalizeRepresentation(value)` - Canonicalize a representation so equivalent inputs share one form. +25. `representationTheoryParseRepresentation(text)` - Parse a text or structured value into a representation. +26. `representationTheoryFormatRepresentation(value)` - Format a representation for deterministic user-facing output. +27. `representationTheoryCompareRepresentation(left, right)` - Compare two representation values under the conventions of Representation Theory. +28. `representationTheoryCombineRepresentation(left, right)` - Combine two representation values with the natural operation for Representation Theory. +29. `representationTheoryDecomposeRepresentation(value)` - Decompose a representation into simpler or canonical components. +30. `representationTheoryEvaluateRepresentation(value, point=None)` - Evaluate a representation at a point, sample, or finite model. +31. `representationTheoryComputeRepresentation(value)` - Compute the central numerical or symbolic data of a representation. +32. `representationTheoryEstimateRepresentation(value, samples=None)` - Estimate a representation property from finite samples or approximations. +33. `representationTheoryApproximateRepresentation(value, tolerance=1e-9)` - Approximate a representation with explicit tolerance controls. +34. `representationTheoryTransformRepresentation(value, mapping)` - Transform a representation through a map, operator, or representation change. +35. `representationTheorySimplifyRepresentation(value)` - Simplify a representation without changing its mathematical meaning. +36. `representationTheoryEnumerateRepresentation(value, limit=None)` - Enumerate finite members, cases, or derived objects for a representation. +37. `representationTheoryClassifyRepresentation(value)` - Classify a representation by its standard Representation Theory invariants. +38. `representationTheoryTestEquivalenceRepresentation(left, right)` - Test whether two representation values are equivalent in Representation Theory. +39. `representationTheoryGenerateExampleRepresentation(size=3)` - Generate a small documented example of a representation. +40. `representationTheoryDocumentRepresentation(value)` - Return a structured explanation of a representation and related assumptions. +41. `representationTheoryValidateCharacter(value)` - Validate the character representation and domain rules for Representation Theory. +42. `representationTheoryConstructCharacter(*args)` - Construct a character from explicit inputs for Representation Theory. +43. `representationTheoryNormalizeCharacter(value)` - Normalize a character into the standard Representation Theory representation. +44. `representationTheoryCanonicalizeCharacter(value)` - Canonicalize a character so equivalent inputs share one form. +45. `representationTheoryParseCharacter(text)` - Parse a text or structured value into a character. +46. `representationTheoryFormatCharacter(value)` - Format a character for deterministic user-facing output. +47. `representationTheoryCompareCharacter(left, right)` - Compare two character values under the conventions of Representation Theory. +48. `representationTheoryCombineCharacter(left, right)` - Combine two character values with the natural operation for Representation Theory. +49. `representationTheoryDecomposeCharacter(value)` - Decompose a character into simpler or canonical components. +50. `representationTheoryEvaluateCharacter(value, point=None)` - Evaluate a character at a point, sample, or finite model. +51. `representationTheoryComputeCharacter(value)` - Compute the central numerical or symbolic data of a character. +52. `representationTheoryEstimateCharacter(value, samples=None)` - Estimate a character property from finite samples or approximations. +53. `representationTheoryApproximateCharacter(value, tolerance=1e-9)` - Approximate a character with explicit tolerance controls. +54. `representationTheoryTransformCharacter(value, mapping)` - Transform a character through a map, operator, or representation change. +55. `representationTheorySimplifyCharacter(value)` - Simplify a character without changing its mathematical meaning. +56. `representationTheoryEnumerateCharacter(value, limit=None)` - Enumerate finite members, cases, or derived objects for a character. +57. `representationTheoryClassifyCharacter(value)` - Classify a character by its standard Representation Theory invariants. +58. `representationTheoryTestEquivalenceCharacter(left, right)` - Test whether two character values are equivalent in Representation Theory. +59. `representationTheoryGenerateExampleCharacter(size=3)` - Generate a small documented example of a character. +60. `representationTheoryDocumentCharacter(value)` - Return a structured explanation of a character and related assumptions. +61. `representationTheoryValidateModule(value)` - Validate the module representation and domain rules for Representation Theory. +62. `representationTheoryConstructModule(*args)` - Construct a module from explicit inputs for Representation Theory. +63. `representationTheoryNormalizeModule(value)` - Normalize a module into the standard Representation Theory representation. +64. `representationTheoryCanonicalizeModule(value)` - Canonicalize a module so equivalent inputs share one form. +65. `representationTheoryParseModule(text)` - Parse a text or structured value into a module. +66. `representationTheoryFormatModule(value)` - Format a module for deterministic user-facing output. +67. `representationTheoryCompareModule(left, right)` - Compare two module values under the conventions of Representation Theory. +68. `representationTheoryCombineModule(left, right)` - Combine two module values with the natural operation for Representation Theory. +69. `representationTheoryDecomposeModule(value)` - Decompose a module into simpler or canonical components. +70. `representationTheoryEvaluateModule(value, point=None)` - Evaluate a module at a point, sample, or finite model. +71. `representationTheoryComputeModule(value)` - Compute the central numerical or symbolic data of a module. +72. `representationTheoryEstimateModule(value, samples=None)` - Estimate a module property from finite samples or approximations. +73. `representationTheoryApproximateModule(value, tolerance=1e-9)` - Approximate a module with explicit tolerance controls. +74. `representationTheoryTransformModule(value, mapping)` - Transform a module through a map, operator, or representation change. +75. `representationTheorySimplifyModule(value)` - Simplify a module without changing its mathematical meaning. +76. `representationTheoryEnumerateModule(value, limit=None)` - Enumerate finite members, cases, or derived objects for a module. +77. `representationTheoryClassifyModule(value)` - Classify a module by its standard Representation Theory invariants. +78. `representationTheoryTestEquivalenceModule(left, right)` - Test whether two module values are equivalent in Representation Theory. +79. `representationTheoryGenerateExampleModule(size=3)` - Generate a small documented example of a module. +80. `representationTheoryDocumentModule(value)` - Return a structured explanation of a module and related assumptions. +81. `representationTheoryValidateInvariantSubspace(value)` - Validate the invariant subspace representation and domain rules for Representation Theory. +82. `representationTheoryConstructInvariantSubspace(*args)` - Construct a invariant subspace from explicit inputs for Representation Theory. +83. `representationTheoryNormalizeInvariantSubspace(value)` - Normalize a invariant subspace into the standard Representation Theory representation. +84. `representationTheoryCanonicalizeInvariantSubspace(value)` - Canonicalize a invariant subspace so equivalent inputs share one form. +85. `representationTheoryParseInvariantSubspace(text)` - Parse a text or structured value into a invariant subspace. +86. `representationTheoryFormatInvariantSubspace(value)` - Format a invariant subspace for deterministic user-facing output. +87. `representationTheoryCompareInvariantSubspace(left, right)` - Compare two invariant subspace values under the conventions of Representation Theory. +88. `representationTheoryCombineInvariantSubspace(left, right)` - Combine two invariant subspace values with the natural operation for Representation Theory. +89. `representationTheoryDecomposeInvariantSubspace(value)` - Decompose a invariant subspace into simpler or canonical components. +90. `representationTheoryEvaluateInvariantSubspace(value, point=None)` - Evaluate a invariant subspace at a point, sample, or finite model. +91. `representationTheoryComputeInvariantSubspace(value)` - Compute the central numerical or symbolic data of a invariant subspace. +92. `representationTheoryEstimateInvariantSubspace(value, samples=None)` - Estimate a invariant subspace property from finite samples or approximations. +93. `representationTheoryApproximateInvariantSubspace(value, tolerance=1e-9)` - Approximate a invariant subspace with explicit tolerance controls. +94. `representationTheoryTransformInvariantSubspace(value, mapping)` - Transform a invariant subspace through a map, operator, or representation change. +95. `representationTheorySimplifyInvariantSubspace(value)` - Simplify a invariant subspace without changing its mathematical meaning. +96. `representationTheoryEnumerateInvariantSubspace(value, limit=None)` - Enumerate finite members, cases, or derived objects for a invariant subspace. +97. `representationTheoryClassifyInvariantSubspace(value)` - Classify a invariant subspace by its standard Representation Theory invariants. +98. `representationTheoryTestEquivalenceInvariantSubspace(left, right)` - Test whether two invariant subspace values are equivalent in Representation Theory. +99. `representationTheoryGenerateExampleInvariantSubspace(size=3)` - Generate a small documented example of a invariant subspace. +100. `representationTheoryDocumentInvariantSubspace(value)` - Return a structured explanation of a invariant subspace and related assumptions. + +### Galois Theory + +Core object families: + +- field extension +- minimal polynomial +- automorphism +- splitting field +- Galois group + +Candidate functions: + +1. `galoisTheoryValidateFieldExtension(value)` - Validate the field extension representation and domain rules for Galois Theory. +2. `galoisTheoryConstructFieldExtension(*args)` - Construct a field extension from explicit inputs for Galois Theory. +3. `galoisTheoryNormalizeFieldExtension(value)` - Normalize a field extension into the standard Galois Theory representation. +4. `galoisTheoryCanonicalizeFieldExtension(value)` - Canonicalize a field extension so equivalent inputs share one form. +5. `galoisTheoryParseFieldExtension(text)` - Parse a text or structured value into a field extension. +6. `galoisTheoryFormatFieldExtension(value)` - Format a field extension for deterministic user-facing output. +7. `galoisTheoryCompareFieldExtension(left, right)` - Compare two field extension values under the conventions of Galois Theory. +8. `galoisTheoryCombineFieldExtension(left, right)` - Combine two field extension values with the natural operation for Galois Theory. +9. `galoisTheoryDecomposeFieldExtension(value)` - Decompose a field extension into simpler or canonical components. +10. `galoisTheoryEvaluateFieldExtension(value, point=None)` - Evaluate a field extension at a point, sample, or finite model. +11. `galoisTheoryComputeFieldExtension(value)` - Compute the central numerical or symbolic data of a field extension. +12. `galoisTheoryEstimateFieldExtension(value, samples=None)` - Estimate a field extension property from finite samples or approximations. +13. `galoisTheoryApproximateFieldExtension(value, tolerance=1e-9)` - Approximate a field extension with explicit tolerance controls. +14. `galoisTheoryTransformFieldExtension(value, mapping)` - Transform a field extension through a map, operator, or representation change. +15. `galoisTheorySimplifyFieldExtension(value)` - Simplify a field extension without changing its mathematical meaning. +16. `galoisTheoryEnumerateFieldExtension(value, limit=None)` - Enumerate finite members, cases, or derived objects for a field extension. +17. `galoisTheoryClassifyFieldExtension(value)` - Classify a field extension by its standard Galois Theory invariants. +18. `galoisTheoryTestEquivalenceFieldExtension(left, right)` - Test whether two field extension values are equivalent in Galois Theory. +19. `galoisTheoryGenerateExampleFieldExtension(size=3)` - Generate a small documented example of a field extension. +20. `galoisTheoryDocumentFieldExtension(value)` - Return a structured explanation of a field extension and related assumptions. +21. `galoisTheoryValidateMinimalPolynomial(value)` - Validate the minimal polynomial representation and domain rules for Galois Theory. +22. `galoisTheoryConstructMinimalPolynomial(*args)` - Construct a minimal polynomial from explicit inputs for Galois Theory. +23. `galoisTheoryNormalizeMinimalPolynomial(value)` - Normalize a minimal polynomial into the standard Galois Theory representation. +24. `galoisTheoryCanonicalizeMinimalPolynomial(value)` - Canonicalize a minimal polynomial so equivalent inputs share one form. +25. `galoisTheoryParseMinimalPolynomial(text)` - Parse a text or structured value into a minimal polynomial. +26. `galoisTheoryFormatMinimalPolynomial(value)` - Format a minimal polynomial for deterministic user-facing output. +27. `galoisTheoryCompareMinimalPolynomial(left, right)` - Compare two minimal polynomial values under the conventions of Galois Theory. +28. `galoisTheoryCombineMinimalPolynomial(left, right)` - Combine two minimal polynomial values with the natural operation for Galois Theory. +29. `galoisTheoryDecomposeMinimalPolynomial(value)` - Decompose a minimal polynomial into simpler or canonical components. +30. `galoisTheoryEvaluateMinimalPolynomial(value, point=None)` - Evaluate a minimal polynomial at a point, sample, or finite model. +31. `galoisTheoryComputeMinimalPolynomial(value)` - Compute the central numerical or symbolic data of a minimal polynomial. +32. `galoisTheoryEstimateMinimalPolynomial(value, samples=None)` - Estimate a minimal polynomial property from finite samples or approximations. +33. `galoisTheoryApproximateMinimalPolynomial(value, tolerance=1e-9)` - Approximate a minimal polynomial with explicit tolerance controls. +34. `galoisTheoryTransformMinimalPolynomial(value, mapping)` - Transform a minimal polynomial through a map, operator, or representation change. +35. `galoisTheorySimplifyMinimalPolynomial(value)` - Simplify a minimal polynomial without changing its mathematical meaning. +36. `galoisTheoryEnumerateMinimalPolynomial(value, limit=None)` - Enumerate finite members, cases, or derived objects for a minimal polynomial. +37. `galoisTheoryClassifyMinimalPolynomial(value)` - Classify a minimal polynomial by its standard Galois Theory invariants. +38. `galoisTheoryTestEquivalenceMinimalPolynomial(left, right)` - Test whether two minimal polynomial values are equivalent in Galois Theory. +39. `galoisTheoryGenerateExampleMinimalPolynomial(size=3)` - Generate a small documented example of a minimal polynomial. +40. `galoisTheoryDocumentMinimalPolynomial(value)` - Return a structured explanation of a minimal polynomial and related assumptions. +41. `galoisTheoryValidateAutomorphism(value)` - Validate the automorphism representation and domain rules for Galois Theory. +42. `galoisTheoryConstructAutomorphism(*args)` - Construct a automorphism from explicit inputs for Galois Theory. +43. `galoisTheoryNormalizeAutomorphism(value)` - Normalize a automorphism into the standard Galois Theory representation. +44. `galoisTheoryCanonicalizeAutomorphism(value)` - Canonicalize a automorphism so equivalent inputs share one form. +45. `galoisTheoryParseAutomorphism(text)` - Parse a text or structured value into a automorphism. +46. `galoisTheoryFormatAutomorphism(value)` - Format a automorphism for deterministic user-facing output. +47. `galoisTheoryCompareAutomorphism(left, right)` - Compare two automorphism values under the conventions of Galois Theory. +48. `galoisTheoryCombineAutomorphism(left, right)` - Combine two automorphism values with the natural operation for Galois Theory. +49. `galoisTheoryDecomposeAutomorphism(value)` - Decompose a automorphism into simpler or canonical components. +50. `galoisTheoryEvaluateAutomorphism(value, point=None)` - Evaluate a automorphism at a point, sample, or finite model. +51. `galoisTheoryComputeAutomorphism(value)` - Compute the central numerical or symbolic data of a automorphism. +52. `galoisTheoryEstimateAutomorphism(value, samples=None)` - Estimate a automorphism property from finite samples or approximations. +53. `galoisTheoryApproximateAutomorphism(value, tolerance=1e-9)` - Approximate a automorphism with explicit tolerance controls. +54. `galoisTheoryTransformAutomorphism(value, mapping)` - Transform a automorphism through a map, operator, or representation change. +55. `galoisTheorySimplifyAutomorphism(value)` - Simplify a automorphism without changing its mathematical meaning. +56. `galoisTheoryEnumerateAutomorphism(value, limit=None)` - Enumerate finite members, cases, or derived objects for a automorphism. +57. `galoisTheoryClassifyAutomorphism(value)` - Classify a automorphism by its standard Galois Theory invariants. +58. `galoisTheoryTestEquivalenceAutomorphism(left, right)` - Test whether two automorphism values are equivalent in Galois Theory. +59. `galoisTheoryGenerateExampleAutomorphism(size=3)` - Generate a small documented example of a automorphism. +60. `galoisTheoryDocumentAutomorphism(value)` - Return a structured explanation of a automorphism and related assumptions. +61. `galoisTheoryValidateSplittingField(value)` - Validate the splitting field representation and domain rules for Galois Theory. +62. `galoisTheoryConstructSplittingField(*args)` - Construct a splitting field from explicit inputs for Galois Theory. +63. `galoisTheoryNormalizeSplittingField(value)` - Normalize a splitting field into the standard Galois Theory representation. +64. `galoisTheoryCanonicalizeSplittingField(value)` - Canonicalize a splitting field so equivalent inputs share one form. +65. `galoisTheoryParseSplittingField(text)` - Parse a text or structured value into a splitting field. +66. `galoisTheoryFormatSplittingField(value)` - Format a splitting field for deterministic user-facing output. +67. `galoisTheoryCompareSplittingField(left, right)` - Compare two splitting field values under the conventions of Galois Theory. +68. `galoisTheoryCombineSplittingField(left, right)` - Combine two splitting field values with the natural operation for Galois Theory. +69. `galoisTheoryDecomposeSplittingField(value)` - Decompose a splitting field into simpler or canonical components. +70. `galoisTheoryEvaluateSplittingField(value, point=None)` - Evaluate a splitting field at a point, sample, or finite model. +71. `galoisTheoryComputeSplittingField(value)` - Compute the central numerical or symbolic data of a splitting field. +72. `galoisTheoryEstimateSplittingField(value, samples=None)` - Estimate a splitting field property from finite samples or approximations. +73. `galoisTheoryApproximateSplittingField(value, tolerance=1e-9)` - Approximate a splitting field with explicit tolerance controls. +74. `galoisTheoryTransformSplittingField(value, mapping)` - Transform a splitting field through a map, operator, or representation change. +75. `galoisTheorySimplifySplittingField(value)` - Simplify a splitting field without changing its mathematical meaning. +76. `galoisTheoryEnumerateSplittingField(value, limit=None)` - Enumerate finite members, cases, or derived objects for a splitting field. +77. `galoisTheoryClassifySplittingField(value)` - Classify a splitting field by its standard Galois Theory invariants. +78. `galoisTheoryTestEquivalenceSplittingField(left, right)` - Test whether two splitting field values are equivalent in Galois Theory. +79. `galoisTheoryGenerateExampleSplittingField(size=3)` - Generate a small documented example of a splitting field. +80. `galoisTheoryDocumentSplittingField(value)` - Return a structured explanation of a splitting field and related assumptions. +81. `galoisTheoryValidateGaloisGroup(value)` - Validate the Galois group representation and domain rules for Galois Theory. +82. `galoisTheoryConstructGaloisGroup(*args)` - Construct a Galois group from explicit inputs for Galois Theory. +83. `galoisTheoryNormalizeGaloisGroup(value)` - Normalize a Galois group into the standard Galois Theory representation. +84. `galoisTheoryCanonicalizeGaloisGroup(value)` - Canonicalize a Galois group so equivalent inputs share one form. +85. `galoisTheoryParseGaloisGroup(text)` - Parse a text or structured value into a Galois group. +86. `galoisTheoryFormatGaloisGroup(value)` - Format a Galois group for deterministic user-facing output. +87. `galoisTheoryCompareGaloisGroup(left, right)` - Compare two Galois group values under the conventions of Galois Theory. +88. `galoisTheoryCombineGaloisGroup(left, right)` - Combine two Galois group values with the natural operation for Galois Theory. +89. `galoisTheoryDecomposeGaloisGroup(value)` - Decompose a Galois group into simpler or canonical components. +90. `galoisTheoryEvaluateGaloisGroup(value, point=None)` - Evaluate a Galois group at a point, sample, or finite model. +91. `galoisTheoryComputeGaloisGroup(value)` - Compute the central numerical or symbolic data of a Galois group. +92. `galoisTheoryEstimateGaloisGroup(value, samples=None)` - Estimate a Galois group property from finite samples or approximations. +93. `galoisTheoryApproximateGaloisGroup(value, tolerance=1e-9)` - Approximate a Galois group with explicit tolerance controls. +94. `galoisTheoryTransformGaloisGroup(value, mapping)` - Transform a Galois group through a map, operator, or representation change. +95. `galoisTheorySimplifyGaloisGroup(value)` - Simplify a Galois group without changing its mathematical meaning. +96. `galoisTheoryEnumerateGaloisGroup(value, limit=None)` - Enumerate finite members, cases, or derived objects for a Galois group. +97. `galoisTheoryClassifyGaloisGroup(value)` - Classify a Galois group by its standard Galois Theory invariants. +98. `galoisTheoryTestEquivalenceGaloisGroup(left, right)` - Test whether two Galois group values are equivalent in Galois Theory. +99. `galoisTheoryGenerateExampleGaloisGroup(size=3)` - Generate a small documented example of a Galois group. +100. `galoisTheoryDocumentGaloisGroup(value)` - Return a structured explanation of a Galois group and related assumptions. + +### Commutative Algebra + +Core object families: + +- commutative ring +- ideal +- module +- quotient ring +- localization + +Candidate functions: + +1. `commutativeAlgebraValidateCommutativeRing(value)` - Validate the commutative ring representation and domain rules for Commutative Algebra. +2. `commutativeAlgebraConstructCommutativeRing(*args)` - Construct a commutative ring from explicit inputs for Commutative Algebra. +3. `commutativeAlgebraNormalizeCommutativeRing(value)` - Normalize a commutative ring into the standard Commutative Algebra representation. +4. `commutativeAlgebraCanonicalizeCommutativeRing(value)` - Canonicalize a commutative ring so equivalent inputs share one form. +5. `commutativeAlgebraParseCommutativeRing(text)` - Parse a text or structured value into a commutative ring. +6. `commutativeAlgebraFormatCommutativeRing(value)` - Format a commutative ring for deterministic user-facing output. +7. `commutativeAlgebraCompareCommutativeRing(left, right)` - Compare two commutative ring values under the conventions of Commutative Algebra. +8. `commutativeAlgebraCombineCommutativeRing(left, right)` - Combine two commutative ring values with the natural operation for Commutative Algebra. +9. `commutativeAlgebraDecomposeCommutativeRing(value)` - Decompose a commutative ring into simpler or canonical components. +10. `commutativeAlgebraEvaluateCommutativeRing(value, point=None)` - Evaluate a commutative ring at a point, sample, or finite model. +11. `commutativeAlgebraComputeCommutativeRing(value)` - Compute the central numerical or symbolic data of a commutative ring. +12. `commutativeAlgebraEstimateCommutativeRing(value, samples=None)` - Estimate a commutative ring property from finite samples or approximations. +13. `commutativeAlgebraApproximateCommutativeRing(value, tolerance=1e-9)` - Approximate a commutative ring with explicit tolerance controls. +14. `commutativeAlgebraTransformCommutativeRing(value, mapping)` - Transform a commutative ring through a map, operator, or representation change. +15. `commutativeAlgebraSimplifyCommutativeRing(value)` - Simplify a commutative ring without changing its mathematical meaning. +16. `commutativeAlgebraEnumerateCommutativeRing(value, limit=None)` - Enumerate finite members, cases, or derived objects for a commutative ring. +17. `commutativeAlgebraClassifyCommutativeRing(value)` - Classify a commutative ring by its standard Commutative Algebra invariants. +18. `commutativeAlgebraTestEquivalenceCommutativeRing(left, right)` - Test whether two commutative ring values are equivalent in Commutative Algebra. +19. `commutativeAlgebraGenerateExampleCommutativeRing(size=3)` - Generate a small documented example of a commutative ring. +20. `commutativeAlgebraDocumentCommutativeRing(value)` - Return a structured explanation of a commutative ring and related assumptions. +21. `commutativeAlgebraValidateIdeal(value)` - Validate the ideal representation and domain rules for Commutative Algebra. +22. `commutativeAlgebraConstructIdeal(*args)` - Construct a ideal from explicit inputs for Commutative Algebra. +23. `commutativeAlgebraNormalizeIdeal(value)` - Normalize a ideal into the standard Commutative Algebra representation. +24. `commutativeAlgebraCanonicalizeIdeal(value)` - Canonicalize a ideal so equivalent inputs share one form. +25. `commutativeAlgebraParseIdeal(text)` - Parse a text or structured value into a ideal. +26. `commutativeAlgebraFormatIdeal(value)` - Format a ideal for deterministic user-facing output. +27. `commutativeAlgebraCompareIdeal(left, right)` - Compare two ideal values under the conventions of Commutative Algebra. +28. `commutativeAlgebraCombineIdeal(left, right)` - Combine two ideal values with the natural operation for Commutative Algebra. +29. `commutativeAlgebraDecomposeIdeal(value)` - Decompose a ideal into simpler or canonical components. +30. `commutativeAlgebraEvaluateIdeal(value, point=None)` - Evaluate a ideal at a point, sample, or finite model. +31. `commutativeAlgebraComputeIdeal(value)` - Compute the central numerical or symbolic data of a ideal. +32. `commutativeAlgebraEstimateIdeal(value, samples=None)` - Estimate a ideal property from finite samples or approximations. +33. `commutativeAlgebraApproximateIdeal(value, tolerance=1e-9)` - Approximate a ideal with explicit tolerance controls. +34. `commutativeAlgebraTransformIdeal(value, mapping)` - Transform a ideal through a map, operator, or representation change. +35. `commutativeAlgebraSimplifyIdeal(value)` - Simplify a ideal without changing its mathematical meaning. +36. `commutativeAlgebraEnumerateIdeal(value, limit=None)` - Enumerate finite members, cases, or derived objects for a ideal. +37. `commutativeAlgebraClassifyIdeal(value)` - Classify a ideal by its standard Commutative Algebra invariants. +38. `commutativeAlgebraTestEquivalenceIdeal(left, right)` - Test whether two ideal values are equivalent in Commutative Algebra. +39. `commutativeAlgebraGenerateExampleIdeal(size=3)` - Generate a small documented example of a ideal. +40. `commutativeAlgebraDocumentIdeal(value)` - Return a structured explanation of a ideal and related assumptions. +41. `commutativeAlgebraValidateModule(value)` - Validate the module representation and domain rules for Commutative Algebra. +42. `commutativeAlgebraConstructModule(*args)` - Construct a module from explicit inputs for Commutative Algebra. +43. `commutativeAlgebraNormalizeModule(value)` - Normalize a module into the standard Commutative Algebra representation. +44. `commutativeAlgebraCanonicalizeModule(value)` - Canonicalize a module so equivalent inputs share one form. +45. `commutativeAlgebraParseModule(text)` - Parse a text or structured value into a module. +46. `commutativeAlgebraFormatModule(value)` - Format a module for deterministic user-facing output. +47. `commutativeAlgebraCompareModule(left, right)` - Compare two module values under the conventions of Commutative Algebra. +48. `commutativeAlgebraCombineModule(left, right)` - Combine two module values with the natural operation for Commutative Algebra. +49. `commutativeAlgebraDecomposeModule(value)` - Decompose a module into simpler or canonical components. +50. `commutativeAlgebraEvaluateModule(value, point=None)` - Evaluate a module at a point, sample, or finite model. +51. `commutativeAlgebraComputeModule(value)` - Compute the central numerical or symbolic data of a module. +52. `commutativeAlgebraEstimateModule(value, samples=None)` - Estimate a module property from finite samples or approximations. +53. `commutativeAlgebraApproximateModule(value, tolerance=1e-9)` - Approximate a module with explicit tolerance controls. +54. `commutativeAlgebraTransformModule(value, mapping)` - Transform a module through a map, operator, or representation change. +55. `commutativeAlgebraSimplifyModule(value)` - Simplify a module without changing its mathematical meaning. +56. `commutativeAlgebraEnumerateModule(value, limit=None)` - Enumerate finite members, cases, or derived objects for a module. +57. `commutativeAlgebraClassifyModule(value)` - Classify a module by its standard Commutative Algebra invariants. +58. `commutativeAlgebraTestEquivalenceModule(left, right)` - Test whether two module values are equivalent in Commutative Algebra. +59. `commutativeAlgebraGenerateExampleModule(size=3)` - Generate a small documented example of a module. +60. `commutativeAlgebraDocumentModule(value)` - Return a structured explanation of a module and related assumptions. +61. `commutativeAlgebraValidateQuotientRing(value)` - Validate the quotient ring representation and domain rules for Commutative Algebra. +62. `commutativeAlgebraConstructQuotientRing(*args)` - Construct a quotient ring from explicit inputs for Commutative Algebra. +63. `commutativeAlgebraNormalizeQuotientRing(value)` - Normalize a quotient ring into the standard Commutative Algebra representation. +64. `commutativeAlgebraCanonicalizeQuotientRing(value)` - Canonicalize a quotient ring so equivalent inputs share one form. +65. `commutativeAlgebraParseQuotientRing(text)` - Parse a text or structured value into a quotient ring. +66. `commutativeAlgebraFormatQuotientRing(value)` - Format a quotient ring for deterministic user-facing output. +67. `commutativeAlgebraCompareQuotientRing(left, right)` - Compare two quotient ring values under the conventions of Commutative Algebra. +68. `commutativeAlgebraCombineQuotientRing(left, right)` - Combine two quotient ring values with the natural operation for Commutative Algebra. +69. `commutativeAlgebraDecomposeQuotientRing(value)` - Decompose a quotient ring into simpler or canonical components. +70. `commutativeAlgebraEvaluateQuotientRing(value, point=None)` - Evaluate a quotient ring at a point, sample, or finite model. +71. `commutativeAlgebraComputeQuotientRing(value)` - Compute the central numerical or symbolic data of a quotient ring. +72. `commutativeAlgebraEstimateQuotientRing(value, samples=None)` - Estimate a quotient ring property from finite samples or approximations. +73. `commutativeAlgebraApproximateQuotientRing(value, tolerance=1e-9)` - Approximate a quotient ring with explicit tolerance controls. +74. `commutativeAlgebraTransformQuotientRing(value, mapping)` - Transform a quotient ring through a map, operator, or representation change. +75. `commutativeAlgebraSimplifyQuotientRing(value)` - Simplify a quotient ring without changing its mathematical meaning. +76. `commutativeAlgebraEnumerateQuotientRing(value, limit=None)` - Enumerate finite members, cases, or derived objects for a quotient ring. +77. `commutativeAlgebraClassifyQuotientRing(value)` - Classify a quotient ring by its standard Commutative Algebra invariants. +78. `commutativeAlgebraTestEquivalenceQuotientRing(left, right)` - Test whether two quotient ring values are equivalent in Commutative Algebra. +79. `commutativeAlgebraGenerateExampleQuotientRing(size=3)` - Generate a small documented example of a quotient ring. +80. `commutativeAlgebraDocumentQuotientRing(value)` - Return a structured explanation of a quotient ring and related assumptions. +81. `commutativeAlgebraValidateLocalization(value)` - Validate the localization representation and domain rules for Commutative Algebra. +82. `commutativeAlgebraConstructLocalization(*args)` - Construct a localization from explicit inputs for Commutative Algebra. +83. `commutativeAlgebraNormalizeLocalization(value)` - Normalize a localization into the standard Commutative Algebra representation. +84. `commutativeAlgebraCanonicalizeLocalization(value)` - Canonicalize a localization so equivalent inputs share one form. +85. `commutativeAlgebraParseLocalization(text)` - Parse a text or structured value into a localization. +86. `commutativeAlgebraFormatLocalization(value)` - Format a localization for deterministic user-facing output. +87. `commutativeAlgebraCompareLocalization(left, right)` - Compare two localization values under the conventions of Commutative Algebra. +88. `commutativeAlgebraCombineLocalization(left, right)` - Combine two localization values with the natural operation for Commutative Algebra. +89. `commutativeAlgebraDecomposeLocalization(value)` - Decompose a localization into simpler or canonical components. +90. `commutativeAlgebraEvaluateLocalization(value, point=None)` - Evaluate a localization at a point, sample, or finite model. +91. `commutativeAlgebraComputeLocalization(value)` - Compute the central numerical or symbolic data of a localization. +92. `commutativeAlgebraEstimateLocalization(value, samples=None)` - Estimate a localization property from finite samples or approximations. +93. `commutativeAlgebraApproximateLocalization(value, tolerance=1e-9)` - Approximate a localization with explicit tolerance controls. +94. `commutativeAlgebraTransformLocalization(value, mapping)` - Transform a localization through a map, operator, or representation change. +95. `commutativeAlgebraSimplifyLocalization(value)` - Simplify a localization without changing its mathematical meaning. +96. `commutativeAlgebraEnumerateLocalization(value, limit=None)` - Enumerate finite members, cases, or derived objects for a localization. +97. `commutativeAlgebraClassifyLocalization(value)` - Classify a localization by its standard Commutative Algebra invariants. +98. `commutativeAlgebraTestEquivalenceLocalization(left, right)` - Test whether two localization values are equivalent in Commutative Algebra. +99. `commutativeAlgebraGenerateExampleLocalization(size=3)` - Generate a small documented example of a localization. +100. `commutativeAlgebraDocumentLocalization(value)` - Return a structured explanation of a localization and related assumptions. + +### Homological Algebra + +Core object families: + +- chain complex +- exact sequence +- derived functor +- chain map +- homology object + +Candidate functions: + +1. `homologicalAlgebraValidateChainComplex(value)` - Validate the chain complex representation and domain rules for Homological Algebra. +2. `homologicalAlgebraConstructChainComplex(*args)` - Construct a chain complex from explicit inputs for Homological Algebra. +3. `homologicalAlgebraNormalizeChainComplex(value)` - Normalize a chain complex into the standard Homological Algebra representation. +4. `homologicalAlgebraCanonicalizeChainComplex(value)` - Canonicalize a chain complex so equivalent inputs share one form. +5. `homologicalAlgebraParseChainComplex(text)` - Parse a text or structured value into a chain complex. +6. `homologicalAlgebraFormatChainComplex(value)` - Format a chain complex for deterministic user-facing output. +7. `homologicalAlgebraCompareChainComplex(left, right)` - Compare two chain complex values under the conventions of Homological Algebra. +8. `homologicalAlgebraCombineChainComplex(left, right)` - Combine two chain complex values with the natural operation for Homological Algebra. +9. `homologicalAlgebraDecomposeChainComplex(value)` - Decompose a chain complex into simpler or canonical components. +10. `homologicalAlgebraEvaluateChainComplex(value, point=None)` - Evaluate a chain complex at a point, sample, or finite model. +11. `homologicalAlgebraComputeChainComplex(value)` - Compute the central numerical or symbolic data of a chain complex. +12. `homologicalAlgebraEstimateChainComplex(value, samples=None)` - Estimate a chain complex property from finite samples or approximations. +13. `homologicalAlgebraApproximateChainComplex(value, tolerance=1e-9)` - Approximate a chain complex with explicit tolerance controls. +14. `homologicalAlgebraTransformChainComplex(value, mapping)` - Transform a chain complex through a map, operator, or representation change. +15. `homologicalAlgebraSimplifyChainComplex(value)` - Simplify a chain complex without changing its mathematical meaning. +16. `homologicalAlgebraEnumerateChainComplex(value, limit=None)` - Enumerate finite members, cases, or derived objects for a chain complex. +17. `homologicalAlgebraClassifyChainComplex(value)` - Classify a chain complex by its standard Homological Algebra invariants. +18. `homologicalAlgebraTestEquivalenceChainComplex(left, right)` - Test whether two chain complex values are equivalent in Homological Algebra. +19. `homologicalAlgebraGenerateExampleChainComplex(size=3)` - Generate a small documented example of a chain complex. +20. `homologicalAlgebraDocumentChainComplex(value)` - Return a structured explanation of a chain complex and related assumptions. +21. `homologicalAlgebraValidateExactSequence(value)` - Validate the exact sequence representation and domain rules for Homological Algebra. +22. `homologicalAlgebraConstructExactSequence(*args)` - Construct a exact sequence from explicit inputs for Homological Algebra. +23. `homologicalAlgebraNormalizeExactSequence(value)` - Normalize a exact sequence into the standard Homological Algebra representation. +24. `homologicalAlgebraCanonicalizeExactSequence(value)` - Canonicalize a exact sequence so equivalent inputs share one form. +25. `homologicalAlgebraParseExactSequence(text)` - Parse a text or structured value into a exact sequence. +26. `homologicalAlgebraFormatExactSequence(value)` - Format a exact sequence for deterministic user-facing output. +27. `homologicalAlgebraCompareExactSequence(left, right)` - Compare two exact sequence values under the conventions of Homological Algebra. +28. `homologicalAlgebraCombineExactSequence(left, right)` - Combine two exact sequence values with the natural operation for Homological Algebra. +29. `homologicalAlgebraDecomposeExactSequence(value)` - Decompose a exact sequence into simpler or canonical components. +30. `homologicalAlgebraEvaluateExactSequence(value, point=None)` - Evaluate a exact sequence at a point, sample, or finite model. +31. `homologicalAlgebraComputeExactSequence(value)` - Compute the central numerical or symbolic data of a exact sequence. +32. `homologicalAlgebraEstimateExactSequence(value, samples=None)` - Estimate a exact sequence property from finite samples or approximations. +33. `homologicalAlgebraApproximateExactSequence(value, tolerance=1e-9)` - Approximate a exact sequence with explicit tolerance controls. +34. `homologicalAlgebraTransformExactSequence(value, mapping)` - Transform a exact sequence through a map, operator, or representation change. +35. `homologicalAlgebraSimplifyExactSequence(value)` - Simplify a exact sequence without changing its mathematical meaning. +36. `homologicalAlgebraEnumerateExactSequence(value, limit=None)` - Enumerate finite members, cases, or derived objects for a exact sequence. +37. `homologicalAlgebraClassifyExactSequence(value)` - Classify a exact sequence by its standard Homological Algebra invariants. +38. `homologicalAlgebraTestEquivalenceExactSequence(left, right)` - Test whether two exact sequence values are equivalent in Homological Algebra. +39. `homologicalAlgebraGenerateExampleExactSequence(size=3)` - Generate a small documented example of a exact sequence. +40. `homologicalAlgebraDocumentExactSequence(value)` - Return a structured explanation of a exact sequence and related assumptions. +41. `homologicalAlgebraValidateDerivedFunctor(value)` - Validate the derived functor representation and domain rules for Homological Algebra. +42. `homologicalAlgebraConstructDerivedFunctor(*args)` - Construct a derived functor from explicit inputs for Homological Algebra. +43. `homologicalAlgebraNormalizeDerivedFunctor(value)` - Normalize a derived functor into the standard Homological Algebra representation. +44. `homologicalAlgebraCanonicalizeDerivedFunctor(value)` - Canonicalize a derived functor so equivalent inputs share one form. +45. `homologicalAlgebraParseDerivedFunctor(text)` - Parse a text or structured value into a derived functor. +46. `homologicalAlgebraFormatDerivedFunctor(value)` - Format a derived functor for deterministic user-facing output. +47. `homologicalAlgebraCompareDerivedFunctor(left, right)` - Compare two derived functor values under the conventions of Homological Algebra. +48. `homologicalAlgebraCombineDerivedFunctor(left, right)` - Combine two derived functor values with the natural operation for Homological Algebra. +49. `homologicalAlgebraDecomposeDerivedFunctor(value)` - Decompose a derived functor into simpler or canonical components. +50. `homologicalAlgebraEvaluateDerivedFunctor(value, point=None)` - Evaluate a derived functor at a point, sample, or finite model. +51. `homologicalAlgebraComputeDerivedFunctor(value)` - Compute the central numerical or symbolic data of a derived functor. +52. `homologicalAlgebraEstimateDerivedFunctor(value, samples=None)` - Estimate a derived functor property from finite samples or approximations. +53. `homologicalAlgebraApproximateDerivedFunctor(value, tolerance=1e-9)` - Approximate a derived functor with explicit tolerance controls. +54. `homologicalAlgebraTransformDerivedFunctor(value, mapping)` - Transform a derived functor through a map, operator, or representation change. +55. `homologicalAlgebraSimplifyDerivedFunctor(value)` - Simplify a derived functor without changing its mathematical meaning. +56. `homologicalAlgebraEnumerateDerivedFunctor(value, limit=None)` - Enumerate finite members, cases, or derived objects for a derived functor. +57. `homologicalAlgebraClassifyDerivedFunctor(value)` - Classify a derived functor by its standard Homological Algebra invariants. +58. `homologicalAlgebraTestEquivalenceDerivedFunctor(left, right)` - Test whether two derived functor values are equivalent in Homological Algebra. +59. `homologicalAlgebraGenerateExampleDerivedFunctor(size=3)` - Generate a small documented example of a derived functor. +60. `homologicalAlgebraDocumentDerivedFunctor(value)` - Return a structured explanation of a derived functor and related assumptions. +61. `homologicalAlgebraValidateChainMap(value)` - Validate the chain map representation and domain rules for Homological Algebra. +62. `homologicalAlgebraConstructChainMap(*args)` - Construct a chain map from explicit inputs for Homological Algebra. +63. `homologicalAlgebraNormalizeChainMap(value)` - Normalize a chain map into the standard Homological Algebra representation. +64. `homologicalAlgebraCanonicalizeChainMap(value)` - Canonicalize a chain map so equivalent inputs share one form. +65. `homologicalAlgebraParseChainMap(text)` - Parse a text or structured value into a chain map. +66. `homologicalAlgebraFormatChainMap(value)` - Format a chain map for deterministic user-facing output. +67. `homologicalAlgebraCompareChainMap(left, right)` - Compare two chain map values under the conventions of Homological Algebra. +68. `homologicalAlgebraCombineChainMap(left, right)` - Combine two chain map values with the natural operation for Homological Algebra. +69. `homologicalAlgebraDecomposeChainMap(value)` - Decompose a chain map into simpler or canonical components. +70. `homologicalAlgebraEvaluateChainMap(value, point=None)` - Evaluate a chain map at a point, sample, or finite model. +71. `homologicalAlgebraComputeChainMap(value)` - Compute the central numerical or symbolic data of a chain map. +72. `homologicalAlgebraEstimateChainMap(value, samples=None)` - Estimate a chain map property from finite samples or approximations. +73. `homologicalAlgebraApproximateChainMap(value, tolerance=1e-9)` - Approximate a chain map with explicit tolerance controls. +74. `homologicalAlgebraTransformChainMap(value, mapping)` - Transform a chain map through a map, operator, or representation change. +75. `homologicalAlgebraSimplifyChainMap(value)` - Simplify a chain map without changing its mathematical meaning. +76. `homologicalAlgebraEnumerateChainMap(value, limit=None)` - Enumerate finite members, cases, or derived objects for a chain map. +77. `homologicalAlgebraClassifyChainMap(value)` - Classify a chain map by its standard Homological Algebra invariants. +78. `homologicalAlgebraTestEquivalenceChainMap(left, right)` - Test whether two chain map values are equivalent in Homological Algebra. +79. `homologicalAlgebraGenerateExampleChainMap(size=3)` - Generate a small documented example of a chain map. +80. `homologicalAlgebraDocumentChainMap(value)` - Return a structured explanation of a chain map and related assumptions. +81. `homologicalAlgebraValidateHomologyObject(value)` - Validate the homology object representation and domain rules for Homological Algebra. +82. `homologicalAlgebraConstructHomologyObject(*args)` - Construct a homology object from explicit inputs for Homological Algebra. +83. `homologicalAlgebraNormalizeHomologyObject(value)` - Normalize a homology object into the standard Homological Algebra representation. +84. `homologicalAlgebraCanonicalizeHomologyObject(value)` - Canonicalize a homology object so equivalent inputs share one form. +85. `homologicalAlgebraParseHomologyObject(text)` - Parse a text or structured value into a homology object. +86. `homologicalAlgebraFormatHomologyObject(value)` - Format a homology object for deterministic user-facing output. +87. `homologicalAlgebraCompareHomologyObject(left, right)` - Compare two homology object values under the conventions of Homological Algebra. +88. `homologicalAlgebraCombineHomologyObject(left, right)` - Combine two homology object values with the natural operation for Homological Algebra. +89. `homologicalAlgebraDecomposeHomologyObject(value)` - Decompose a homology object into simpler or canonical components. +90. `homologicalAlgebraEvaluateHomologyObject(value, point=None)` - Evaluate a homology object at a point, sample, or finite model. +91. `homologicalAlgebraComputeHomologyObject(value)` - Compute the central numerical or symbolic data of a homology object. +92. `homologicalAlgebraEstimateHomologyObject(value, samples=None)` - Estimate a homology object property from finite samples or approximations. +93. `homologicalAlgebraApproximateHomologyObject(value, tolerance=1e-9)` - Approximate a homology object with explicit tolerance controls. +94. `homologicalAlgebraTransformHomologyObject(value, mapping)` - Transform a homology object through a map, operator, or representation change. +95. `homologicalAlgebraSimplifyHomologyObject(value)` - Simplify a homology object without changing its mathematical meaning. +96. `homologicalAlgebraEnumerateHomologyObject(value, limit=None)` - Enumerate finite members, cases, or derived objects for a homology object. +97. `homologicalAlgebraClassifyHomologyObject(value)` - Classify a homology object by its standard Homological Algebra invariants. +98. `homologicalAlgebraTestEquivalenceHomologyObject(left, right)` - Test whether two homology object values are equivalent in Homological Algebra. +99. `homologicalAlgebraGenerateExampleHomologyObject(size=3)` - Generate a small documented example of a homology object. +100. `homologicalAlgebraDocumentHomologyObject(value)` - Return a structured explanation of a homology object and related assumptions. + +### Noncommutative Algebra + +Core object families: + +- noncommutative ring +- algebra element +- commutator +- left ideal +- right ideal + +Candidate functions: + +1. `noncommutativeAlgebraValidateNoncommutativeRing(value)` - Validate the noncommutative ring representation and domain rules for Noncommutative Algebra. +2. `noncommutativeAlgebraConstructNoncommutativeRing(*args)` - Construct a noncommutative ring from explicit inputs for Noncommutative Algebra. +3. `noncommutativeAlgebraNormalizeNoncommutativeRing(value)` - Normalize a noncommutative ring into the standard Noncommutative Algebra representation. +4. `noncommutativeAlgebraCanonicalizeNoncommutativeRing(value)` - Canonicalize a noncommutative ring so equivalent inputs share one form. +5. `noncommutativeAlgebraParseNoncommutativeRing(text)` - Parse a text or structured value into a noncommutative ring. +6. `noncommutativeAlgebraFormatNoncommutativeRing(value)` - Format a noncommutative ring for deterministic user-facing output. +7. `noncommutativeAlgebraCompareNoncommutativeRing(left, right)` - Compare two noncommutative ring values under the conventions of Noncommutative Algebra. +8. `noncommutativeAlgebraCombineNoncommutativeRing(left, right)` - Combine two noncommutative ring values with the natural operation for Noncommutative Algebra. +9. `noncommutativeAlgebraDecomposeNoncommutativeRing(value)` - Decompose a noncommutative ring into simpler or canonical components. +10. `noncommutativeAlgebraEvaluateNoncommutativeRing(value, point=None)` - Evaluate a noncommutative ring at a point, sample, or finite model. +11. `noncommutativeAlgebraComputeNoncommutativeRing(value)` - Compute the central numerical or symbolic data of a noncommutative ring. +12. `noncommutativeAlgebraEstimateNoncommutativeRing(value, samples=None)` - Estimate a noncommutative ring property from finite samples or approximations. +13. `noncommutativeAlgebraApproximateNoncommutativeRing(value, tolerance=1e-9)` - Approximate a noncommutative ring with explicit tolerance controls. +14. `noncommutativeAlgebraTransformNoncommutativeRing(value, mapping)` - Transform a noncommutative ring through a map, operator, or representation change. +15. `noncommutativeAlgebraSimplifyNoncommutativeRing(value)` - Simplify a noncommutative ring without changing its mathematical meaning. +16. `noncommutativeAlgebraEnumerateNoncommutativeRing(value, limit=None)` - Enumerate finite members, cases, or derived objects for a noncommutative ring. +17. `noncommutativeAlgebraClassifyNoncommutativeRing(value)` - Classify a noncommutative ring by its standard Noncommutative Algebra invariants. +18. `noncommutativeAlgebraTestEquivalenceNoncommutativeRing(left, right)` - Test whether two noncommutative ring values are equivalent in Noncommutative Algebra. +19. `noncommutativeAlgebraGenerateExampleNoncommutativeRing(size=3)` - Generate a small documented example of a noncommutative ring. +20. `noncommutativeAlgebraDocumentNoncommutativeRing(value)` - Return a structured explanation of a noncommutative ring and related assumptions. +21. `noncommutativeAlgebraValidateAlgebraElement(value)` - Validate the algebra element representation and domain rules for Noncommutative Algebra. +22. `noncommutativeAlgebraConstructAlgebraElement(*args)` - Construct a algebra element from explicit inputs for Noncommutative Algebra. +23. `noncommutativeAlgebraNormalizeAlgebraElement(value)` - Normalize a algebra element into the standard Noncommutative Algebra representation. +24. `noncommutativeAlgebraCanonicalizeAlgebraElement(value)` - Canonicalize a algebra element so equivalent inputs share one form. +25. `noncommutativeAlgebraParseAlgebraElement(text)` - Parse a text or structured value into a algebra element. +26. `noncommutativeAlgebraFormatAlgebraElement(value)` - Format a algebra element for deterministic user-facing output. +27. `noncommutativeAlgebraCompareAlgebraElement(left, right)` - Compare two algebra element values under the conventions of Noncommutative Algebra. +28. `noncommutativeAlgebraCombineAlgebraElement(left, right)` - Combine two algebra element values with the natural operation for Noncommutative Algebra. +29. `noncommutativeAlgebraDecomposeAlgebraElement(value)` - Decompose a algebra element into simpler or canonical components. +30. `noncommutativeAlgebraEvaluateAlgebraElement(value, point=None)` - Evaluate a algebra element at a point, sample, or finite model. +31. `noncommutativeAlgebraComputeAlgebraElement(value)` - Compute the central numerical or symbolic data of a algebra element. +32. `noncommutativeAlgebraEstimateAlgebraElement(value, samples=None)` - Estimate a algebra element property from finite samples or approximations. +33. `noncommutativeAlgebraApproximateAlgebraElement(value, tolerance=1e-9)` - Approximate a algebra element with explicit tolerance controls. +34. `noncommutativeAlgebraTransformAlgebraElement(value, mapping)` - Transform a algebra element through a map, operator, or representation change. +35. `noncommutativeAlgebraSimplifyAlgebraElement(value)` - Simplify a algebra element without changing its mathematical meaning. +36. `noncommutativeAlgebraEnumerateAlgebraElement(value, limit=None)` - Enumerate finite members, cases, or derived objects for a algebra element. +37. `noncommutativeAlgebraClassifyAlgebraElement(value)` - Classify a algebra element by its standard Noncommutative Algebra invariants. +38. `noncommutativeAlgebraTestEquivalenceAlgebraElement(left, right)` - Test whether two algebra element values are equivalent in Noncommutative Algebra. +39. `noncommutativeAlgebraGenerateExampleAlgebraElement(size=3)` - Generate a small documented example of a algebra element. +40. `noncommutativeAlgebraDocumentAlgebraElement(value)` - Return a structured explanation of a algebra element and related assumptions. +41. `noncommutativeAlgebraValidateCommutator(value)` - Validate the commutator representation and domain rules for Noncommutative Algebra. +42. `noncommutativeAlgebraConstructCommutator(*args)` - Construct a commutator from explicit inputs for Noncommutative Algebra. +43. `noncommutativeAlgebraNormalizeCommutator(value)` - Normalize a commutator into the standard Noncommutative Algebra representation. +44. `noncommutativeAlgebraCanonicalizeCommutator(value)` - Canonicalize a commutator so equivalent inputs share one form. +45. `noncommutativeAlgebraParseCommutator(text)` - Parse a text or structured value into a commutator. +46. `noncommutativeAlgebraFormatCommutator(value)` - Format a commutator for deterministic user-facing output. +47. `noncommutativeAlgebraCompareCommutator(left, right)` - Compare two commutator values under the conventions of Noncommutative Algebra. +48. `noncommutativeAlgebraCombineCommutator(left, right)` - Combine two commutator values with the natural operation for Noncommutative Algebra. +49. `noncommutativeAlgebraDecomposeCommutator(value)` - Decompose a commutator into simpler or canonical components. +50. `noncommutativeAlgebraEvaluateCommutator(value, point=None)` - Evaluate a commutator at a point, sample, or finite model. +51. `noncommutativeAlgebraComputeCommutator(value)` - Compute the central numerical or symbolic data of a commutator. +52. `noncommutativeAlgebraEstimateCommutator(value, samples=None)` - Estimate a commutator property from finite samples or approximations. +53. `noncommutativeAlgebraApproximateCommutator(value, tolerance=1e-9)` - Approximate a commutator with explicit tolerance controls. +54. `noncommutativeAlgebraTransformCommutator(value, mapping)` - Transform a commutator through a map, operator, or representation change. +55. `noncommutativeAlgebraSimplifyCommutator(value)` - Simplify a commutator without changing its mathematical meaning. +56. `noncommutativeAlgebraEnumerateCommutator(value, limit=None)` - Enumerate finite members, cases, or derived objects for a commutator. +57. `noncommutativeAlgebraClassifyCommutator(value)` - Classify a commutator by its standard Noncommutative Algebra invariants. +58. `noncommutativeAlgebraTestEquivalenceCommutator(left, right)` - Test whether two commutator values are equivalent in Noncommutative Algebra. +59. `noncommutativeAlgebraGenerateExampleCommutator(size=3)` - Generate a small documented example of a commutator. +60. `noncommutativeAlgebraDocumentCommutator(value)` - Return a structured explanation of a commutator and related assumptions. +61. `noncommutativeAlgebraValidateLeftIdeal(value)` - Validate the left ideal representation and domain rules for Noncommutative Algebra. +62. `noncommutativeAlgebraConstructLeftIdeal(*args)` - Construct a left ideal from explicit inputs for Noncommutative Algebra. +63. `noncommutativeAlgebraNormalizeLeftIdeal(value)` - Normalize a left ideal into the standard Noncommutative Algebra representation. +64. `noncommutativeAlgebraCanonicalizeLeftIdeal(value)` - Canonicalize a left ideal so equivalent inputs share one form. +65. `noncommutativeAlgebraParseLeftIdeal(text)` - Parse a text or structured value into a left ideal. +66. `noncommutativeAlgebraFormatLeftIdeal(value)` - Format a left ideal for deterministic user-facing output. +67. `noncommutativeAlgebraCompareLeftIdeal(left, right)` - Compare two left ideal values under the conventions of Noncommutative Algebra. +68. `noncommutativeAlgebraCombineLeftIdeal(left, right)` - Combine two left ideal values with the natural operation for Noncommutative Algebra. +69. `noncommutativeAlgebraDecomposeLeftIdeal(value)` - Decompose a left ideal into simpler or canonical components. +70. `noncommutativeAlgebraEvaluateLeftIdeal(value, point=None)` - Evaluate a left ideal at a point, sample, or finite model. +71. `noncommutativeAlgebraComputeLeftIdeal(value)` - Compute the central numerical or symbolic data of a left ideal. +72. `noncommutativeAlgebraEstimateLeftIdeal(value, samples=None)` - Estimate a left ideal property from finite samples or approximations. +73. `noncommutativeAlgebraApproximateLeftIdeal(value, tolerance=1e-9)` - Approximate a left ideal with explicit tolerance controls. +74. `noncommutativeAlgebraTransformLeftIdeal(value, mapping)` - Transform a left ideal through a map, operator, or representation change. +75. `noncommutativeAlgebraSimplifyLeftIdeal(value)` - Simplify a left ideal without changing its mathematical meaning. +76. `noncommutativeAlgebraEnumerateLeftIdeal(value, limit=None)` - Enumerate finite members, cases, or derived objects for a left ideal. +77. `noncommutativeAlgebraClassifyLeftIdeal(value)` - Classify a left ideal by its standard Noncommutative Algebra invariants. +78. `noncommutativeAlgebraTestEquivalenceLeftIdeal(left, right)` - Test whether two left ideal values are equivalent in Noncommutative Algebra. +79. `noncommutativeAlgebraGenerateExampleLeftIdeal(size=3)` - Generate a small documented example of a left ideal. +80. `noncommutativeAlgebraDocumentLeftIdeal(value)` - Return a structured explanation of a left ideal and related assumptions. +81. `noncommutativeAlgebraValidateRightIdeal(value)` - Validate the right ideal representation and domain rules for Noncommutative Algebra. +82. `noncommutativeAlgebraConstructRightIdeal(*args)` - Construct a right ideal from explicit inputs for Noncommutative Algebra. +83. `noncommutativeAlgebraNormalizeRightIdeal(value)` - Normalize a right ideal into the standard Noncommutative Algebra representation. +84. `noncommutativeAlgebraCanonicalizeRightIdeal(value)` - Canonicalize a right ideal so equivalent inputs share one form. +85. `noncommutativeAlgebraParseRightIdeal(text)` - Parse a text or structured value into a right ideal. +86. `noncommutativeAlgebraFormatRightIdeal(value)` - Format a right ideal for deterministic user-facing output. +87. `noncommutativeAlgebraCompareRightIdeal(left, right)` - Compare two right ideal values under the conventions of Noncommutative Algebra. +88. `noncommutativeAlgebraCombineRightIdeal(left, right)` - Combine two right ideal values with the natural operation for Noncommutative Algebra. +89. `noncommutativeAlgebraDecomposeRightIdeal(value)` - Decompose a right ideal into simpler or canonical components. +90. `noncommutativeAlgebraEvaluateRightIdeal(value, point=None)` - Evaluate a right ideal at a point, sample, or finite model. +91. `noncommutativeAlgebraComputeRightIdeal(value)` - Compute the central numerical or symbolic data of a right ideal. +92. `noncommutativeAlgebraEstimateRightIdeal(value, samples=None)` - Estimate a right ideal property from finite samples or approximations. +93. `noncommutativeAlgebraApproximateRightIdeal(value, tolerance=1e-9)` - Approximate a right ideal with explicit tolerance controls. +94. `noncommutativeAlgebraTransformRightIdeal(value, mapping)` - Transform a right ideal through a map, operator, or representation change. +95. `noncommutativeAlgebraSimplifyRightIdeal(value)` - Simplify a right ideal without changing its mathematical meaning. +96. `noncommutativeAlgebraEnumerateRightIdeal(value, limit=None)` - Enumerate finite members, cases, or derived objects for a right ideal. +97. `noncommutativeAlgebraClassifyRightIdeal(value)` - Classify a right ideal by its standard Noncommutative Algebra invariants. +98. `noncommutativeAlgebraTestEquivalenceRightIdeal(left, right)` - Test whether two right ideal values are equivalent in Noncommutative Algebra. +99. `noncommutativeAlgebraGenerateExampleRightIdeal(size=3)` - Generate a small documented example of a right ideal. +100. `noncommutativeAlgebraDocumentRightIdeal(value)` - Return a structured explanation of a right ideal and related assumptions. + +### Universal Algebra + +Core object families: + +- signature +- algebra +- identity law +- congruence +- homomorphism + +Candidate functions: + +1. `universalAlgebraValidateSignature(value)` - Validate the signature representation and domain rules for Universal Algebra. +2. `universalAlgebraConstructSignature(*args)` - Construct a signature from explicit inputs for Universal Algebra. +3. `universalAlgebraNormalizeSignature(value)` - Normalize a signature into the standard Universal Algebra representation. +4. `universalAlgebraCanonicalizeSignature(value)` - Canonicalize a signature so equivalent inputs share one form. +5. `universalAlgebraParseSignature(text)` - Parse a text or structured value into a signature. +6. `universalAlgebraFormatSignature(value)` - Format a signature for deterministic user-facing output. +7. `universalAlgebraCompareSignature(left, right)` - Compare two signature values under the conventions of Universal Algebra. +8. `universalAlgebraCombineSignature(left, right)` - Combine two signature values with the natural operation for Universal Algebra. +9. `universalAlgebraDecomposeSignature(value)` - Decompose a signature into simpler or canonical components. +10. `universalAlgebraEvaluateSignature(value, point=None)` - Evaluate a signature at a point, sample, or finite model. +11. `universalAlgebraComputeSignature(value)` - Compute the central numerical or symbolic data of a signature. +12. `universalAlgebraEstimateSignature(value, samples=None)` - Estimate a signature property from finite samples or approximations. +13. `universalAlgebraApproximateSignature(value, tolerance=1e-9)` - Approximate a signature with explicit tolerance controls. +14. `universalAlgebraTransformSignature(value, mapping)` - Transform a signature through a map, operator, or representation change. +15. `universalAlgebraSimplifySignature(value)` - Simplify a signature without changing its mathematical meaning. +16. `universalAlgebraEnumerateSignature(value, limit=None)` - Enumerate finite members, cases, or derived objects for a signature. +17. `universalAlgebraClassifySignature(value)` - Classify a signature by its standard Universal Algebra invariants. +18. `universalAlgebraTestEquivalenceSignature(left, right)` - Test whether two signature values are equivalent in Universal Algebra. +19. `universalAlgebraGenerateExampleSignature(size=3)` - Generate a small documented example of a signature. +20. `universalAlgebraDocumentSignature(value)` - Return a structured explanation of a signature and related assumptions. +21. `universalAlgebraValidateAlgebra(value)` - Validate the algebra representation and domain rules for Universal Algebra. +22. `universalAlgebraConstructAlgebra(*args)` - Construct a algebra from explicit inputs for Universal Algebra. +23. `universalAlgebraNormalizeAlgebra(value)` - Normalize a algebra into the standard Universal Algebra representation. +24. `universalAlgebraCanonicalizeAlgebra(value)` - Canonicalize a algebra so equivalent inputs share one form. +25. `universalAlgebraParseAlgebra(text)` - Parse a text or structured value into a algebra. +26. `universalAlgebraFormatAlgebra(value)` - Format a algebra for deterministic user-facing output. +27. `universalAlgebraCompareAlgebra(left, right)` - Compare two algebra values under the conventions of Universal Algebra. +28. `universalAlgebraCombineAlgebra(left, right)` - Combine two algebra values with the natural operation for Universal Algebra. +29. `universalAlgebraDecomposeAlgebra(value)` - Decompose a algebra into simpler or canonical components. +30. `universalAlgebraEvaluateAlgebra(value, point=None)` - Evaluate a algebra at a point, sample, or finite model. +31. `universalAlgebraComputeAlgebra(value)` - Compute the central numerical or symbolic data of a algebra. +32. `universalAlgebraEstimateAlgebra(value, samples=None)` - Estimate a algebra property from finite samples or approximations. +33. `universalAlgebraApproximateAlgebra(value, tolerance=1e-9)` - Approximate a algebra with explicit tolerance controls. +34. `universalAlgebraTransformAlgebra(value, mapping)` - Transform a algebra through a map, operator, or representation change. +35. `universalAlgebraSimplifyAlgebra(value)` - Simplify a algebra without changing its mathematical meaning. +36. `universalAlgebraEnumerateAlgebra(value, limit=None)` - Enumerate finite members, cases, or derived objects for a algebra. +37. `universalAlgebraClassifyAlgebra(value)` - Classify a algebra by its standard Universal Algebra invariants. +38. `universalAlgebraTestEquivalenceAlgebra(left, right)` - Test whether two algebra values are equivalent in Universal Algebra. +39. `universalAlgebraGenerateExampleAlgebra(size=3)` - Generate a small documented example of a algebra. +40. `universalAlgebraDocumentAlgebra(value)` - Return a structured explanation of a algebra and related assumptions. +41. `universalAlgebraValidateIdentityLaw(value)` - Validate the identity law representation and domain rules for Universal Algebra. +42. `universalAlgebraConstructIdentityLaw(*args)` - Construct a identity law from explicit inputs for Universal Algebra. +43. `universalAlgebraNormalizeIdentityLaw(value)` - Normalize a identity law into the standard Universal Algebra representation. +44. `universalAlgebraCanonicalizeIdentityLaw(value)` - Canonicalize a identity law so equivalent inputs share one form. +45. `universalAlgebraParseIdentityLaw(text)` - Parse a text or structured value into a identity law. +46. `universalAlgebraFormatIdentityLaw(value)` - Format a identity law for deterministic user-facing output. +47. `universalAlgebraCompareIdentityLaw(left, right)` - Compare two identity law values under the conventions of Universal Algebra. +48. `universalAlgebraCombineIdentityLaw(left, right)` - Combine two identity law values with the natural operation for Universal Algebra. +49. `universalAlgebraDecomposeIdentityLaw(value)` - Decompose a identity law into simpler or canonical components. +50. `universalAlgebraEvaluateIdentityLaw(value, point=None)` - Evaluate a identity law at a point, sample, or finite model. +51. `universalAlgebraComputeIdentityLaw(value)` - Compute the central numerical or symbolic data of a identity law. +52. `universalAlgebraEstimateIdentityLaw(value, samples=None)` - Estimate a identity law property from finite samples or approximations. +53. `universalAlgebraApproximateIdentityLaw(value, tolerance=1e-9)` - Approximate a identity law with explicit tolerance controls. +54. `universalAlgebraTransformIdentityLaw(value, mapping)` - Transform a identity law through a map, operator, or representation change. +55. `universalAlgebraSimplifyIdentityLaw(value)` - Simplify a identity law without changing its mathematical meaning. +56. `universalAlgebraEnumerateIdentityLaw(value, limit=None)` - Enumerate finite members, cases, or derived objects for a identity law. +57. `universalAlgebraClassifyIdentityLaw(value)` - Classify a identity law by its standard Universal Algebra invariants. +58. `universalAlgebraTestEquivalenceIdentityLaw(left, right)` - Test whether two identity law values are equivalent in Universal Algebra. +59. `universalAlgebraGenerateExampleIdentityLaw(size=3)` - Generate a small documented example of a identity law. +60. `universalAlgebraDocumentIdentityLaw(value)` - Return a structured explanation of a identity law and related assumptions. +61. `universalAlgebraValidateCongruence(value)` - Validate the congruence representation and domain rules for Universal Algebra. +62. `universalAlgebraConstructCongruence(*args)` - Construct a congruence from explicit inputs for Universal Algebra. +63. `universalAlgebraNormalizeCongruence(value)` - Normalize a congruence into the standard Universal Algebra representation. +64. `universalAlgebraCanonicalizeCongruence(value)` - Canonicalize a congruence so equivalent inputs share one form. +65. `universalAlgebraParseCongruence(text)` - Parse a text or structured value into a congruence. +66. `universalAlgebraFormatCongruence(value)` - Format a congruence for deterministic user-facing output. +67. `universalAlgebraCompareCongruence(left, right)` - Compare two congruence values under the conventions of Universal Algebra. +68. `universalAlgebraCombineCongruence(left, right)` - Combine two congruence values with the natural operation for Universal Algebra. +69. `universalAlgebraDecomposeCongruence(value)` - Decompose a congruence into simpler or canonical components. +70. `universalAlgebraEvaluateCongruence(value, point=None)` - Evaluate a congruence at a point, sample, or finite model. +71. `universalAlgebraComputeCongruence(value)` - Compute the central numerical or symbolic data of a congruence. +72. `universalAlgebraEstimateCongruence(value, samples=None)` - Estimate a congruence property from finite samples or approximations. +73. `universalAlgebraApproximateCongruence(value, tolerance=1e-9)` - Approximate a congruence with explicit tolerance controls. +74. `universalAlgebraTransformCongruence(value, mapping)` - Transform a congruence through a map, operator, or representation change. +75. `universalAlgebraSimplifyCongruence(value)` - Simplify a congruence without changing its mathematical meaning. +76. `universalAlgebraEnumerateCongruence(value, limit=None)` - Enumerate finite members, cases, or derived objects for a congruence. +77. `universalAlgebraClassifyCongruence(value)` - Classify a congruence by its standard Universal Algebra invariants. +78. `universalAlgebraTestEquivalenceCongruence(left, right)` - Test whether two congruence values are equivalent in Universal Algebra. +79. `universalAlgebraGenerateExampleCongruence(size=3)` - Generate a small documented example of a congruence. +80. `universalAlgebraDocumentCongruence(value)` - Return a structured explanation of a congruence and related assumptions. +81. `universalAlgebraValidateHomomorphism(value)` - Validate the homomorphism representation and domain rules for Universal Algebra. +82. `universalAlgebraConstructHomomorphism(*args)` - Construct a homomorphism from explicit inputs for Universal Algebra. +83. `universalAlgebraNormalizeHomomorphism(value)` - Normalize a homomorphism into the standard Universal Algebra representation. +84. `universalAlgebraCanonicalizeHomomorphism(value)` - Canonicalize a homomorphism so equivalent inputs share one form. +85. `universalAlgebraParseHomomorphism(text)` - Parse a text or structured value into a homomorphism. +86. `universalAlgebraFormatHomomorphism(value)` - Format a homomorphism for deterministic user-facing output. +87. `universalAlgebraCompareHomomorphism(left, right)` - Compare two homomorphism values under the conventions of Universal Algebra. +88. `universalAlgebraCombineHomomorphism(left, right)` - Combine two homomorphism values with the natural operation for Universal Algebra. +89. `universalAlgebraDecomposeHomomorphism(value)` - Decompose a homomorphism into simpler or canonical components. +90. `universalAlgebraEvaluateHomomorphism(value, point=None)` - Evaluate a homomorphism at a point, sample, or finite model. +91. `universalAlgebraComputeHomomorphism(value)` - Compute the central numerical or symbolic data of a homomorphism. +92. `universalAlgebraEstimateHomomorphism(value, samples=None)` - Estimate a homomorphism property from finite samples or approximations. +93. `universalAlgebraApproximateHomomorphism(value, tolerance=1e-9)` - Approximate a homomorphism with explicit tolerance controls. +94. `universalAlgebraTransformHomomorphism(value, mapping)` - Transform a homomorphism through a map, operator, or representation change. +95. `universalAlgebraSimplifyHomomorphism(value)` - Simplify a homomorphism without changing its mathematical meaning. +96. `universalAlgebraEnumerateHomomorphism(value, limit=None)` - Enumerate finite members, cases, or derived objects for a homomorphism. +97. `universalAlgebraClassifyHomomorphism(value)` - Classify a homomorphism by its standard Universal Algebra invariants. +98. `universalAlgebraTestEquivalenceHomomorphism(left, right)` - Test whether two homomorphism values are equivalent in Universal Algebra. +99. `universalAlgebraGenerateExampleHomomorphism(size=3)` - Generate a small documented example of a homomorphism. +100. `universalAlgebraDocumentHomomorphism(value)` - Return a structured explanation of a homomorphism and related assumptions. + +### Lattice Theory + +Core object families: + +- poset +- meet operation +- join operation +- lattice +- complete lattice + +Candidate functions: + +1. `latticeTheoryValidatePoset(value)` - Validate the poset representation and domain rules for Lattice Theory. +2. `latticeTheoryConstructPoset(*args)` - Construct a poset from explicit inputs for Lattice Theory. +3. `latticeTheoryNormalizePoset(value)` - Normalize a poset into the standard Lattice Theory representation. +4. `latticeTheoryCanonicalizePoset(value)` - Canonicalize a poset so equivalent inputs share one form. +5. `latticeTheoryParsePoset(text)` - Parse a text or structured value into a poset. +6. `latticeTheoryFormatPoset(value)` - Format a poset for deterministic user-facing output. +7. `latticeTheoryComparePoset(left, right)` - Compare two poset values under the conventions of Lattice Theory. +8. `latticeTheoryCombinePoset(left, right)` - Combine two poset values with the natural operation for Lattice Theory. +9. `latticeTheoryDecomposePoset(value)` - Decompose a poset into simpler or canonical components. +10. `latticeTheoryEvaluatePoset(value, point=None)` - Evaluate a poset at a point, sample, or finite model. +11. `latticeTheoryComputePoset(value)` - Compute the central numerical or symbolic data of a poset. +12. `latticeTheoryEstimatePoset(value, samples=None)` - Estimate a poset property from finite samples or approximations. +13. `latticeTheoryApproximatePoset(value, tolerance=1e-9)` - Approximate a poset with explicit tolerance controls. +14. `latticeTheoryTransformPoset(value, mapping)` - Transform a poset through a map, operator, or representation change. +15. `latticeTheorySimplifyPoset(value)` - Simplify a poset without changing its mathematical meaning. +16. `latticeTheoryEnumeratePoset(value, limit=None)` - Enumerate finite members, cases, or derived objects for a poset. +17. `latticeTheoryClassifyPoset(value)` - Classify a poset by its standard Lattice Theory invariants. +18. `latticeTheoryTestEquivalencePoset(left, right)` - Test whether two poset values are equivalent in Lattice Theory. +19. `latticeTheoryGenerateExamplePoset(size=3)` - Generate a small documented example of a poset. +20. `latticeTheoryDocumentPoset(value)` - Return a structured explanation of a poset and related assumptions. +21. `latticeTheoryValidateMeetOperation(value)` - Validate the meet operation representation and domain rules for Lattice Theory. +22. `latticeTheoryConstructMeetOperation(*args)` - Construct a meet operation from explicit inputs for Lattice Theory. +23. `latticeTheoryNormalizeMeetOperation(value)` - Normalize a meet operation into the standard Lattice Theory representation. +24. `latticeTheoryCanonicalizeMeetOperation(value)` - Canonicalize a meet operation so equivalent inputs share one form. +25. `latticeTheoryParseMeetOperation(text)` - Parse a text or structured value into a meet operation. +26. `latticeTheoryFormatMeetOperation(value)` - Format a meet operation for deterministic user-facing output. +27. `latticeTheoryCompareMeetOperation(left, right)` - Compare two meet operation values under the conventions of Lattice Theory. +28. `latticeTheoryCombineMeetOperation(left, right)` - Combine two meet operation values with the natural operation for Lattice Theory. +29. `latticeTheoryDecomposeMeetOperation(value)` - Decompose a meet operation into simpler or canonical components. +30. `latticeTheoryEvaluateMeetOperation(value, point=None)` - Evaluate a meet operation at a point, sample, or finite model. +31. `latticeTheoryComputeMeetOperation(value)` - Compute the central numerical or symbolic data of a meet operation. +32. `latticeTheoryEstimateMeetOperation(value, samples=None)` - Estimate a meet operation property from finite samples or approximations. +33. `latticeTheoryApproximateMeetOperation(value, tolerance=1e-9)` - Approximate a meet operation with explicit tolerance controls. +34. `latticeTheoryTransformMeetOperation(value, mapping)` - Transform a meet operation through a map, operator, or representation change. +35. `latticeTheorySimplifyMeetOperation(value)` - Simplify a meet operation without changing its mathematical meaning. +36. `latticeTheoryEnumerateMeetOperation(value, limit=None)` - Enumerate finite members, cases, or derived objects for a meet operation. +37. `latticeTheoryClassifyMeetOperation(value)` - Classify a meet operation by its standard Lattice Theory invariants. +38. `latticeTheoryTestEquivalenceMeetOperation(left, right)` - Test whether two meet operation values are equivalent in Lattice Theory. +39. `latticeTheoryGenerateExampleMeetOperation(size=3)` - Generate a small documented example of a meet operation. +40. `latticeTheoryDocumentMeetOperation(value)` - Return a structured explanation of a meet operation and related assumptions. +41. `latticeTheoryValidateJoinOperation(value)` - Validate the join operation representation and domain rules for Lattice Theory. +42. `latticeTheoryConstructJoinOperation(*args)` - Construct a join operation from explicit inputs for Lattice Theory. +43. `latticeTheoryNormalizeJoinOperation(value)` - Normalize a join operation into the standard Lattice Theory representation. +44. `latticeTheoryCanonicalizeJoinOperation(value)` - Canonicalize a join operation so equivalent inputs share one form. +45. `latticeTheoryParseJoinOperation(text)` - Parse a text or structured value into a join operation. +46. `latticeTheoryFormatJoinOperation(value)` - Format a join operation for deterministic user-facing output. +47. `latticeTheoryCompareJoinOperation(left, right)` - Compare two join operation values under the conventions of Lattice Theory. +48. `latticeTheoryCombineJoinOperation(left, right)` - Combine two join operation values with the natural operation for Lattice Theory. +49. `latticeTheoryDecomposeJoinOperation(value)` - Decompose a join operation into simpler or canonical components. +50. `latticeTheoryEvaluateJoinOperation(value, point=None)` - Evaluate a join operation at a point, sample, or finite model. +51. `latticeTheoryComputeJoinOperation(value)` - Compute the central numerical or symbolic data of a join operation. +52. `latticeTheoryEstimateJoinOperation(value, samples=None)` - Estimate a join operation property from finite samples or approximations. +53. `latticeTheoryApproximateJoinOperation(value, tolerance=1e-9)` - Approximate a join operation with explicit tolerance controls. +54. `latticeTheoryTransformJoinOperation(value, mapping)` - Transform a join operation through a map, operator, or representation change. +55. `latticeTheorySimplifyJoinOperation(value)` - Simplify a join operation without changing its mathematical meaning. +56. `latticeTheoryEnumerateJoinOperation(value, limit=None)` - Enumerate finite members, cases, or derived objects for a join operation. +57. `latticeTheoryClassifyJoinOperation(value)` - Classify a join operation by its standard Lattice Theory invariants. +58. `latticeTheoryTestEquivalenceJoinOperation(left, right)` - Test whether two join operation values are equivalent in Lattice Theory. +59. `latticeTheoryGenerateExampleJoinOperation(size=3)` - Generate a small documented example of a join operation. +60. `latticeTheoryDocumentJoinOperation(value)` - Return a structured explanation of a join operation and related assumptions. +61. `latticeTheoryValidateLattice(value)` - Validate the lattice representation and domain rules for Lattice Theory. +62. `latticeTheoryConstructLattice(*args)` - Construct a lattice from explicit inputs for Lattice Theory. +63. `latticeTheoryNormalizeLattice(value)` - Normalize a lattice into the standard Lattice Theory representation. +64. `latticeTheoryCanonicalizeLattice(value)` - Canonicalize a lattice so equivalent inputs share one form. +65. `latticeTheoryParseLattice(text)` - Parse a text or structured value into a lattice. +66. `latticeTheoryFormatLattice(value)` - Format a lattice for deterministic user-facing output. +67. `latticeTheoryCompareLattice(left, right)` - Compare two lattice values under the conventions of Lattice Theory. +68. `latticeTheoryCombineLattice(left, right)` - Combine two lattice values with the natural operation for Lattice Theory. +69. `latticeTheoryDecomposeLattice(value)` - Decompose a lattice into simpler or canonical components. +70. `latticeTheoryEvaluateLattice(value, point=None)` - Evaluate a lattice at a point, sample, or finite model. +71. `latticeTheoryComputeLattice(value)` - Compute the central numerical or symbolic data of a lattice. +72. `latticeTheoryEstimateLattice(value, samples=None)` - Estimate a lattice property from finite samples or approximations. +73. `latticeTheoryApproximateLattice(value, tolerance=1e-9)` - Approximate a lattice with explicit tolerance controls. +74. `latticeTheoryTransformLattice(value, mapping)` - Transform a lattice through a map, operator, or representation change. +75. `latticeTheorySimplifyLattice(value)` - Simplify a lattice without changing its mathematical meaning. +76. `latticeTheoryEnumerateLattice(value, limit=None)` - Enumerate finite members, cases, or derived objects for a lattice. +77. `latticeTheoryClassifyLattice(value)` - Classify a lattice by its standard Lattice Theory invariants. +78. `latticeTheoryTestEquivalenceLattice(left, right)` - Test whether two lattice values are equivalent in Lattice Theory. +79. `latticeTheoryGenerateExampleLattice(size=3)` - Generate a small documented example of a lattice. +80. `latticeTheoryDocumentLattice(value)` - Return a structured explanation of a lattice and related assumptions. +81. `latticeTheoryValidateCompleteLattice(value)` - Validate the complete lattice representation and domain rules for Lattice Theory. +82. `latticeTheoryConstructCompleteLattice(*args)` - Construct a complete lattice from explicit inputs for Lattice Theory. +83. `latticeTheoryNormalizeCompleteLattice(value)` - Normalize a complete lattice into the standard Lattice Theory representation. +84. `latticeTheoryCanonicalizeCompleteLattice(value)` - Canonicalize a complete lattice so equivalent inputs share one form. +85. `latticeTheoryParseCompleteLattice(text)` - Parse a text or structured value into a complete lattice. +86. `latticeTheoryFormatCompleteLattice(value)` - Format a complete lattice for deterministic user-facing output. +87. `latticeTheoryCompareCompleteLattice(left, right)` - Compare two complete lattice values under the conventions of Lattice Theory. +88. `latticeTheoryCombineCompleteLattice(left, right)` - Combine two complete lattice values with the natural operation for Lattice Theory. +89. `latticeTheoryDecomposeCompleteLattice(value)` - Decompose a complete lattice into simpler or canonical components. +90. `latticeTheoryEvaluateCompleteLattice(value, point=None)` - Evaluate a complete lattice at a point, sample, or finite model. +91. `latticeTheoryComputeCompleteLattice(value)` - Compute the central numerical or symbolic data of a complete lattice. +92. `latticeTheoryEstimateCompleteLattice(value, samples=None)` - Estimate a complete lattice property from finite samples or approximations. +93. `latticeTheoryApproximateCompleteLattice(value, tolerance=1e-9)` - Approximate a complete lattice with explicit tolerance controls. +94. `latticeTheoryTransformCompleteLattice(value, mapping)` - Transform a complete lattice through a map, operator, or representation change. +95. `latticeTheorySimplifyCompleteLattice(value)` - Simplify a complete lattice without changing its mathematical meaning. +96. `latticeTheoryEnumerateCompleteLattice(value, limit=None)` - Enumerate finite members, cases, or derived objects for a complete lattice. +97. `latticeTheoryClassifyCompleteLattice(value)` - Classify a complete lattice by its standard Lattice Theory invariants. +98. `latticeTheoryTestEquivalenceCompleteLattice(left, right)` - Test whether two complete lattice values are equivalent in Lattice Theory. +99. `latticeTheoryGenerateExampleCompleteLattice(size=3)` - Generate a small documented example of a complete lattice. +100. `latticeTheoryDocumentCompleteLattice(value)` - Return a structured explanation of a complete lattice and related assumptions. + +### Order Theory + +Core object families: + +- ordered set +- chain +- antichain +- minimal element +- order relation + +Candidate functions: + +1. `orderTheoryValidateOrderedSet(value)` - Validate the ordered set representation and domain rules for Order Theory. +2. `orderTheoryConstructOrderedSet(*args)` - Construct a ordered set from explicit inputs for Order Theory. +3. `orderTheoryNormalizeOrderedSet(value)` - Normalize a ordered set into the standard Order Theory representation. +4. `orderTheoryCanonicalizeOrderedSet(value)` - Canonicalize a ordered set so equivalent inputs share one form. +5. `orderTheoryParseOrderedSet(text)` - Parse a text or structured value into a ordered set. +6. `orderTheoryFormatOrderedSet(value)` - Format a ordered set for deterministic user-facing output. +7. `orderTheoryCompareOrderedSet(left, right)` - Compare two ordered set values under the conventions of Order Theory. +8. `orderTheoryCombineOrderedSet(left, right)` - Combine two ordered set values with the natural operation for Order Theory. +9. `orderTheoryDecomposeOrderedSet(value)` - Decompose a ordered set into simpler or canonical components. +10. `orderTheoryEvaluateOrderedSet(value, point=None)` - Evaluate a ordered set at a point, sample, or finite model. +11. `orderTheoryComputeOrderedSet(value)` - Compute the central numerical or symbolic data of a ordered set. +12. `orderTheoryEstimateOrderedSet(value, samples=None)` - Estimate a ordered set property from finite samples or approximations. +13. `orderTheoryApproximateOrderedSet(value, tolerance=1e-9)` - Approximate a ordered set with explicit tolerance controls. +14. `orderTheoryTransformOrderedSet(value, mapping)` - Transform a ordered set through a map, operator, or representation change. +15. `orderTheorySimplifyOrderedSet(value)` - Simplify a ordered set without changing its mathematical meaning. +16. `orderTheoryEnumerateOrderedSet(value, limit=None)` - Enumerate finite members, cases, or derived objects for a ordered set. +17. `orderTheoryClassifyOrderedSet(value)` - Classify a ordered set by its standard Order Theory invariants. +18. `orderTheoryTestEquivalenceOrderedSet(left, right)` - Test whether two ordered set values are equivalent in Order Theory. +19. `orderTheoryGenerateExampleOrderedSet(size=3)` - Generate a small documented example of a ordered set. +20. `orderTheoryDocumentOrderedSet(value)` - Return a structured explanation of a ordered set and related assumptions. +21. `orderTheoryValidateChain(value)` - Validate the chain representation and domain rules for Order Theory. +22. `orderTheoryConstructChain(*args)` - Construct a chain from explicit inputs for Order Theory. +23. `orderTheoryNormalizeChain(value)` - Normalize a chain into the standard Order Theory representation. +24. `orderTheoryCanonicalizeChain(value)` - Canonicalize a chain so equivalent inputs share one form. +25. `orderTheoryParseChain(text)` - Parse a text or structured value into a chain. +26. `orderTheoryFormatChain(value)` - Format a chain for deterministic user-facing output. +27. `orderTheoryCompareChain(left, right)` - Compare two chain values under the conventions of Order Theory. +28. `orderTheoryCombineChain(left, right)` - Combine two chain values with the natural operation for Order Theory. +29. `orderTheoryDecomposeChain(value)` - Decompose a chain into simpler or canonical components. +30. `orderTheoryEvaluateChain(value, point=None)` - Evaluate a chain at a point, sample, or finite model. +31. `orderTheoryComputeChain(value)` - Compute the central numerical or symbolic data of a chain. +32. `orderTheoryEstimateChain(value, samples=None)` - Estimate a chain property from finite samples or approximations. +33. `orderTheoryApproximateChain(value, tolerance=1e-9)` - Approximate a chain with explicit tolerance controls. +34. `orderTheoryTransformChain(value, mapping)` - Transform a chain through a map, operator, or representation change. +35. `orderTheorySimplifyChain(value)` - Simplify a chain without changing its mathematical meaning. +36. `orderTheoryEnumerateChain(value, limit=None)` - Enumerate finite members, cases, or derived objects for a chain. +37. `orderTheoryClassifyChain(value)` - Classify a chain by its standard Order Theory invariants. +38. `orderTheoryTestEquivalenceChain(left, right)` - Test whether two chain values are equivalent in Order Theory. +39. `orderTheoryGenerateExampleChain(size=3)` - Generate a small documented example of a chain. +40. `orderTheoryDocumentChain(value)` - Return a structured explanation of a chain and related assumptions. +41. `orderTheoryValidateAntichain(value)` - Validate the antichain representation and domain rules for Order Theory. +42. `orderTheoryConstructAntichain(*args)` - Construct a antichain from explicit inputs for Order Theory. +43. `orderTheoryNormalizeAntichain(value)` - Normalize a antichain into the standard Order Theory representation. +44. `orderTheoryCanonicalizeAntichain(value)` - Canonicalize a antichain so equivalent inputs share one form. +45. `orderTheoryParseAntichain(text)` - Parse a text or structured value into a antichain. +46. `orderTheoryFormatAntichain(value)` - Format a antichain for deterministic user-facing output. +47. `orderTheoryCompareAntichain(left, right)` - Compare two antichain values under the conventions of Order Theory. +48. `orderTheoryCombineAntichain(left, right)` - Combine two antichain values with the natural operation for Order Theory. +49. `orderTheoryDecomposeAntichain(value)` - Decompose a antichain into simpler or canonical components. +50. `orderTheoryEvaluateAntichain(value, point=None)` - Evaluate a antichain at a point, sample, or finite model. +51. `orderTheoryComputeAntichain(value)` - Compute the central numerical or symbolic data of a antichain. +52. `orderTheoryEstimateAntichain(value, samples=None)` - Estimate a antichain property from finite samples or approximations. +53. `orderTheoryApproximateAntichain(value, tolerance=1e-9)` - Approximate a antichain with explicit tolerance controls. +54. `orderTheoryTransformAntichain(value, mapping)` - Transform a antichain through a map, operator, or representation change. +55. `orderTheorySimplifyAntichain(value)` - Simplify a antichain without changing its mathematical meaning. +56. `orderTheoryEnumerateAntichain(value, limit=None)` - Enumerate finite members, cases, or derived objects for a antichain. +57. `orderTheoryClassifyAntichain(value)` - Classify a antichain by its standard Order Theory invariants. +58. `orderTheoryTestEquivalenceAntichain(left, right)` - Test whether two antichain values are equivalent in Order Theory. +59. `orderTheoryGenerateExampleAntichain(size=3)` - Generate a small documented example of a antichain. +60. `orderTheoryDocumentAntichain(value)` - Return a structured explanation of a antichain and related assumptions. +61. `orderTheoryValidateMinimalElement(value)` - Validate the minimal element representation and domain rules for Order Theory. +62. `orderTheoryConstructMinimalElement(*args)` - Construct a minimal element from explicit inputs for Order Theory. +63. `orderTheoryNormalizeMinimalElement(value)` - Normalize a minimal element into the standard Order Theory representation. +64. `orderTheoryCanonicalizeMinimalElement(value)` - Canonicalize a minimal element so equivalent inputs share one form. +65. `orderTheoryParseMinimalElement(text)` - Parse a text or structured value into a minimal element. +66. `orderTheoryFormatMinimalElement(value)` - Format a minimal element for deterministic user-facing output. +67. `orderTheoryCompareMinimalElement(left, right)` - Compare two minimal element values under the conventions of Order Theory. +68. `orderTheoryCombineMinimalElement(left, right)` - Combine two minimal element values with the natural operation for Order Theory. +69. `orderTheoryDecomposeMinimalElement(value)` - Decompose a minimal element into simpler or canonical components. +70. `orderTheoryEvaluateMinimalElement(value, point=None)` - Evaluate a minimal element at a point, sample, or finite model. +71. `orderTheoryComputeMinimalElement(value)` - Compute the central numerical or symbolic data of a minimal element. +72. `orderTheoryEstimateMinimalElement(value, samples=None)` - Estimate a minimal element property from finite samples or approximations. +73. `orderTheoryApproximateMinimalElement(value, tolerance=1e-9)` - Approximate a minimal element with explicit tolerance controls. +74. `orderTheoryTransformMinimalElement(value, mapping)` - Transform a minimal element through a map, operator, or representation change. +75. `orderTheorySimplifyMinimalElement(value)` - Simplify a minimal element without changing its mathematical meaning. +76. `orderTheoryEnumerateMinimalElement(value, limit=None)` - Enumerate finite members, cases, or derived objects for a minimal element. +77. `orderTheoryClassifyMinimalElement(value)` - Classify a minimal element by its standard Order Theory invariants. +78. `orderTheoryTestEquivalenceMinimalElement(left, right)` - Test whether two minimal element values are equivalent in Order Theory. +79. `orderTheoryGenerateExampleMinimalElement(size=3)` - Generate a small documented example of a minimal element. +80. `orderTheoryDocumentMinimalElement(value)` - Return a structured explanation of a minimal element and related assumptions. +81. `orderTheoryValidateOrderRelation(value)` - Validate the order relation representation and domain rules for Order Theory. +82. `orderTheoryConstructOrderRelation(*args)` - Construct a order relation from explicit inputs for Order Theory. +83. `orderTheoryNormalizeOrderRelation(value)` - Normalize a order relation into the standard Order Theory representation. +84. `orderTheoryCanonicalizeOrderRelation(value)` - Canonicalize a order relation so equivalent inputs share one form. +85. `orderTheoryParseOrderRelation(text)` - Parse a text or structured value into a order relation. +86. `orderTheoryFormatOrderRelation(value)` - Format a order relation for deterministic user-facing output. +87. `orderTheoryCompareOrderRelation(left, right)` - Compare two order relation values under the conventions of Order Theory. +88. `orderTheoryCombineOrderRelation(left, right)` - Combine two order relation values with the natural operation for Order Theory. +89. `orderTheoryDecomposeOrderRelation(value)` - Decompose a order relation into simpler or canonical components. +90. `orderTheoryEvaluateOrderRelation(value, point=None)` - Evaluate a order relation at a point, sample, or finite model. +91. `orderTheoryComputeOrderRelation(value)` - Compute the central numerical or symbolic data of a order relation. +92. `orderTheoryEstimateOrderRelation(value, samples=None)` - Estimate a order relation property from finite samples or approximations. +93. `orderTheoryApproximateOrderRelation(value, tolerance=1e-9)` - Approximate a order relation with explicit tolerance controls. +94. `orderTheoryTransformOrderRelation(value, mapping)` - Transform a order relation through a map, operator, or representation change. +95. `orderTheorySimplifyOrderRelation(value)` - Simplify a order relation without changing its mathematical meaning. +96. `orderTheoryEnumerateOrderRelation(value, limit=None)` - Enumerate finite members, cases, or derived objects for a order relation. +97. `orderTheoryClassifyOrderRelation(value)` - Classify a order relation by its standard Order Theory invariants. +98. `orderTheoryTestEquivalenceOrderRelation(left, right)` - Test whether two order relation values are equivalent in Order Theory. +99. `orderTheoryGenerateExampleOrderRelation(size=3)` - Generate a small documented example of a order relation. +100. `orderTheoryDocumentOrderRelation(value)` - Return a structured explanation of a order relation and related assumptions. + +### Model Theory + +Core object families: + +- structure +- language +- term +- formula +- model + +Candidate functions: + +1. `modelTheoryValidateStructure(value)` - Validate the structure representation and domain rules for Model Theory. +2. `modelTheoryConstructStructure(*args)` - Construct a structure from explicit inputs for Model Theory. +3. `modelTheoryNormalizeStructure(value)` - Normalize a structure into the standard Model Theory representation. +4. `modelTheoryCanonicalizeStructure(value)` - Canonicalize a structure so equivalent inputs share one form. +5. `modelTheoryParseStructure(text)` - Parse a text or structured value into a structure. +6. `modelTheoryFormatStructure(value)` - Format a structure for deterministic user-facing output. +7. `modelTheoryCompareStructure(left, right)` - Compare two structure values under the conventions of Model Theory. +8. `modelTheoryCombineStructure(left, right)` - Combine two structure values with the natural operation for Model Theory. +9. `modelTheoryDecomposeStructure(value)` - Decompose a structure into simpler or canonical components. +10. `modelTheoryEvaluateStructure(value, point=None)` - Evaluate a structure at a point, sample, or finite model. +11. `modelTheoryComputeStructure(value)` - Compute the central numerical or symbolic data of a structure. +12. `modelTheoryEstimateStructure(value, samples=None)` - Estimate a structure property from finite samples or approximations. +13. `modelTheoryApproximateStructure(value, tolerance=1e-9)` - Approximate a structure with explicit tolerance controls. +14. `modelTheoryTransformStructure(value, mapping)` - Transform a structure through a map, operator, or representation change. +15. `modelTheorySimplifyStructure(value)` - Simplify a structure without changing its mathematical meaning. +16. `modelTheoryEnumerateStructure(value, limit=None)` - Enumerate finite members, cases, or derived objects for a structure. +17. `modelTheoryClassifyStructure(value)` - Classify a structure by its standard Model Theory invariants. +18. `modelTheoryTestEquivalenceStructure(left, right)` - Test whether two structure values are equivalent in Model Theory. +19. `modelTheoryGenerateExampleStructure(size=3)` - Generate a small documented example of a structure. +20. `modelTheoryDocumentStructure(value)` - Return a structured explanation of a structure and related assumptions. +21. `modelTheoryValidateLanguage(value)` - Validate the language representation and domain rules for Model Theory. +22. `modelTheoryConstructLanguage(*args)` - Construct a language from explicit inputs for Model Theory. +23. `modelTheoryNormalizeLanguage(value)` - Normalize a language into the standard Model Theory representation. +24. `modelTheoryCanonicalizeLanguage(value)` - Canonicalize a language so equivalent inputs share one form. +25. `modelTheoryParseLanguage(text)` - Parse a text or structured value into a language. +26. `modelTheoryFormatLanguage(value)` - Format a language for deterministic user-facing output. +27. `modelTheoryCompareLanguage(left, right)` - Compare two language values under the conventions of Model Theory. +28. `modelTheoryCombineLanguage(left, right)` - Combine two language values with the natural operation for Model Theory. +29. `modelTheoryDecomposeLanguage(value)` - Decompose a language into simpler or canonical components. +30. `modelTheoryEvaluateLanguage(value, point=None)` - Evaluate a language at a point, sample, or finite model. +31. `modelTheoryComputeLanguage(value)` - Compute the central numerical or symbolic data of a language. +32. `modelTheoryEstimateLanguage(value, samples=None)` - Estimate a language property from finite samples or approximations. +33. `modelTheoryApproximateLanguage(value, tolerance=1e-9)` - Approximate a language with explicit tolerance controls. +34. `modelTheoryTransformLanguage(value, mapping)` - Transform a language through a map, operator, or representation change. +35. `modelTheorySimplifyLanguage(value)` - Simplify a language without changing its mathematical meaning. +36. `modelTheoryEnumerateLanguage(value, limit=None)` - Enumerate finite members, cases, or derived objects for a language. +37. `modelTheoryClassifyLanguage(value)` - Classify a language by its standard Model Theory invariants. +38. `modelTheoryTestEquivalenceLanguage(left, right)` - Test whether two language values are equivalent in Model Theory. +39. `modelTheoryGenerateExampleLanguage(size=3)` - Generate a small documented example of a language. +40. `modelTheoryDocumentLanguage(value)` - Return a structured explanation of a language and related assumptions. +41. `modelTheoryValidateTerm(value)` - Validate the term representation and domain rules for Model Theory. +42. `modelTheoryConstructTerm(*args)` - Construct a term from explicit inputs for Model Theory. +43. `modelTheoryNormalizeTerm(value)` - Normalize a term into the standard Model Theory representation. +44. `modelTheoryCanonicalizeTerm(value)` - Canonicalize a term so equivalent inputs share one form. +45. `modelTheoryParseTerm(text)` - Parse a text or structured value into a term. +46. `modelTheoryFormatTerm(value)` - Format a term for deterministic user-facing output. +47. `modelTheoryCompareTerm(left, right)` - Compare two term values under the conventions of Model Theory. +48. `modelTheoryCombineTerm(left, right)` - Combine two term values with the natural operation for Model Theory. +49. `modelTheoryDecomposeTerm(value)` - Decompose a term into simpler or canonical components. +50. `modelTheoryEvaluateTerm(value, point=None)` - Evaluate a term at a point, sample, or finite model. +51. `modelTheoryComputeTerm(value)` - Compute the central numerical or symbolic data of a term. +52. `modelTheoryEstimateTerm(value, samples=None)` - Estimate a term property from finite samples or approximations. +53. `modelTheoryApproximateTerm(value, tolerance=1e-9)` - Approximate a term with explicit tolerance controls. +54. `modelTheoryTransformTerm(value, mapping)` - Transform a term through a map, operator, or representation change. +55. `modelTheorySimplifyTerm(value)` - Simplify a term without changing its mathematical meaning. +56. `modelTheoryEnumerateTerm(value, limit=None)` - Enumerate finite members, cases, or derived objects for a term. +57. `modelTheoryClassifyTerm(value)` - Classify a term by its standard Model Theory invariants. +58. `modelTheoryTestEquivalenceTerm(left, right)` - Test whether two term values are equivalent in Model Theory. +59. `modelTheoryGenerateExampleTerm(size=3)` - Generate a small documented example of a term. +60. `modelTheoryDocumentTerm(value)` - Return a structured explanation of a term and related assumptions. +61. `modelTheoryValidateFormula(value)` - Validate the formula representation and domain rules for Model Theory. +62. `modelTheoryConstructFormula(*args)` - Construct a formula from explicit inputs for Model Theory. +63. `modelTheoryNormalizeFormula(value)` - Normalize a formula into the standard Model Theory representation. +64. `modelTheoryCanonicalizeFormula(value)` - Canonicalize a formula so equivalent inputs share one form. +65. `modelTheoryParseFormula(text)` - Parse a text or structured value into a formula. +66. `modelTheoryFormatFormula(value)` - Format a formula for deterministic user-facing output. +67. `modelTheoryCompareFormula(left, right)` - Compare two formula values under the conventions of Model Theory. +68. `modelTheoryCombineFormula(left, right)` - Combine two formula values with the natural operation for Model Theory. +69. `modelTheoryDecomposeFormula(value)` - Decompose a formula into simpler or canonical components. +70. `modelTheoryEvaluateFormula(value, point=None)` - Evaluate a formula at a point, sample, or finite model. +71. `modelTheoryComputeFormula(value)` - Compute the central numerical or symbolic data of a formula. +72. `modelTheoryEstimateFormula(value, samples=None)` - Estimate a formula property from finite samples or approximations. +73. `modelTheoryApproximateFormula(value, tolerance=1e-9)` - Approximate a formula with explicit tolerance controls. +74. `modelTheoryTransformFormula(value, mapping)` - Transform a formula through a map, operator, or representation change. +75. `modelTheorySimplifyFormula(value)` - Simplify a formula without changing its mathematical meaning. +76. `modelTheoryEnumerateFormula(value, limit=None)` - Enumerate finite members, cases, or derived objects for a formula. +77. `modelTheoryClassifyFormula(value)` - Classify a formula by its standard Model Theory invariants. +78. `modelTheoryTestEquivalenceFormula(left, right)` - Test whether two formula values are equivalent in Model Theory. +79. `modelTheoryGenerateExampleFormula(size=3)` - Generate a small documented example of a formula. +80. `modelTheoryDocumentFormula(value)` - Return a structured explanation of a formula and related assumptions. +81. `modelTheoryValidateModel(value)` - Validate the model representation and domain rules for Model Theory. +82. `modelTheoryConstructModel(*args)` - Construct a model from explicit inputs for Model Theory. +83. `modelTheoryNormalizeModel(value)` - Normalize a model into the standard Model Theory representation. +84. `modelTheoryCanonicalizeModel(value)` - Canonicalize a model so equivalent inputs share one form. +85. `modelTheoryParseModel(text)` - Parse a text or structured value into a model. +86. `modelTheoryFormatModel(value)` - Format a model for deterministic user-facing output. +87. `modelTheoryCompareModel(left, right)` - Compare two model values under the conventions of Model Theory. +88. `modelTheoryCombineModel(left, right)` - Combine two model values with the natural operation for Model Theory. +89. `modelTheoryDecomposeModel(value)` - Decompose a model into simpler or canonical components. +90. `modelTheoryEvaluateModel(value, point=None)` - Evaluate a model at a point, sample, or finite model. +91. `modelTheoryComputeModel(value)` - Compute the central numerical or symbolic data of a model. +92. `modelTheoryEstimateModel(value, samples=None)` - Estimate a model property from finite samples or approximations. +93. `modelTheoryApproximateModel(value, tolerance=1e-9)` - Approximate a model with explicit tolerance controls. +94. `modelTheoryTransformModel(value, mapping)` - Transform a model through a map, operator, or representation change. +95. `modelTheorySimplifyModel(value)` - Simplify a model without changing its mathematical meaning. +96. `modelTheoryEnumerateModel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a model. +97. `modelTheoryClassifyModel(value)` - Classify a model by its standard Model Theory invariants. +98. `modelTheoryTestEquivalenceModel(left, right)` - Test whether two model values are equivalent in Model Theory. +99. `modelTheoryGenerateExampleModel(size=3)` - Generate a small documented example of a model. +100. `modelTheoryDocumentModel(value)` - Return a structured explanation of a model and related assumptions. + +### Proof Theory + +Core object families: + +- sequent +- proof tree +- inference rule +- derivation +- normal form + +Candidate functions: + +1. `proofTheoryValidateSequent(value)` - Validate the sequent representation and domain rules for Proof Theory. +2. `proofTheoryConstructSequent(*args)` - Construct a sequent from explicit inputs for Proof Theory. +3. `proofTheoryNormalizeSequent(value)` - Normalize a sequent into the standard Proof Theory representation. +4. `proofTheoryCanonicalizeSequent(value)` - Canonicalize a sequent so equivalent inputs share one form. +5. `proofTheoryParseSequent(text)` - Parse a text or structured value into a sequent. +6. `proofTheoryFormatSequent(value)` - Format a sequent for deterministic user-facing output. +7. `proofTheoryCompareSequent(left, right)` - Compare two sequent values under the conventions of Proof Theory. +8. `proofTheoryCombineSequent(left, right)` - Combine two sequent values with the natural operation for Proof Theory. +9. `proofTheoryDecomposeSequent(value)` - Decompose a sequent into simpler or canonical components. +10. `proofTheoryEvaluateSequent(value, point=None)` - Evaluate a sequent at a point, sample, or finite model. +11. `proofTheoryComputeSequent(value)` - Compute the central numerical or symbolic data of a sequent. +12. `proofTheoryEstimateSequent(value, samples=None)` - Estimate a sequent property from finite samples or approximations. +13. `proofTheoryApproximateSequent(value, tolerance=1e-9)` - Approximate a sequent with explicit tolerance controls. +14. `proofTheoryTransformSequent(value, mapping)` - Transform a sequent through a map, operator, or representation change. +15. `proofTheorySimplifySequent(value)` - Simplify a sequent without changing its mathematical meaning. +16. `proofTheoryEnumerateSequent(value, limit=None)` - Enumerate finite members, cases, or derived objects for a sequent. +17. `proofTheoryClassifySequent(value)` - Classify a sequent by its standard Proof Theory invariants. +18. `proofTheoryTestEquivalenceSequent(left, right)` - Test whether two sequent values are equivalent in Proof Theory. +19. `proofTheoryGenerateExampleSequent(size=3)` - Generate a small documented example of a sequent. +20. `proofTheoryDocumentSequent(value)` - Return a structured explanation of a sequent and related assumptions. +21. `proofTheoryValidateProofTree(value)` - Validate the proof tree representation and domain rules for Proof Theory. +22. `proofTheoryConstructProofTree(*args)` - Construct a proof tree from explicit inputs for Proof Theory. +23. `proofTheoryNormalizeProofTree(value)` - Normalize a proof tree into the standard Proof Theory representation. +24. `proofTheoryCanonicalizeProofTree(value)` - Canonicalize a proof tree so equivalent inputs share one form. +25. `proofTheoryParseProofTree(text)` - Parse a text or structured value into a proof tree. +26. `proofTheoryFormatProofTree(value)` - Format a proof tree for deterministic user-facing output. +27. `proofTheoryCompareProofTree(left, right)` - Compare two proof tree values under the conventions of Proof Theory. +28. `proofTheoryCombineProofTree(left, right)` - Combine two proof tree values with the natural operation for Proof Theory. +29. `proofTheoryDecomposeProofTree(value)` - Decompose a proof tree into simpler or canonical components. +30. `proofTheoryEvaluateProofTree(value, point=None)` - Evaluate a proof tree at a point, sample, or finite model. +31. `proofTheoryComputeProofTree(value)` - Compute the central numerical or symbolic data of a proof tree. +32. `proofTheoryEstimateProofTree(value, samples=None)` - Estimate a proof tree property from finite samples or approximations. +33. `proofTheoryApproximateProofTree(value, tolerance=1e-9)` - Approximate a proof tree with explicit tolerance controls. +34. `proofTheoryTransformProofTree(value, mapping)` - Transform a proof tree through a map, operator, or representation change. +35. `proofTheorySimplifyProofTree(value)` - Simplify a proof tree without changing its mathematical meaning. +36. `proofTheoryEnumerateProofTree(value, limit=None)` - Enumerate finite members, cases, or derived objects for a proof tree. +37. `proofTheoryClassifyProofTree(value)` - Classify a proof tree by its standard Proof Theory invariants. +38. `proofTheoryTestEquivalenceProofTree(left, right)` - Test whether two proof tree values are equivalent in Proof Theory. +39. `proofTheoryGenerateExampleProofTree(size=3)` - Generate a small documented example of a proof tree. +40. `proofTheoryDocumentProofTree(value)` - Return a structured explanation of a proof tree and related assumptions. +41. `proofTheoryValidateInferenceRule(value)` - Validate the inference rule representation and domain rules for Proof Theory. +42. `proofTheoryConstructInferenceRule(*args)` - Construct a inference rule from explicit inputs for Proof Theory. +43. `proofTheoryNormalizeInferenceRule(value)` - Normalize a inference rule into the standard Proof Theory representation. +44. `proofTheoryCanonicalizeInferenceRule(value)` - Canonicalize a inference rule so equivalent inputs share one form. +45. `proofTheoryParseInferenceRule(text)` - Parse a text or structured value into a inference rule. +46. `proofTheoryFormatInferenceRule(value)` - Format a inference rule for deterministic user-facing output. +47. `proofTheoryCompareInferenceRule(left, right)` - Compare two inference rule values under the conventions of Proof Theory. +48. `proofTheoryCombineInferenceRule(left, right)` - Combine two inference rule values with the natural operation for Proof Theory. +49. `proofTheoryDecomposeInferenceRule(value)` - Decompose a inference rule into simpler or canonical components. +50. `proofTheoryEvaluateInferenceRule(value, point=None)` - Evaluate a inference rule at a point, sample, or finite model. +51. `proofTheoryComputeInferenceRule(value)` - Compute the central numerical or symbolic data of a inference rule. +52. `proofTheoryEstimateInferenceRule(value, samples=None)` - Estimate a inference rule property from finite samples or approximations. +53. `proofTheoryApproximateInferenceRule(value, tolerance=1e-9)` - Approximate a inference rule with explicit tolerance controls. +54. `proofTheoryTransformInferenceRule(value, mapping)` - Transform a inference rule through a map, operator, or representation change. +55. `proofTheorySimplifyInferenceRule(value)` - Simplify a inference rule without changing its mathematical meaning. +56. `proofTheoryEnumerateInferenceRule(value, limit=None)` - Enumerate finite members, cases, or derived objects for a inference rule. +57. `proofTheoryClassifyInferenceRule(value)` - Classify a inference rule by its standard Proof Theory invariants. +58. `proofTheoryTestEquivalenceInferenceRule(left, right)` - Test whether two inference rule values are equivalent in Proof Theory. +59. `proofTheoryGenerateExampleInferenceRule(size=3)` - Generate a small documented example of a inference rule. +60. `proofTheoryDocumentInferenceRule(value)` - Return a structured explanation of a inference rule and related assumptions. +61. `proofTheoryValidateDerivation(value)` - Validate the derivation representation and domain rules for Proof Theory. +62. `proofTheoryConstructDerivation(*args)` - Construct a derivation from explicit inputs for Proof Theory. +63. `proofTheoryNormalizeDerivation(value)` - Normalize a derivation into the standard Proof Theory representation. +64. `proofTheoryCanonicalizeDerivation(value)` - Canonicalize a derivation so equivalent inputs share one form. +65. `proofTheoryParseDerivation(text)` - Parse a text or structured value into a derivation. +66. `proofTheoryFormatDerivation(value)` - Format a derivation for deterministic user-facing output. +67. `proofTheoryCompareDerivation(left, right)` - Compare two derivation values under the conventions of Proof Theory. +68. `proofTheoryCombineDerivation(left, right)` - Combine two derivation values with the natural operation for Proof Theory. +69. `proofTheoryDecomposeDerivation(value)` - Decompose a derivation into simpler or canonical components. +70. `proofTheoryEvaluateDerivation(value, point=None)` - Evaluate a derivation at a point, sample, or finite model. +71. `proofTheoryComputeDerivation(value)` - Compute the central numerical or symbolic data of a derivation. +72. `proofTheoryEstimateDerivation(value, samples=None)` - Estimate a derivation property from finite samples or approximations. +73. `proofTheoryApproximateDerivation(value, tolerance=1e-9)` - Approximate a derivation with explicit tolerance controls. +74. `proofTheoryTransformDerivation(value, mapping)` - Transform a derivation through a map, operator, or representation change. +75. `proofTheorySimplifyDerivation(value)` - Simplify a derivation without changing its mathematical meaning. +76. `proofTheoryEnumerateDerivation(value, limit=None)` - Enumerate finite members, cases, or derived objects for a derivation. +77. `proofTheoryClassifyDerivation(value)` - Classify a derivation by its standard Proof Theory invariants. +78. `proofTheoryTestEquivalenceDerivation(left, right)` - Test whether two derivation values are equivalent in Proof Theory. +79. `proofTheoryGenerateExampleDerivation(size=3)` - Generate a small documented example of a derivation. +80. `proofTheoryDocumentDerivation(value)` - Return a structured explanation of a derivation and related assumptions. +81. `proofTheoryValidateNormalForm(value)` - Validate the normal form representation and domain rules for Proof Theory. +82. `proofTheoryConstructNormalForm(*args)` - Construct a normal form from explicit inputs for Proof Theory. +83. `proofTheoryNormalizeNormalForm(value)` - Normalize a normal form into the standard Proof Theory representation. +84. `proofTheoryCanonicalizeNormalForm(value)` - Canonicalize a normal form so equivalent inputs share one form. +85. `proofTheoryParseNormalForm(text)` - Parse a text or structured value into a normal form. +86. `proofTheoryFormatNormalForm(value)` - Format a normal form for deterministic user-facing output. +87. `proofTheoryCompareNormalForm(left, right)` - Compare two normal form values under the conventions of Proof Theory. +88. `proofTheoryCombineNormalForm(left, right)` - Combine two normal form values with the natural operation for Proof Theory. +89. `proofTheoryDecomposeNormalForm(value)` - Decompose a normal form into simpler or canonical components. +90. `proofTheoryEvaluateNormalForm(value, point=None)` - Evaluate a normal form at a point, sample, or finite model. +91. `proofTheoryComputeNormalForm(value)` - Compute the central numerical or symbolic data of a normal form. +92. `proofTheoryEstimateNormalForm(value, samples=None)` - Estimate a normal form property from finite samples or approximations. +93. `proofTheoryApproximateNormalForm(value, tolerance=1e-9)` - Approximate a normal form with explicit tolerance controls. +94. `proofTheoryTransformNormalForm(value, mapping)` - Transform a normal form through a map, operator, or representation change. +95. `proofTheorySimplifyNormalForm(value)` - Simplify a normal form without changing its mathematical meaning. +96. `proofTheoryEnumerateNormalForm(value, limit=None)` - Enumerate finite members, cases, or derived objects for a normal form. +97. `proofTheoryClassifyNormalForm(value)` - Classify a normal form by its standard Proof Theory invariants. +98. `proofTheoryTestEquivalenceNormalForm(left, right)` - Test whether two normal form values are equivalent in Proof Theory. +99. `proofTheoryGenerateExampleNormalForm(size=3)` - Generate a small documented example of a normal form. +100. `proofTheoryDocumentNormalForm(value)` - Return a structured explanation of a normal form and related assumptions. + +### Descriptive Set Theory + +Core object families: + +- cylinder set +- prefix tree +- Borel code +- equivalence relation +- reduction + +Candidate functions: + +1. `descriptiveSetTheoryValidateCylinderSet(value)` - Validate the cylinder set representation and domain rules for Descriptive Set Theory. +2. `descriptiveSetTheoryConstructCylinderSet(*args)` - Construct a cylinder set from explicit inputs for Descriptive Set Theory. +3. `descriptiveSetTheoryNormalizeCylinderSet(value)` - Normalize a cylinder set into the standard Descriptive Set Theory representation. +4. `descriptiveSetTheoryCanonicalizeCylinderSet(value)` - Canonicalize a cylinder set so equivalent inputs share one form. +5. `descriptiveSetTheoryParseCylinderSet(text)` - Parse a text or structured value into a cylinder set. +6. `descriptiveSetTheoryFormatCylinderSet(value)` - Format a cylinder set for deterministic user-facing output. +7. `descriptiveSetTheoryCompareCylinderSet(left, right)` - Compare two cylinder set values under the conventions of Descriptive Set Theory. +8. `descriptiveSetTheoryCombineCylinderSet(left, right)` - Combine two cylinder set values with the natural operation for Descriptive Set Theory. +9. `descriptiveSetTheoryDecomposeCylinderSet(value)` - Decompose a cylinder set into simpler or canonical components. +10. `descriptiveSetTheoryEvaluateCylinderSet(value, point=None)` - Evaluate a cylinder set at a point, sample, or finite model. +11. `descriptiveSetTheoryComputeCylinderSet(value)` - Compute the central numerical or symbolic data of a cylinder set. +12. `descriptiveSetTheoryEstimateCylinderSet(value, samples=None)` - Estimate a cylinder set property from finite samples or approximations. +13. `descriptiveSetTheoryApproximateCylinderSet(value, tolerance=1e-9)` - Approximate a cylinder set with explicit tolerance controls. +14. `descriptiveSetTheoryTransformCylinderSet(value, mapping)` - Transform a cylinder set through a map, operator, or representation change. +15. `descriptiveSetTheorySimplifyCylinderSet(value)` - Simplify a cylinder set without changing its mathematical meaning. +16. `descriptiveSetTheoryEnumerateCylinderSet(value, limit=None)` - Enumerate finite members, cases, or derived objects for a cylinder set. +17. `descriptiveSetTheoryClassifyCylinderSet(value)` - Classify a cylinder set by its standard Descriptive Set Theory invariants. +18. `descriptiveSetTheoryTestEquivalenceCylinderSet(left, right)` - Test whether two cylinder set values are equivalent in Descriptive Set Theory. +19. `descriptiveSetTheoryGenerateExampleCylinderSet(size=3)` - Generate a small documented example of a cylinder set. +20. `descriptiveSetTheoryDocumentCylinderSet(value)` - Return a structured explanation of a cylinder set and related assumptions. +21. `descriptiveSetTheoryValidatePrefixTree(value)` - Validate the prefix tree representation and domain rules for Descriptive Set Theory. +22. `descriptiveSetTheoryConstructPrefixTree(*args)` - Construct a prefix tree from explicit inputs for Descriptive Set Theory. +23. `descriptiveSetTheoryNormalizePrefixTree(value)` - Normalize a prefix tree into the standard Descriptive Set Theory representation. +24. `descriptiveSetTheoryCanonicalizePrefixTree(value)` - Canonicalize a prefix tree so equivalent inputs share one form. +25. `descriptiveSetTheoryParsePrefixTree(text)` - Parse a text or structured value into a prefix tree. +26. `descriptiveSetTheoryFormatPrefixTree(value)` - Format a prefix tree for deterministic user-facing output. +27. `descriptiveSetTheoryComparePrefixTree(left, right)` - Compare two prefix tree values under the conventions of Descriptive Set Theory. +28. `descriptiveSetTheoryCombinePrefixTree(left, right)` - Combine two prefix tree values with the natural operation for Descriptive Set Theory. +29. `descriptiveSetTheoryDecomposePrefixTree(value)` - Decompose a prefix tree into simpler or canonical components. +30. `descriptiveSetTheoryEvaluatePrefixTree(value, point=None)` - Evaluate a prefix tree at a point, sample, or finite model. +31. `descriptiveSetTheoryComputePrefixTree(value)` - Compute the central numerical or symbolic data of a prefix tree. +32. `descriptiveSetTheoryEstimatePrefixTree(value, samples=None)` - Estimate a prefix tree property from finite samples or approximations. +33. `descriptiveSetTheoryApproximatePrefixTree(value, tolerance=1e-9)` - Approximate a prefix tree with explicit tolerance controls. +34. `descriptiveSetTheoryTransformPrefixTree(value, mapping)` - Transform a prefix tree through a map, operator, or representation change. +35. `descriptiveSetTheorySimplifyPrefixTree(value)` - Simplify a prefix tree without changing its mathematical meaning. +36. `descriptiveSetTheoryEnumeratePrefixTree(value, limit=None)` - Enumerate finite members, cases, or derived objects for a prefix tree. +37. `descriptiveSetTheoryClassifyPrefixTree(value)` - Classify a prefix tree by its standard Descriptive Set Theory invariants. +38. `descriptiveSetTheoryTestEquivalencePrefixTree(left, right)` - Test whether two prefix tree values are equivalent in Descriptive Set Theory. +39. `descriptiveSetTheoryGenerateExamplePrefixTree(size=3)` - Generate a small documented example of a prefix tree. +40. `descriptiveSetTheoryDocumentPrefixTree(value)` - Return a structured explanation of a prefix tree and related assumptions. +41. `descriptiveSetTheoryValidateBorelCode(value)` - Validate the Borel code representation and domain rules for Descriptive Set Theory. +42. `descriptiveSetTheoryConstructBorelCode(*args)` - Construct a Borel code from explicit inputs for Descriptive Set Theory. +43. `descriptiveSetTheoryNormalizeBorelCode(value)` - Normalize a Borel code into the standard Descriptive Set Theory representation. +44. `descriptiveSetTheoryCanonicalizeBorelCode(value)` - Canonicalize a Borel code so equivalent inputs share one form. +45. `descriptiveSetTheoryParseBorelCode(text)` - Parse a text or structured value into a Borel code. +46. `descriptiveSetTheoryFormatBorelCode(value)` - Format a Borel code for deterministic user-facing output. +47. `descriptiveSetTheoryCompareBorelCode(left, right)` - Compare two Borel code values under the conventions of Descriptive Set Theory. +48. `descriptiveSetTheoryCombineBorelCode(left, right)` - Combine two Borel code values with the natural operation for Descriptive Set Theory. +49. `descriptiveSetTheoryDecomposeBorelCode(value)` - Decompose a Borel code into simpler or canonical components. +50. `descriptiveSetTheoryEvaluateBorelCode(value, point=None)` - Evaluate a Borel code at a point, sample, or finite model. +51. `descriptiveSetTheoryComputeBorelCode(value)` - Compute the central numerical or symbolic data of a Borel code. +52. `descriptiveSetTheoryEstimateBorelCode(value, samples=None)` - Estimate a Borel code property from finite samples or approximations. +53. `descriptiveSetTheoryApproximateBorelCode(value, tolerance=1e-9)` - Approximate a Borel code with explicit tolerance controls. +54. `descriptiveSetTheoryTransformBorelCode(value, mapping)` - Transform a Borel code through a map, operator, or representation change. +55. `descriptiveSetTheorySimplifyBorelCode(value)` - Simplify a Borel code without changing its mathematical meaning. +56. `descriptiveSetTheoryEnumerateBorelCode(value, limit=None)` - Enumerate finite members, cases, or derived objects for a Borel code. +57. `descriptiveSetTheoryClassifyBorelCode(value)` - Classify a Borel code by its standard Descriptive Set Theory invariants. +58. `descriptiveSetTheoryTestEquivalenceBorelCode(left, right)` - Test whether two Borel code values are equivalent in Descriptive Set Theory. +59. `descriptiveSetTheoryGenerateExampleBorelCode(size=3)` - Generate a small documented example of a Borel code. +60. `descriptiveSetTheoryDocumentBorelCode(value)` - Return a structured explanation of a Borel code and related assumptions. +61. `descriptiveSetTheoryValidateEquivalenceRelation(value)` - Validate the equivalence relation representation and domain rules for Descriptive Set Theory. +62. `descriptiveSetTheoryConstructEquivalenceRelation(*args)` - Construct a equivalence relation from explicit inputs for Descriptive Set Theory. +63. `descriptiveSetTheoryNormalizeEquivalenceRelation(value)` - Normalize a equivalence relation into the standard Descriptive Set Theory representation. +64. `descriptiveSetTheoryCanonicalizeEquivalenceRelation(value)` - Canonicalize a equivalence relation so equivalent inputs share one form. +65. `descriptiveSetTheoryParseEquivalenceRelation(text)` - Parse a text or structured value into a equivalence relation. +66. `descriptiveSetTheoryFormatEquivalenceRelation(value)` - Format a equivalence relation for deterministic user-facing output. +67. `descriptiveSetTheoryCompareEquivalenceRelation(left, right)` - Compare two equivalence relation values under the conventions of Descriptive Set Theory. +68. `descriptiveSetTheoryCombineEquivalenceRelation(left, right)` - Combine two equivalence relation values with the natural operation for Descriptive Set Theory. +69. `descriptiveSetTheoryDecomposeEquivalenceRelation(value)` - Decompose a equivalence relation into simpler or canonical components. +70. `descriptiveSetTheoryEvaluateEquivalenceRelation(value, point=None)` - Evaluate a equivalence relation at a point, sample, or finite model. +71. `descriptiveSetTheoryComputeEquivalenceRelation(value)` - Compute the central numerical or symbolic data of a equivalence relation. +72. `descriptiveSetTheoryEstimateEquivalenceRelation(value, samples=None)` - Estimate a equivalence relation property from finite samples or approximations. +73. `descriptiveSetTheoryApproximateEquivalenceRelation(value, tolerance=1e-9)` - Approximate a equivalence relation with explicit tolerance controls. +74. `descriptiveSetTheoryTransformEquivalenceRelation(value, mapping)` - Transform a equivalence relation through a map, operator, or representation change. +75. `descriptiveSetTheorySimplifyEquivalenceRelation(value)` - Simplify a equivalence relation without changing its mathematical meaning. +76. `descriptiveSetTheoryEnumerateEquivalenceRelation(value, limit=None)` - Enumerate finite members, cases, or derived objects for a equivalence relation. +77. `descriptiveSetTheoryClassifyEquivalenceRelation(value)` - Classify a equivalence relation by its standard Descriptive Set Theory invariants. +78. `descriptiveSetTheoryTestEquivalenceEquivalenceRelation(left, right)` - Test whether two equivalence relation values are equivalent in Descriptive Set Theory. +79. `descriptiveSetTheoryGenerateExampleEquivalenceRelation(size=3)` - Generate a small documented example of a equivalence relation. +80. `descriptiveSetTheoryDocumentEquivalenceRelation(value)` - Return a structured explanation of a equivalence relation and related assumptions. +81. `descriptiveSetTheoryValidateReduction(value)` - Validate the reduction representation and domain rules for Descriptive Set Theory. +82. `descriptiveSetTheoryConstructReduction(*args)` - Construct a reduction from explicit inputs for Descriptive Set Theory. +83. `descriptiveSetTheoryNormalizeReduction(value)` - Normalize a reduction into the standard Descriptive Set Theory representation. +84. `descriptiveSetTheoryCanonicalizeReduction(value)` - Canonicalize a reduction so equivalent inputs share one form. +85. `descriptiveSetTheoryParseReduction(text)` - Parse a text or structured value into a reduction. +86. `descriptiveSetTheoryFormatReduction(value)` - Format a reduction for deterministic user-facing output. +87. `descriptiveSetTheoryCompareReduction(left, right)` - Compare two reduction values under the conventions of Descriptive Set Theory. +88. `descriptiveSetTheoryCombineReduction(left, right)` - Combine two reduction values with the natural operation for Descriptive Set Theory. +89. `descriptiveSetTheoryDecomposeReduction(value)` - Decompose a reduction into simpler or canonical components. +90. `descriptiveSetTheoryEvaluateReduction(value, point=None)` - Evaluate a reduction at a point, sample, or finite model. +91. `descriptiveSetTheoryComputeReduction(value)` - Compute the central numerical or symbolic data of a reduction. +92. `descriptiveSetTheoryEstimateReduction(value, samples=None)` - Estimate a reduction property from finite samples or approximations. +93. `descriptiveSetTheoryApproximateReduction(value, tolerance=1e-9)` - Approximate a reduction with explicit tolerance controls. +94. `descriptiveSetTheoryTransformReduction(value, mapping)` - Transform a reduction through a map, operator, or representation change. +95. `descriptiveSetTheorySimplifyReduction(value)` - Simplify a reduction without changing its mathematical meaning. +96. `descriptiveSetTheoryEnumerateReduction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a reduction. +97. `descriptiveSetTheoryClassifyReduction(value)` - Classify a reduction by its standard Descriptive Set Theory invariants. +98. `descriptiveSetTheoryTestEquivalenceReduction(left, right)` - Test whether two reduction values are equivalent in Descriptive Set Theory. +99. `descriptiveSetTheoryGenerateExampleReduction(size=3)` - Generate a small documented example of a reduction. +100. `descriptiveSetTheoryDocumentReduction(value)` - Return a structured explanation of a reduction and related assumptions. + +### Computability Theory + +Core object families: + +- machine +- partial function +- decider +- enumerator +- language + +Candidate functions: + +1. `computabilityTheoryValidateMachine(value)` - Validate the machine representation and domain rules for Computability Theory. +2. `computabilityTheoryConstructMachine(*args)` - Construct a machine from explicit inputs for Computability Theory. +3. `computabilityTheoryNormalizeMachine(value)` - Normalize a machine into the standard Computability Theory representation. +4. `computabilityTheoryCanonicalizeMachine(value)` - Canonicalize a machine so equivalent inputs share one form. +5. `computabilityTheoryParseMachine(text)` - Parse a text or structured value into a machine. +6. `computabilityTheoryFormatMachine(value)` - Format a machine for deterministic user-facing output. +7. `computabilityTheoryCompareMachine(left, right)` - Compare two machine values under the conventions of Computability Theory. +8. `computabilityTheoryCombineMachine(left, right)` - Combine two machine values with the natural operation for Computability Theory. +9. `computabilityTheoryDecomposeMachine(value)` - Decompose a machine into simpler or canonical components. +10. `computabilityTheoryEvaluateMachine(value, point=None)` - Evaluate a machine at a point, sample, or finite model. +11. `computabilityTheoryComputeMachine(value)` - Compute the central numerical or symbolic data of a machine. +12. `computabilityTheoryEstimateMachine(value, samples=None)` - Estimate a machine property from finite samples or approximations. +13. `computabilityTheoryApproximateMachine(value, tolerance=1e-9)` - Approximate a machine with explicit tolerance controls. +14. `computabilityTheoryTransformMachine(value, mapping)` - Transform a machine through a map, operator, or representation change. +15. `computabilityTheorySimplifyMachine(value)` - Simplify a machine without changing its mathematical meaning. +16. `computabilityTheoryEnumerateMachine(value, limit=None)` - Enumerate finite members, cases, or derived objects for a machine. +17. `computabilityTheoryClassifyMachine(value)` - Classify a machine by its standard Computability Theory invariants. +18. `computabilityTheoryTestEquivalenceMachine(left, right)` - Test whether two machine values are equivalent in Computability Theory. +19. `computabilityTheoryGenerateExampleMachine(size=3)` - Generate a small documented example of a machine. +20. `computabilityTheoryDocumentMachine(value)` - Return a structured explanation of a machine and related assumptions. +21. `computabilityTheoryValidatePartialFunction(value)` - Validate the partial function representation and domain rules for Computability Theory. +22. `computabilityTheoryConstructPartialFunction(*args)` - Construct a partial function from explicit inputs for Computability Theory. +23. `computabilityTheoryNormalizePartialFunction(value)` - Normalize a partial function into the standard Computability Theory representation. +24. `computabilityTheoryCanonicalizePartialFunction(value)` - Canonicalize a partial function so equivalent inputs share one form. +25. `computabilityTheoryParsePartialFunction(text)` - Parse a text or structured value into a partial function. +26. `computabilityTheoryFormatPartialFunction(value)` - Format a partial function for deterministic user-facing output. +27. `computabilityTheoryComparePartialFunction(left, right)` - Compare two partial function values under the conventions of Computability Theory. +28. `computabilityTheoryCombinePartialFunction(left, right)` - Combine two partial function values with the natural operation for Computability Theory. +29. `computabilityTheoryDecomposePartialFunction(value)` - Decompose a partial function into simpler or canonical components. +30. `computabilityTheoryEvaluatePartialFunction(value, point=None)` - Evaluate a partial function at a point, sample, or finite model. +31. `computabilityTheoryComputePartialFunction(value)` - Compute the central numerical or symbolic data of a partial function. +32. `computabilityTheoryEstimatePartialFunction(value, samples=None)` - Estimate a partial function property from finite samples or approximations. +33. `computabilityTheoryApproximatePartialFunction(value, tolerance=1e-9)` - Approximate a partial function with explicit tolerance controls. +34. `computabilityTheoryTransformPartialFunction(value, mapping)` - Transform a partial function through a map, operator, or representation change. +35. `computabilityTheorySimplifyPartialFunction(value)` - Simplify a partial function without changing its mathematical meaning. +36. `computabilityTheoryEnumeratePartialFunction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a partial function. +37. `computabilityTheoryClassifyPartialFunction(value)` - Classify a partial function by its standard Computability Theory invariants. +38. `computabilityTheoryTestEquivalencePartialFunction(left, right)` - Test whether two partial function values are equivalent in Computability Theory. +39. `computabilityTheoryGenerateExamplePartialFunction(size=3)` - Generate a small documented example of a partial function. +40. `computabilityTheoryDocumentPartialFunction(value)` - Return a structured explanation of a partial function and related assumptions. +41. `computabilityTheoryValidateDecider(value)` - Validate the decider representation and domain rules for Computability Theory. +42. `computabilityTheoryConstructDecider(*args)` - Construct a decider from explicit inputs for Computability Theory. +43. `computabilityTheoryNormalizeDecider(value)` - Normalize a decider into the standard Computability Theory representation. +44. `computabilityTheoryCanonicalizeDecider(value)` - Canonicalize a decider so equivalent inputs share one form. +45. `computabilityTheoryParseDecider(text)` - Parse a text or structured value into a decider. +46. `computabilityTheoryFormatDecider(value)` - Format a decider for deterministic user-facing output. +47. `computabilityTheoryCompareDecider(left, right)` - Compare two decider values under the conventions of Computability Theory. +48. `computabilityTheoryCombineDecider(left, right)` - Combine two decider values with the natural operation for Computability Theory. +49. `computabilityTheoryDecomposeDecider(value)` - Decompose a decider into simpler or canonical components. +50. `computabilityTheoryEvaluateDecider(value, point=None)` - Evaluate a decider at a point, sample, or finite model. +51. `computabilityTheoryComputeDecider(value)` - Compute the central numerical or symbolic data of a decider. +52. `computabilityTheoryEstimateDecider(value, samples=None)` - Estimate a decider property from finite samples or approximations. +53. `computabilityTheoryApproximateDecider(value, tolerance=1e-9)` - Approximate a decider with explicit tolerance controls. +54. `computabilityTheoryTransformDecider(value, mapping)` - Transform a decider through a map, operator, or representation change. +55. `computabilityTheorySimplifyDecider(value)` - Simplify a decider without changing its mathematical meaning. +56. `computabilityTheoryEnumerateDecider(value, limit=None)` - Enumerate finite members, cases, or derived objects for a decider. +57. `computabilityTheoryClassifyDecider(value)` - Classify a decider by its standard Computability Theory invariants. +58. `computabilityTheoryTestEquivalenceDecider(left, right)` - Test whether two decider values are equivalent in Computability Theory. +59. `computabilityTheoryGenerateExampleDecider(size=3)` - Generate a small documented example of a decider. +60. `computabilityTheoryDocumentDecider(value)` - Return a structured explanation of a decider and related assumptions. +61. `computabilityTheoryValidateEnumerator(value)` - Validate the enumerator representation and domain rules for Computability Theory. +62. `computabilityTheoryConstructEnumerator(*args)` - Construct a enumerator from explicit inputs for Computability Theory. +63. `computabilityTheoryNormalizeEnumerator(value)` - Normalize a enumerator into the standard Computability Theory representation. +64. `computabilityTheoryCanonicalizeEnumerator(value)` - Canonicalize a enumerator so equivalent inputs share one form. +65. `computabilityTheoryParseEnumerator(text)` - Parse a text or structured value into a enumerator. +66. `computabilityTheoryFormatEnumerator(value)` - Format a enumerator for deterministic user-facing output. +67. `computabilityTheoryCompareEnumerator(left, right)` - Compare two enumerator values under the conventions of Computability Theory. +68. `computabilityTheoryCombineEnumerator(left, right)` - Combine two enumerator values with the natural operation for Computability Theory. +69. `computabilityTheoryDecomposeEnumerator(value)` - Decompose a enumerator into simpler or canonical components. +70. `computabilityTheoryEvaluateEnumerator(value, point=None)` - Evaluate a enumerator at a point, sample, or finite model. +71. `computabilityTheoryComputeEnumerator(value)` - Compute the central numerical or symbolic data of a enumerator. +72. `computabilityTheoryEstimateEnumerator(value, samples=None)` - Estimate a enumerator property from finite samples or approximations. +73. `computabilityTheoryApproximateEnumerator(value, tolerance=1e-9)` - Approximate a enumerator with explicit tolerance controls. +74. `computabilityTheoryTransformEnumerator(value, mapping)` - Transform a enumerator through a map, operator, or representation change. +75. `computabilityTheorySimplifyEnumerator(value)` - Simplify a enumerator without changing its mathematical meaning. +76. `computabilityTheoryEnumerateEnumerator(value, limit=None)` - Enumerate finite members, cases, or derived objects for a enumerator. +77. `computabilityTheoryClassifyEnumerator(value)` - Classify a enumerator by its standard Computability Theory invariants. +78. `computabilityTheoryTestEquivalenceEnumerator(left, right)` - Test whether two enumerator values are equivalent in Computability Theory. +79. `computabilityTheoryGenerateExampleEnumerator(size=3)` - Generate a small documented example of a enumerator. +80. `computabilityTheoryDocumentEnumerator(value)` - Return a structured explanation of a enumerator and related assumptions. +81. `computabilityTheoryValidateLanguage(value)` - Validate the language representation and domain rules for Computability Theory. +82. `computabilityTheoryConstructLanguage(*args)` - Construct a language from explicit inputs for Computability Theory. +83. `computabilityTheoryNormalizeLanguage(value)` - Normalize a language into the standard Computability Theory representation. +84. `computabilityTheoryCanonicalizeLanguage(value)` - Canonicalize a language so equivalent inputs share one form. +85. `computabilityTheoryParseLanguage(text)` - Parse a text or structured value into a language. +86. `computabilityTheoryFormatLanguage(value)` - Format a language for deterministic user-facing output. +87. `computabilityTheoryCompareLanguage(left, right)` - Compare two language values under the conventions of Computability Theory. +88. `computabilityTheoryCombineLanguage(left, right)` - Combine two language values with the natural operation for Computability Theory. +89. `computabilityTheoryDecomposeLanguage(value)` - Decompose a language into simpler or canonical components. +90. `computabilityTheoryEvaluateLanguage(value, point=None)` - Evaluate a language at a point, sample, or finite model. +91. `computabilityTheoryComputeLanguage(value)` - Compute the central numerical or symbolic data of a language. +92. `computabilityTheoryEstimateLanguage(value, samples=None)` - Estimate a language property from finite samples or approximations. +93. `computabilityTheoryApproximateLanguage(value, tolerance=1e-9)` - Approximate a language with explicit tolerance controls. +94. `computabilityTheoryTransformLanguage(value, mapping)` - Transform a language through a map, operator, or representation change. +95. `computabilityTheorySimplifyLanguage(value)` - Simplify a language without changing its mathematical meaning. +96. `computabilityTheoryEnumerateLanguage(value, limit=None)` - Enumerate finite members, cases, or derived objects for a language. +97. `computabilityTheoryClassifyLanguage(value)` - Classify a language by its standard Computability Theory invariants. +98. `computabilityTheoryTestEquivalenceLanguage(left, right)` - Test whether two language values are equivalent in Computability Theory. +99. `computabilityTheoryGenerateExampleLanguage(size=3)` - Generate a small documented example of a language. +100. `computabilityTheoryDocumentLanguage(value)` - Return a structured explanation of a language and related assumptions. + +### Automata and Formal Languages + +Core object families: + +- automaton +- regular language +- grammar +- parser state +- derivation + +Candidate functions: + +1. `automataAndFormalLanguagesValidateAutomaton(value)` - Validate the automaton representation and domain rules for Automata and Formal Languages. +2. `automataAndFormalLanguagesConstructAutomaton(*args)` - Construct a automaton from explicit inputs for Automata and Formal Languages. +3. `automataAndFormalLanguagesNormalizeAutomaton(value)` - Normalize a automaton into the standard Automata and Formal Languages representation. +4. `automataAndFormalLanguagesCanonicalizeAutomaton(value)` - Canonicalize a automaton so equivalent inputs share one form. +5. `automataAndFormalLanguagesParseAutomaton(text)` - Parse a text or structured value into a automaton. +6. `automataAndFormalLanguagesFormatAutomaton(value)` - Format a automaton for deterministic user-facing output. +7. `automataAndFormalLanguagesCompareAutomaton(left, right)` - Compare two automaton values under the conventions of Automata and Formal Languages. +8. `automataAndFormalLanguagesCombineAutomaton(left, right)` - Combine two automaton values with the natural operation for Automata and Formal Languages. +9. `automataAndFormalLanguagesDecomposeAutomaton(value)` - Decompose a automaton into simpler or canonical components. +10. `automataAndFormalLanguagesEvaluateAutomaton(value, point=None)` - Evaluate a automaton at a point, sample, or finite model. +11. `automataAndFormalLanguagesComputeAutomaton(value)` - Compute the central numerical or symbolic data of a automaton. +12. `automataAndFormalLanguagesEstimateAutomaton(value, samples=None)` - Estimate a automaton property from finite samples or approximations. +13. `automataAndFormalLanguagesApproximateAutomaton(value, tolerance=1e-9)` - Approximate a automaton with explicit tolerance controls. +14. `automataAndFormalLanguagesTransformAutomaton(value, mapping)` - Transform a automaton through a map, operator, or representation change. +15. `automataAndFormalLanguagesSimplifyAutomaton(value)` - Simplify a automaton without changing its mathematical meaning. +16. `automataAndFormalLanguagesEnumerateAutomaton(value, limit=None)` - Enumerate finite members, cases, or derived objects for a automaton. +17. `automataAndFormalLanguagesClassifyAutomaton(value)` - Classify a automaton by its standard Automata and Formal Languages invariants. +18. `automataAndFormalLanguagesTestEquivalenceAutomaton(left, right)` - Test whether two automaton values are equivalent in Automata and Formal Languages. +19. `automataAndFormalLanguagesGenerateExampleAutomaton(size=3)` - Generate a small documented example of a automaton. +20. `automataAndFormalLanguagesDocumentAutomaton(value)` - Return a structured explanation of a automaton and related assumptions. +21. `automataAndFormalLanguagesValidateRegularLanguage(value)` - Validate the regular language representation and domain rules for Automata and Formal Languages. +22. `automataAndFormalLanguagesConstructRegularLanguage(*args)` - Construct a regular language from explicit inputs for Automata and Formal Languages. +23. `automataAndFormalLanguagesNormalizeRegularLanguage(value)` - Normalize a regular language into the standard Automata and Formal Languages representation. +24. `automataAndFormalLanguagesCanonicalizeRegularLanguage(value)` - Canonicalize a regular language so equivalent inputs share one form. +25. `automataAndFormalLanguagesParseRegularLanguage(text)` - Parse a text or structured value into a regular language. +26. `automataAndFormalLanguagesFormatRegularLanguage(value)` - Format a regular language for deterministic user-facing output. +27. `automataAndFormalLanguagesCompareRegularLanguage(left, right)` - Compare two regular language values under the conventions of Automata and Formal Languages. +28. `automataAndFormalLanguagesCombineRegularLanguage(left, right)` - Combine two regular language values with the natural operation for Automata and Formal Languages. +29. `automataAndFormalLanguagesDecomposeRegularLanguage(value)` - Decompose a regular language into simpler or canonical components. +30. `automataAndFormalLanguagesEvaluateRegularLanguage(value, point=None)` - Evaluate a regular language at a point, sample, or finite model. +31. `automataAndFormalLanguagesComputeRegularLanguage(value)` - Compute the central numerical or symbolic data of a regular language. +32. `automataAndFormalLanguagesEstimateRegularLanguage(value, samples=None)` - Estimate a regular language property from finite samples or approximations. +33. `automataAndFormalLanguagesApproximateRegularLanguage(value, tolerance=1e-9)` - Approximate a regular language with explicit tolerance controls. +34. `automataAndFormalLanguagesTransformRegularLanguage(value, mapping)` - Transform a regular language through a map, operator, or representation change. +35. `automataAndFormalLanguagesSimplifyRegularLanguage(value)` - Simplify a regular language without changing its mathematical meaning. +36. `automataAndFormalLanguagesEnumerateRegularLanguage(value, limit=None)` - Enumerate finite members, cases, or derived objects for a regular language. +37. `automataAndFormalLanguagesClassifyRegularLanguage(value)` - Classify a regular language by its standard Automata and Formal Languages invariants. +38. `automataAndFormalLanguagesTestEquivalenceRegularLanguage(left, right)` - Test whether two regular language values are equivalent in Automata and Formal Languages. +39. `automataAndFormalLanguagesGenerateExampleRegularLanguage(size=3)` - Generate a small documented example of a regular language. +40. `automataAndFormalLanguagesDocumentRegularLanguage(value)` - Return a structured explanation of a regular language and related assumptions. +41. `automataAndFormalLanguagesValidateGrammar(value)` - Validate the grammar representation and domain rules for Automata and Formal Languages. +42. `automataAndFormalLanguagesConstructGrammar(*args)` - Construct a grammar from explicit inputs for Automata and Formal Languages. +43. `automataAndFormalLanguagesNormalizeGrammar(value)` - Normalize a grammar into the standard Automata and Formal Languages representation. +44. `automataAndFormalLanguagesCanonicalizeGrammar(value)` - Canonicalize a grammar so equivalent inputs share one form. +45. `automataAndFormalLanguagesParseGrammar(text)` - Parse a text or structured value into a grammar. +46. `automataAndFormalLanguagesFormatGrammar(value)` - Format a grammar for deterministic user-facing output. +47. `automataAndFormalLanguagesCompareGrammar(left, right)` - Compare two grammar values under the conventions of Automata and Formal Languages. +48. `automataAndFormalLanguagesCombineGrammar(left, right)` - Combine two grammar values with the natural operation for Automata and Formal Languages. +49. `automataAndFormalLanguagesDecomposeGrammar(value)` - Decompose a grammar into simpler or canonical components. +50. `automataAndFormalLanguagesEvaluateGrammar(value, point=None)` - Evaluate a grammar at a point, sample, or finite model. +51. `automataAndFormalLanguagesComputeGrammar(value)` - Compute the central numerical or symbolic data of a grammar. +52. `automataAndFormalLanguagesEstimateGrammar(value, samples=None)` - Estimate a grammar property from finite samples or approximations. +53. `automataAndFormalLanguagesApproximateGrammar(value, tolerance=1e-9)` - Approximate a grammar with explicit tolerance controls. +54. `automataAndFormalLanguagesTransformGrammar(value, mapping)` - Transform a grammar through a map, operator, or representation change. +55. `automataAndFormalLanguagesSimplifyGrammar(value)` - Simplify a grammar without changing its mathematical meaning. +56. `automataAndFormalLanguagesEnumerateGrammar(value, limit=None)` - Enumerate finite members, cases, or derived objects for a grammar. +57. `automataAndFormalLanguagesClassifyGrammar(value)` - Classify a grammar by its standard Automata and Formal Languages invariants. +58. `automataAndFormalLanguagesTestEquivalenceGrammar(left, right)` - Test whether two grammar values are equivalent in Automata and Formal Languages. +59. `automataAndFormalLanguagesGenerateExampleGrammar(size=3)` - Generate a small documented example of a grammar. +60. `automataAndFormalLanguagesDocumentGrammar(value)` - Return a structured explanation of a grammar and related assumptions. +61. `automataAndFormalLanguagesValidateParserState(value)` - Validate the parser state representation and domain rules for Automata and Formal Languages. +62. `automataAndFormalLanguagesConstructParserState(*args)` - Construct a parser state from explicit inputs for Automata and Formal Languages. +63. `automataAndFormalLanguagesNormalizeParserState(value)` - Normalize a parser state into the standard Automata and Formal Languages representation. +64. `automataAndFormalLanguagesCanonicalizeParserState(value)` - Canonicalize a parser state so equivalent inputs share one form. +65. `automataAndFormalLanguagesParseParserState(text)` - Parse a text or structured value into a parser state. +66. `automataAndFormalLanguagesFormatParserState(value)` - Format a parser state for deterministic user-facing output. +67. `automataAndFormalLanguagesCompareParserState(left, right)` - Compare two parser state values under the conventions of Automata and Formal Languages. +68. `automataAndFormalLanguagesCombineParserState(left, right)` - Combine two parser state values with the natural operation for Automata and Formal Languages. +69. `automataAndFormalLanguagesDecomposeParserState(value)` - Decompose a parser state into simpler or canonical components. +70. `automataAndFormalLanguagesEvaluateParserState(value, point=None)` - Evaluate a parser state at a point, sample, or finite model. +71. `automataAndFormalLanguagesComputeParserState(value)` - Compute the central numerical or symbolic data of a parser state. +72. `automataAndFormalLanguagesEstimateParserState(value, samples=None)` - Estimate a parser state property from finite samples or approximations. +73. `automataAndFormalLanguagesApproximateParserState(value, tolerance=1e-9)` - Approximate a parser state with explicit tolerance controls. +74. `automataAndFormalLanguagesTransformParserState(value, mapping)` - Transform a parser state through a map, operator, or representation change. +75. `automataAndFormalLanguagesSimplifyParserState(value)` - Simplify a parser state without changing its mathematical meaning. +76. `automataAndFormalLanguagesEnumerateParserState(value, limit=None)` - Enumerate finite members, cases, or derived objects for a parser state. +77. `automataAndFormalLanguagesClassifyParserState(value)` - Classify a parser state by its standard Automata and Formal Languages invariants. +78. `automataAndFormalLanguagesTestEquivalenceParserState(left, right)` - Test whether two parser state values are equivalent in Automata and Formal Languages. +79. `automataAndFormalLanguagesGenerateExampleParserState(size=3)` - Generate a small documented example of a parser state. +80. `automataAndFormalLanguagesDocumentParserState(value)` - Return a structured explanation of a parser state and related assumptions. +81. `automataAndFormalLanguagesValidateDerivation(value)` - Validate the derivation representation and domain rules for Automata and Formal Languages. +82. `automataAndFormalLanguagesConstructDerivation(*args)` - Construct a derivation from explicit inputs for Automata and Formal Languages. +83. `automataAndFormalLanguagesNormalizeDerivation(value)` - Normalize a derivation into the standard Automata and Formal Languages representation. +84. `automataAndFormalLanguagesCanonicalizeDerivation(value)` - Canonicalize a derivation so equivalent inputs share one form. +85. `automataAndFormalLanguagesParseDerivation(text)` - Parse a text or structured value into a derivation. +86. `automataAndFormalLanguagesFormatDerivation(value)` - Format a derivation for deterministic user-facing output. +87. `automataAndFormalLanguagesCompareDerivation(left, right)` - Compare two derivation values under the conventions of Automata and Formal Languages. +88. `automataAndFormalLanguagesCombineDerivation(left, right)` - Combine two derivation values with the natural operation for Automata and Formal Languages. +89. `automataAndFormalLanguagesDecomposeDerivation(value)` - Decompose a derivation into simpler or canonical components. +90. `automataAndFormalLanguagesEvaluateDerivation(value, point=None)` - Evaluate a derivation at a point, sample, or finite model. +91. `automataAndFormalLanguagesComputeDerivation(value)` - Compute the central numerical or symbolic data of a derivation. +92. `automataAndFormalLanguagesEstimateDerivation(value, samples=None)` - Estimate a derivation property from finite samples or approximations. +93. `automataAndFormalLanguagesApproximateDerivation(value, tolerance=1e-9)` - Approximate a derivation with explicit tolerance controls. +94. `automataAndFormalLanguagesTransformDerivation(value, mapping)` - Transform a derivation through a map, operator, or representation change. +95. `automataAndFormalLanguagesSimplifyDerivation(value)` - Simplify a derivation without changing its mathematical meaning. +96. `automataAndFormalLanguagesEnumerateDerivation(value, limit=None)` - Enumerate finite members, cases, or derived objects for a derivation. +97. `automataAndFormalLanguagesClassifyDerivation(value)` - Classify a derivation by its standard Automata and Formal Languages invariants. +98. `automataAndFormalLanguagesTestEquivalenceDerivation(left, right)` - Test whether two derivation values are equivalent in Automata and Formal Languages. +99. `automataAndFormalLanguagesGenerateExampleDerivation(size=3)` - Generate a small documented example of a derivation. +100. `automataAndFormalLanguagesDocumentDerivation(value)` - Return a structured explanation of a derivation and related assumptions. + +### Coding Theory + +Core object families: + +- codeword +- linear code +- syndrome +- parity check +- generator matrix + +Candidate functions: + +1. `codingTheoryValidateCodeword(value)` - Validate the codeword representation and domain rules for Coding Theory. +2. `codingTheoryConstructCodeword(*args)` - Construct a codeword from explicit inputs for Coding Theory. +3. `codingTheoryNormalizeCodeword(value)` - Normalize a codeword into the standard Coding Theory representation. +4. `codingTheoryCanonicalizeCodeword(value)` - Canonicalize a codeword so equivalent inputs share one form. +5. `codingTheoryParseCodeword(text)` - Parse a text or structured value into a codeword. +6. `codingTheoryFormatCodeword(value)` - Format a codeword for deterministic user-facing output. +7. `codingTheoryCompareCodeword(left, right)` - Compare two codeword values under the conventions of Coding Theory. +8. `codingTheoryCombineCodeword(left, right)` - Combine two codeword values with the natural operation for Coding Theory. +9. `codingTheoryDecomposeCodeword(value)` - Decompose a codeword into simpler or canonical components. +10. `codingTheoryEvaluateCodeword(value, point=None)` - Evaluate a codeword at a point, sample, or finite model. +11. `codingTheoryComputeCodeword(value)` - Compute the central numerical or symbolic data of a codeword. +12. `codingTheoryEstimateCodeword(value, samples=None)` - Estimate a codeword property from finite samples or approximations. +13. `codingTheoryApproximateCodeword(value, tolerance=1e-9)` - Approximate a codeword with explicit tolerance controls. +14. `codingTheoryTransformCodeword(value, mapping)` - Transform a codeword through a map, operator, or representation change. +15. `codingTheorySimplifyCodeword(value)` - Simplify a codeword without changing its mathematical meaning. +16. `codingTheoryEnumerateCodeword(value, limit=None)` - Enumerate finite members, cases, or derived objects for a codeword. +17. `codingTheoryClassifyCodeword(value)` - Classify a codeword by its standard Coding Theory invariants. +18. `codingTheoryTestEquivalenceCodeword(left, right)` - Test whether two codeword values are equivalent in Coding Theory. +19. `codingTheoryGenerateExampleCodeword(size=3)` - Generate a small documented example of a codeword. +20. `codingTheoryDocumentCodeword(value)` - Return a structured explanation of a codeword and related assumptions. +21. `codingTheoryValidateLinearCode(value)` - Validate the linear code representation and domain rules for Coding Theory. +22. `codingTheoryConstructLinearCode(*args)` - Construct a linear code from explicit inputs for Coding Theory. +23. `codingTheoryNormalizeLinearCode(value)` - Normalize a linear code into the standard Coding Theory representation. +24. `codingTheoryCanonicalizeLinearCode(value)` - Canonicalize a linear code so equivalent inputs share one form. +25. `codingTheoryParseLinearCode(text)` - Parse a text or structured value into a linear code. +26. `codingTheoryFormatLinearCode(value)` - Format a linear code for deterministic user-facing output. +27. `codingTheoryCompareLinearCode(left, right)` - Compare two linear code values under the conventions of Coding Theory. +28. `codingTheoryCombineLinearCode(left, right)` - Combine two linear code values with the natural operation for Coding Theory. +29. `codingTheoryDecomposeLinearCode(value)` - Decompose a linear code into simpler or canonical components. +30. `codingTheoryEvaluateLinearCode(value, point=None)` - Evaluate a linear code at a point, sample, or finite model. +31. `codingTheoryComputeLinearCode(value)` - Compute the central numerical or symbolic data of a linear code. +32. `codingTheoryEstimateLinearCode(value, samples=None)` - Estimate a linear code property from finite samples or approximations. +33. `codingTheoryApproximateLinearCode(value, tolerance=1e-9)` - Approximate a linear code with explicit tolerance controls. +34. `codingTheoryTransformLinearCode(value, mapping)` - Transform a linear code through a map, operator, or representation change. +35. `codingTheorySimplifyLinearCode(value)` - Simplify a linear code without changing its mathematical meaning. +36. `codingTheoryEnumerateLinearCode(value, limit=None)` - Enumerate finite members, cases, or derived objects for a linear code. +37. `codingTheoryClassifyLinearCode(value)` - Classify a linear code by its standard Coding Theory invariants. +38. `codingTheoryTestEquivalenceLinearCode(left, right)` - Test whether two linear code values are equivalent in Coding Theory. +39. `codingTheoryGenerateExampleLinearCode(size=3)` - Generate a small documented example of a linear code. +40. `codingTheoryDocumentLinearCode(value)` - Return a structured explanation of a linear code and related assumptions. +41. `codingTheoryValidateSyndrome(value)` - Validate the syndrome representation and domain rules for Coding Theory. +42. `codingTheoryConstructSyndrome(*args)` - Construct a syndrome from explicit inputs for Coding Theory. +43. `codingTheoryNormalizeSyndrome(value)` - Normalize a syndrome into the standard Coding Theory representation. +44. `codingTheoryCanonicalizeSyndrome(value)` - Canonicalize a syndrome so equivalent inputs share one form. +45. `codingTheoryParseSyndrome(text)` - Parse a text or structured value into a syndrome. +46. `codingTheoryFormatSyndrome(value)` - Format a syndrome for deterministic user-facing output. +47. `codingTheoryCompareSyndrome(left, right)` - Compare two syndrome values under the conventions of Coding Theory. +48. `codingTheoryCombineSyndrome(left, right)` - Combine two syndrome values with the natural operation for Coding Theory. +49. `codingTheoryDecomposeSyndrome(value)` - Decompose a syndrome into simpler or canonical components. +50. `codingTheoryEvaluateSyndrome(value, point=None)` - Evaluate a syndrome at a point, sample, or finite model. +51. `codingTheoryComputeSyndrome(value)` - Compute the central numerical or symbolic data of a syndrome. +52. `codingTheoryEstimateSyndrome(value, samples=None)` - Estimate a syndrome property from finite samples or approximations. +53. `codingTheoryApproximateSyndrome(value, tolerance=1e-9)` - Approximate a syndrome with explicit tolerance controls. +54. `codingTheoryTransformSyndrome(value, mapping)` - Transform a syndrome through a map, operator, or representation change. +55. `codingTheorySimplifySyndrome(value)` - Simplify a syndrome without changing its mathematical meaning. +56. `codingTheoryEnumerateSyndrome(value, limit=None)` - Enumerate finite members, cases, or derived objects for a syndrome. +57. `codingTheoryClassifySyndrome(value)` - Classify a syndrome by its standard Coding Theory invariants. +58. `codingTheoryTestEquivalenceSyndrome(left, right)` - Test whether two syndrome values are equivalent in Coding Theory. +59. `codingTheoryGenerateExampleSyndrome(size=3)` - Generate a small documented example of a syndrome. +60. `codingTheoryDocumentSyndrome(value)` - Return a structured explanation of a syndrome and related assumptions. +61. `codingTheoryValidateParityCheck(value)` - Validate the parity check representation and domain rules for Coding Theory. +62. `codingTheoryConstructParityCheck(*args)` - Construct a parity check from explicit inputs for Coding Theory. +63. `codingTheoryNormalizeParityCheck(value)` - Normalize a parity check into the standard Coding Theory representation. +64. `codingTheoryCanonicalizeParityCheck(value)` - Canonicalize a parity check so equivalent inputs share one form. +65. `codingTheoryParseParityCheck(text)` - Parse a text or structured value into a parity check. +66. `codingTheoryFormatParityCheck(value)` - Format a parity check for deterministic user-facing output. +67. `codingTheoryCompareParityCheck(left, right)` - Compare two parity check values under the conventions of Coding Theory. +68. `codingTheoryCombineParityCheck(left, right)` - Combine two parity check values with the natural operation for Coding Theory. +69. `codingTheoryDecomposeParityCheck(value)` - Decompose a parity check into simpler or canonical components. +70. `codingTheoryEvaluateParityCheck(value, point=None)` - Evaluate a parity check at a point, sample, or finite model. +71. `codingTheoryComputeParityCheck(value)` - Compute the central numerical or symbolic data of a parity check. +72. `codingTheoryEstimateParityCheck(value, samples=None)` - Estimate a parity check property from finite samples or approximations. +73. `codingTheoryApproximateParityCheck(value, tolerance=1e-9)` - Approximate a parity check with explicit tolerance controls. +74. `codingTheoryTransformParityCheck(value, mapping)` - Transform a parity check through a map, operator, or representation change. +75. `codingTheorySimplifyParityCheck(value)` - Simplify a parity check without changing its mathematical meaning. +76. `codingTheoryEnumerateParityCheck(value, limit=None)` - Enumerate finite members, cases, or derived objects for a parity check. +77. `codingTheoryClassifyParityCheck(value)` - Classify a parity check by its standard Coding Theory invariants. +78. `codingTheoryTestEquivalenceParityCheck(left, right)` - Test whether two parity check values are equivalent in Coding Theory. +79. `codingTheoryGenerateExampleParityCheck(size=3)` - Generate a small documented example of a parity check. +80. `codingTheoryDocumentParityCheck(value)` - Return a structured explanation of a parity check and related assumptions. +81. `codingTheoryValidateGeneratorMatrix(value)` - Validate the generator matrix representation and domain rules for Coding Theory. +82. `codingTheoryConstructGeneratorMatrix(*args)` - Construct a generator matrix from explicit inputs for Coding Theory. +83. `codingTheoryNormalizeGeneratorMatrix(value)` - Normalize a generator matrix into the standard Coding Theory representation. +84. `codingTheoryCanonicalizeGeneratorMatrix(value)` - Canonicalize a generator matrix so equivalent inputs share one form. +85. `codingTheoryParseGeneratorMatrix(text)` - Parse a text or structured value into a generator matrix. +86. `codingTheoryFormatGeneratorMatrix(value)` - Format a generator matrix for deterministic user-facing output. +87. `codingTheoryCompareGeneratorMatrix(left, right)` - Compare two generator matrix values under the conventions of Coding Theory. +88. `codingTheoryCombineGeneratorMatrix(left, right)` - Combine two generator matrix values with the natural operation for Coding Theory. +89. `codingTheoryDecomposeGeneratorMatrix(value)` - Decompose a generator matrix into simpler or canonical components. +90. `codingTheoryEvaluateGeneratorMatrix(value, point=None)` - Evaluate a generator matrix at a point, sample, or finite model. +91. `codingTheoryComputeGeneratorMatrix(value)` - Compute the central numerical or symbolic data of a generator matrix. +92. `codingTheoryEstimateGeneratorMatrix(value, samples=None)` - Estimate a generator matrix property from finite samples or approximations. +93. `codingTheoryApproximateGeneratorMatrix(value, tolerance=1e-9)` - Approximate a generator matrix with explicit tolerance controls. +94. `codingTheoryTransformGeneratorMatrix(value, mapping)` - Transform a generator matrix through a map, operator, or representation change. +95. `codingTheorySimplifyGeneratorMatrix(value)` - Simplify a generator matrix without changing its mathematical meaning. +96. `codingTheoryEnumerateGeneratorMatrix(value, limit=None)` - Enumerate finite members, cases, or derived objects for a generator matrix. +97. `codingTheoryClassifyGeneratorMatrix(value)` - Classify a generator matrix by its standard Coding Theory invariants. +98. `codingTheoryTestEquivalenceGeneratorMatrix(left, right)` - Test whether two generator matrix values are equivalent in Coding Theory. +99. `codingTheoryGenerateExampleGeneratorMatrix(size=3)` - Generate a small documented example of a generator matrix. +100. `codingTheoryDocumentGeneratorMatrix(value)` - Return a structured explanation of a generator matrix and related assumptions. + +### Cryptography + +Core object families: + +- cipher +- key pair +- modular primitive +- protocol step +- educational attack + +Candidate functions: + +1. `cryptographyValidateCipher(value)` - Validate the cipher representation and domain rules for Cryptography. +2. `cryptographyConstructCipher(*args)` - Construct a cipher from explicit inputs for Cryptography. +3. `cryptographyNormalizeCipher(value)` - Normalize a cipher into the standard Cryptography representation. +4. `cryptographyCanonicalizeCipher(value)` - Canonicalize a cipher so equivalent inputs share one form. +5. `cryptographyParseCipher(text)` - Parse a text or structured value into a cipher. +6. `cryptographyFormatCipher(value)` - Format a cipher for deterministic user-facing output. +7. `cryptographyCompareCipher(left, right)` - Compare two cipher values under the conventions of Cryptography. +8. `cryptographyCombineCipher(left, right)` - Combine two cipher values with the natural operation for Cryptography. +9. `cryptographyDecomposeCipher(value)` - Decompose a cipher into simpler or canonical components. +10. `cryptographyEvaluateCipher(value, point=None)` - Evaluate a cipher at a point, sample, or finite model. +11. `cryptographyComputeCipher(value)` - Compute the central numerical or symbolic data of a cipher. +12. `cryptographyEstimateCipher(value, samples=None)` - Estimate a cipher property from finite samples or approximations. +13. `cryptographyApproximateCipher(value, tolerance=1e-9)` - Approximate a cipher with explicit tolerance controls. +14. `cryptographyTransformCipher(value, mapping)` - Transform a cipher through a map, operator, or representation change. +15. `cryptographySimplifyCipher(value)` - Simplify a cipher without changing its mathematical meaning. +16. `cryptographyEnumerateCipher(value, limit=None)` - Enumerate finite members, cases, or derived objects for a cipher. +17. `cryptographyClassifyCipher(value)` - Classify a cipher by its standard Cryptography invariants. +18. `cryptographyTestEquivalenceCipher(left, right)` - Test whether two cipher values are equivalent in Cryptography. +19. `cryptographyGenerateExampleCipher(size=3)` - Generate a small documented example of a cipher. +20. `cryptographyDocumentCipher(value)` - Return a structured explanation of a cipher and related assumptions. +21. `cryptographyValidateKeyPair(value)` - Validate the key pair representation and domain rules for Cryptography. +22. `cryptographyConstructKeyPair(*args)` - Construct a key pair from explicit inputs for Cryptography. +23. `cryptographyNormalizeKeyPair(value)` - Normalize a key pair into the standard Cryptography representation. +24. `cryptographyCanonicalizeKeyPair(value)` - Canonicalize a key pair so equivalent inputs share one form. +25. `cryptographyParseKeyPair(text)` - Parse a text or structured value into a key pair. +26. `cryptographyFormatKeyPair(value)` - Format a key pair for deterministic user-facing output. +27. `cryptographyCompareKeyPair(left, right)` - Compare two key pair values under the conventions of Cryptography. +28. `cryptographyCombineKeyPair(left, right)` - Combine two key pair values with the natural operation for Cryptography. +29. `cryptographyDecomposeKeyPair(value)` - Decompose a key pair into simpler or canonical components. +30. `cryptographyEvaluateKeyPair(value, point=None)` - Evaluate a key pair at a point, sample, or finite model. +31. `cryptographyComputeKeyPair(value)` - Compute the central numerical or symbolic data of a key pair. +32. `cryptographyEstimateKeyPair(value, samples=None)` - Estimate a key pair property from finite samples or approximations. +33. `cryptographyApproximateKeyPair(value, tolerance=1e-9)` - Approximate a key pair with explicit tolerance controls. +34. `cryptographyTransformKeyPair(value, mapping)` - Transform a key pair through a map, operator, or representation change. +35. `cryptographySimplifyKeyPair(value)` - Simplify a key pair without changing its mathematical meaning. +36. `cryptographyEnumerateKeyPair(value, limit=None)` - Enumerate finite members, cases, or derived objects for a key pair. +37. `cryptographyClassifyKeyPair(value)` - Classify a key pair by its standard Cryptography invariants. +38. `cryptographyTestEquivalenceKeyPair(left, right)` - Test whether two key pair values are equivalent in Cryptography. +39. `cryptographyGenerateExampleKeyPair(size=3)` - Generate a small documented example of a key pair. +40. `cryptographyDocumentKeyPair(value)` - Return a structured explanation of a key pair and related assumptions. +41. `cryptographyValidateModularPrimitive(value)` - Validate the modular primitive representation and domain rules for Cryptography. +42. `cryptographyConstructModularPrimitive(*args)` - Construct a modular primitive from explicit inputs for Cryptography. +43. `cryptographyNormalizeModularPrimitive(value)` - Normalize a modular primitive into the standard Cryptography representation. +44. `cryptographyCanonicalizeModularPrimitive(value)` - Canonicalize a modular primitive so equivalent inputs share one form. +45. `cryptographyParseModularPrimitive(text)` - Parse a text or structured value into a modular primitive. +46. `cryptographyFormatModularPrimitive(value)` - Format a modular primitive for deterministic user-facing output. +47. `cryptographyCompareModularPrimitive(left, right)` - Compare two modular primitive values under the conventions of Cryptography. +48. `cryptographyCombineModularPrimitive(left, right)` - Combine two modular primitive values with the natural operation for Cryptography. +49. `cryptographyDecomposeModularPrimitive(value)` - Decompose a modular primitive into simpler or canonical components. +50. `cryptographyEvaluateModularPrimitive(value, point=None)` - Evaluate a modular primitive at a point, sample, or finite model. +51. `cryptographyComputeModularPrimitive(value)` - Compute the central numerical or symbolic data of a modular primitive. +52. `cryptographyEstimateModularPrimitive(value, samples=None)` - Estimate a modular primitive property from finite samples or approximations. +53. `cryptographyApproximateModularPrimitive(value, tolerance=1e-9)` - Approximate a modular primitive with explicit tolerance controls. +54. `cryptographyTransformModularPrimitive(value, mapping)` - Transform a modular primitive through a map, operator, or representation change. +55. `cryptographySimplifyModularPrimitive(value)` - Simplify a modular primitive without changing its mathematical meaning. +56. `cryptographyEnumerateModularPrimitive(value, limit=None)` - Enumerate finite members, cases, or derived objects for a modular primitive. +57. `cryptographyClassifyModularPrimitive(value)` - Classify a modular primitive by its standard Cryptography invariants. +58. `cryptographyTestEquivalenceModularPrimitive(left, right)` - Test whether two modular primitive values are equivalent in Cryptography. +59. `cryptographyGenerateExampleModularPrimitive(size=3)` - Generate a small documented example of a modular primitive. +60. `cryptographyDocumentModularPrimitive(value)` - Return a structured explanation of a modular primitive and related assumptions. +61. `cryptographyValidateProtocolStep(value)` - Validate the protocol step representation and domain rules for Cryptography. +62. `cryptographyConstructProtocolStep(*args)` - Construct a protocol step from explicit inputs for Cryptography. +63. `cryptographyNormalizeProtocolStep(value)` - Normalize a protocol step into the standard Cryptography representation. +64. `cryptographyCanonicalizeProtocolStep(value)` - Canonicalize a protocol step so equivalent inputs share one form. +65. `cryptographyParseProtocolStep(text)` - Parse a text or structured value into a protocol step. +66. `cryptographyFormatProtocolStep(value)` - Format a protocol step for deterministic user-facing output. +67. `cryptographyCompareProtocolStep(left, right)` - Compare two protocol step values under the conventions of Cryptography. +68. `cryptographyCombineProtocolStep(left, right)` - Combine two protocol step values with the natural operation for Cryptography. +69. `cryptographyDecomposeProtocolStep(value)` - Decompose a protocol step into simpler or canonical components. +70. `cryptographyEvaluateProtocolStep(value, point=None)` - Evaluate a protocol step at a point, sample, or finite model. +71. `cryptographyComputeProtocolStep(value)` - Compute the central numerical or symbolic data of a protocol step. +72. `cryptographyEstimateProtocolStep(value, samples=None)` - Estimate a protocol step property from finite samples or approximations. +73. `cryptographyApproximateProtocolStep(value, tolerance=1e-9)` - Approximate a protocol step with explicit tolerance controls. +74. `cryptographyTransformProtocolStep(value, mapping)` - Transform a protocol step through a map, operator, or representation change. +75. `cryptographySimplifyProtocolStep(value)` - Simplify a protocol step without changing its mathematical meaning. +76. `cryptographyEnumerateProtocolStep(value, limit=None)` - Enumerate finite members, cases, or derived objects for a protocol step. +77. `cryptographyClassifyProtocolStep(value)` - Classify a protocol step by its standard Cryptography invariants. +78. `cryptographyTestEquivalenceProtocolStep(left, right)` - Test whether two protocol step values are equivalent in Cryptography. +79. `cryptographyGenerateExampleProtocolStep(size=3)` - Generate a small documented example of a protocol step. +80. `cryptographyDocumentProtocolStep(value)` - Return a structured explanation of a protocol step and related assumptions. +81. `cryptographyValidateEducationalAttack(value)` - Validate the educational attack representation and domain rules for Cryptography. +82. `cryptographyConstructEducationalAttack(*args)` - Construct a educational attack from explicit inputs for Cryptography. +83. `cryptographyNormalizeEducationalAttack(value)` - Normalize a educational attack into the standard Cryptography representation. +84. `cryptographyCanonicalizeEducationalAttack(value)` - Canonicalize a educational attack so equivalent inputs share one form. +85. `cryptographyParseEducationalAttack(text)` - Parse a text or structured value into a educational attack. +86. `cryptographyFormatEducationalAttack(value)` - Format a educational attack for deterministic user-facing output. +87. `cryptographyCompareEducationalAttack(left, right)` - Compare two educational attack values under the conventions of Cryptography. +88. `cryptographyCombineEducationalAttack(left, right)` - Combine two educational attack values with the natural operation for Cryptography. +89. `cryptographyDecomposeEducationalAttack(value)` - Decompose a educational attack into simpler or canonical components. +90. `cryptographyEvaluateEducationalAttack(value, point=None)` - Evaluate a educational attack at a point, sample, or finite model. +91. `cryptographyComputeEducationalAttack(value)` - Compute the central numerical or symbolic data of a educational attack. +92. `cryptographyEstimateEducationalAttack(value, samples=None)` - Estimate a educational attack property from finite samples or approximations. +93. `cryptographyApproximateEducationalAttack(value, tolerance=1e-9)` - Approximate a educational attack with explicit tolerance controls. +94. `cryptographyTransformEducationalAttack(value, mapping)` - Transform a educational attack through a map, operator, or representation change. +95. `cryptographySimplifyEducationalAttack(value)` - Simplify a educational attack without changing its mathematical meaning. +96. `cryptographyEnumerateEducationalAttack(value, limit=None)` - Enumerate finite members, cases, or derived objects for a educational attack. +97. `cryptographyClassifyEducationalAttack(value)` - Classify a educational attack by its standard Cryptography invariants. +98. `cryptographyTestEquivalenceEducationalAttack(left, right)` - Test whether two educational attack values are equivalent in Cryptography. +99. `cryptographyGenerateExampleEducationalAttack(size=3)` - Generate a small documented example of a educational attack. +100. `cryptographyDocumentEducationalAttack(value)` - Return a structured explanation of a educational attack and related assumptions. + +### Finite Fields + +Core object families: + +- field element +- prime field +- extension field +- primitive element +- field polynomial + +Candidate functions: + +1. `finiteFieldsValidateFieldElement(value)` - Validate the field element representation and domain rules for Finite Fields. +2. `finiteFieldsConstructFieldElement(*args)` - Construct a field element from explicit inputs for Finite Fields. +3. `finiteFieldsNormalizeFieldElement(value)` - Normalize a field element into the standard Finite Fields representation. +4. `finiteFieldsCanonicalizeFieldElement(value)` - Canonicalize a field element so equivalent inputs share one form. +5. `finiteFieldsParseFieldElement(text)` - Parse a text or structured value into a field element. +6. `finiteFieldsFormatFieldElement(value)` - Format a field element for deterministic user-facing output. +7. `finiteFieldsCompareFieldElement(left, right)` - Compare two field element values under the conventions of Finite Fields. +8. `finiteFieldsCombineFieldElement(left, right)` - Combine two field element values with the natural operation for Finite Fields. +9. `finiteFieldsDecomposeFieldElement(value)` - Decompose a field element into simpler or canonical components. +10. `finiteFieldsEvaluateFieldElement(value, point=None)` - Evaluate a field element at a point, sample, or finite model. +11. `finiteFieldsComputeFieldElement(value)` - Compute the central numerical or symbolic data of a field element. +12. `finiteFieldsEstimateFieldElement(value, samples=None)` - Estimate a field element property from finite samples or approximations. +13. `finiteFieldsApproximateFieldElement(value, tolerance=1e-9)` - Approximate a field element with explicit tolerance controls. +14. `finiteFieldsTransformFieldElement(value, mapping)` - Transform a field element through a map, operator, or representation change. +15. `finiteFieldsSimplifyFieldElement(value)` - Simplify a field element without changing its mathematical meaning. +16. `finiteFieldsEnumerateFieldElement(value, limit=None)` - Enumerate finite members, cases, or derived objects for a field element. +17. `finiteFieldsClassifyFieldElement(value)` - Classify a field element by its standard Finite Fields invariants. +18. `finiteFieldsTestEquivalenceFieldElement(left, right)` - Test whether two field element values are equivalent in Finite Fields. +19. `finiteFieldsGenerateExampleFieldElement(size=3)` - Generate a small documented example of a field element. +20. `finiteFieldsDocumentFieldElement(value)` - Return a structured explanation of a field element and related assumptions. +21. `finiteFieldsValidatePrimeField(value)` - Validate the prime field representation and domain rules for Finite Fields. +22. `finiteFieldsConstructPrimeField(*args)` - Construct a prime field from explicit inputs for Finite Fields. +23. `finiteFieldsNormalizePrimeField(value)` - Normalize a prime field into the standard Finite Fields representation. +24. `finiteFieldsCanonicalizePrimeField(value)` - Canonicalize a prime field so equivalent inputs share one form. +25. `finiteFieldsParsePrimeField(text)` - Parse a text or structured value into a prime field. +26. `finiteFieldsFormatPrimeField(value)` - Format a prime field for deterministic user-facing output. +27. `finiteFieldsComparePrimeField(left, right)` - Compare two prime field values under the conventions of Finite Fields. +28. `finiteFieldsCombinePrimeField(left, right)` - Combine two prime field values with the natural operation for Finite Fields. +29. `finiteFieldsDecomposePrimeField(value)` - Decompose a prime field into simpler or canonical components. +30. `finiteFieldsEvaluatePrimeField(value, point=None)` - Evaluate a prime field at a point, sample, or finite model. +31. `finiteFieldsComputePrimeField(value)` - Compute the central numerical or symbolic data of a prime field. +32. `finiteFieldsEstimatePrimeField(value, samples=None)` - Estimate a prime field property from finite samples or approximations. +33. `finiteFieldsApproximatePrimeField(value, tolerance=1e-9)` - Approximate a prime field with explicit tolerance controls. +34. `finiteFieldsTransformPrimeField(value, mapping)` - Transform a prime field through a map, operator, or representation change. +35. `finiteFieldsSimplifyPrimeField(value)` - Simplify a prime field without changing its mathematical meaning. +36. `finiteFieldsEnumeratePrimeField(value, limit=None)` - Enumerate finite members, cases, or derived objects for a prime field. +37. `finiteFieldsClassifyPrimeField(value)` - Classify a prime field by its standard Finite Fields invariants. +38. `finiteFieldsTestEquivalencePrimeField(left, right)` - Test whether two prime field values are equivalent in Finite Fields. +39. `finiteFieldsGenerateExamplePrimeField(size=3)` - Generate a small documented example of a prime field. +40. `finiteFieldsDocumentPrimeField(value)` - Return a structured explanation of a prime field and related assumptions. +41. `finiteFieldsValidateExtensionField(value)` - Validate the extension field representation and domain rules for Finite Fields. +42. `finiteFieldsConstructExtensionField(*args)` - Construct a extension field from explicit inputs for Finite Fields. +43. `finiteFieldsNormalizeExtensionField(value)` - Normalize a extension field into the standard Finite Fields representation. +44. `finiteFieldsCanonicalizeExtensionField(value)` - Canonicalize a extension field so equivalent inputs share one form. +45. `finiteFieldsParseExtensionField(text)` - Parse a text or structured value into a extension field. +46. `finiteFieldsFormatExtensionField(value)` - Format a extension field for deterministic user-facing output. +47. `finiteFieldsCompareExtensionField(left, right)` - Compare two extension field values under the conventions of Finite Fields. +48. `finiteFieldsCombineExtensionField(left, right)` - Combine two extension field values with the natural operation for Finite Fields. +49. `finiteFieldsDecomposeExtensionField(value)` - Decompose a extension field into simpler or canonical components. +50. `finiteFieldsEvaluateExtensionField(value, point=None)` - Evaluate a extension field at a point, sample, or finite model. +51. `finiteFieldsComputeExtensionField(value)` - Compute the central numerical or symbolic data of a extension field. +52. `finiteFieldsEstimateExtensionField(value, samples=None)` - Estimate a extension field property from finite samples or approximations. +53. `finiteFieldsApproximateExtensionField(value, tolerance=1e-9)` - Approximate a extension field with explicit tolerance controls. +54. `finiteFieldsTransformExtensionField(value, mapping)` - Transform a extension field through a map, operator, or representation change. +55. `finiteFieldsSimplifyExtensionField(value)` - Simplify a extension field without changing its mathematical meaning. +56. `finiteFieldsEnumerateExtensionField(value, limit=None)` - Enumerate finite members, cases, or derived objects for a extension field. +57. `finiteFieldsClassifyExtensionField(value)` - Classify a extension field by its standard Finite Fields invariants. +58. `finiteFieldsTestEquivalenceExtensionField(left, right)` - Test whether two extension field values are equivalent in Finite Fields. +59. `finiteFieldsGenerateExampleExtensionField(size=3)` - Generate a small documented example of a extension field. +60. `finiteFieldsDocumentExtensionField(value)` - Return a structured explanation of a extension field and related assumptions. +61. `finiteFieldsValidatePrimitiveElement(value)` - Validate the primitive element representation and domain rules for Finite Fields. +62. `finiteFieldsConstructPrimitiveElement(*args)` - Construct a primitive element from explicit inputs for Finite Fields. +63. `finiteFieldsNormalizePrimitiveElement(value)` - Normalize a primitive element into the standard Finite Fields representation. +64. `finiteFieldsCanonicalizePrimitiveElement(value)` - Canonicalize a primitive element so equivalent inputs share one form. +65. `finiteFieldsParsePrimitiveElement(text)` - Parse a text or structured value into a primitive element. +66. `finiteFieldsFormatPrimitiveElement(value)` - Format a primitive element for deterministic user-facing output. +67. `finiteFieldsComparePrimitiveElement(left, right)` - Compare two primitive element values under the conventions of Finite Fields. +68. `finiteFieldsCombinePrimitiveElement(left, right)` - Combine two primitive element values with the natural operation for Finite Fields. +69. `finiteFieldsDecomposePrimitiveElement(value)` - Decompose a primitive element into simpler or canonical components. +70. `finiteFieldsEvaluatePrimitiveElement(value, point=None)` - Evaluate a primitive element at a point, sample, or finite model. +71. `finiteFieldsComputePrimitiveElement(value)` - Compute the central numerical or symbolic data of a primitive element. +72. `finiteFieldsEstimatePrimitiveElement(value, samples=None)` - Estimate a primitive element property from finite samples or approximations. +73. `finiteFieldsApproximatePrimitiveElement(value, tolerance=1e-9)` - Approximate a primitive element with explicit tolerance controls. +74. `finiteFieldsTransformPrimitiveElement(value, mapping)` - Transform a primitive element through a map, operator, or representation change. +75. `finiteFieldsSimplifyPrimitiveElement(value)` - Simplify a primitive element without changing its mathematical meaning. +76. `finiteFieldsEnumeratePrimitiveElement(value, limit=None)` - Enumerate finite members, cases, or derived objects for a primitive element. +77. `finiteFieldsClassifyPrimitiveElement(value)` - Classify a primitive element by its standard Finite Fields invariants. +78. `finiteFieldsTestEquivalencePrimitiveElement(left, right)` - Test whether two primitive element values are equivalent in Finite Fields. +79. `finiteFieldsGenerateExamplePrimitiveElement(size=3)` - Generate a small documented example of a primitive element. +80. `finiteFieldsDocumentPrimitiveElement(value)` - Return a structured explanation of a primitive element and related assumptions. +81. `finiteFieldsValidateFieldPolynomial(value)` - Validate the field polynomial representation and domain rules for Finite Fields. +82. `finiteFieldsConstructFieldPolynomial(*args)` - Construct a field polynomial from explicit inputs for Finite Fields. +83. `finiteFieldsNormalizeFieldPolynomial(value)` - Normalize a field polynomial into the standard Finite Fields representation. +84. `finiteFieldsCanonicalizeFieldPolynomial(value)` - Canonicalize a field polynomial so equivalent inputs share one form. +85. `finiteFieldsParseFieldPolynomial(text)` - Parse a text or structured value into a field polynomial. +86. `finiteFieldsFormatFieldPolynomial(value)` - Format a field polynomial for deterministic user-facing output. +87. `finiteFieldsCompareFieldPolynomial(left, right)` - Compare two field polynomial values under the conventions of Finite Fields. +88. `finiteFieldsCombineFieldPolynomial(left, right)` - Combine two field polynomial values with the natural operation for Finite Fields. +89. `finiteFieldsDecomposeFieldPolynomial(value)` - Decompose a field polynomial into simpler or canonical components. +90. `finiteFieldsEvaluateFieldPolynomial(value, point=None)` - Evaluate a field polynomial at a point, sample, or finite model. +91. `finiteFieldsComputeFieldPolynomial(value)` - Compute the central numerical or symbolic data of a field polynomial. +92. `finiteFieldsEstimateFieldPolynomial(value, samples=None)` - Estimate a field polynomial property from finite samples or approximations. +93. `finiteFieldsApproximateFieldPolynomial(value, tolerance=1e-9)` - Approximate a field polynomial with explicit tolerance controls. +94. `finiteFieldsTransformFieldPolynomial(value, mapping)` - Transform a field polynomial through a map, operator, or representation change. +95. `finiteFieldsSimplifyFieldPolynomial(value)` - Simplify a field polynomial without changing its mathematical meaning. +96. `finiteFieldsEnumerateFieldPolynomial(value, limit=None)` - Enumerate finite members, cases, or derived objects for a field polynomial. +97. `finiteFieldsClassifyFieldPolynomial(value)` - Classify a field polynomial by its standard Finite Fields invariants. +98. `finiteFieldsTestEquivalenceFieldPolynomial(left, right)` - Test whether two field polynomial values are equivalent in Finite Fields. +99. `finiteFieldsGenerateExampleFieldPolynomial(size=3)` - Generate a small documented example of a field polynomial. +100. `finiteFieldsDocumentFieldPolynomial(value)` - Return a structured explanation of a field polynomial and related assumptions. + +### Analytic Number Theory + +Core object families: + +- prime counting model +- zeta approximation +- arithmetic sum +- Chebyshev function +- Dirichlet series + +Candidate functions: + +1. `analyticNumberTheoryValidatePrimeCountingModel(value)` - Validate the prime counting model representation and domain rules for Analytic Number Theory. +2. `analyticNumberTheoryConstructPrimeCountingModel(*args)` - Construct a prime counting model from explicit inputs for Analytic Number Theory. +3. `analyticNumberTheoryNormalizePrimeCountingModel(value)` - Normalize a prime counting model into the standard Analytic Number Theory representation. +4. `analyticNumberTheoryCanonicalizePrimeCountingModel(value)` - Canonicalize a prime counting model so equivalent inputs share one form. +5. `analyticNumberTheoryParsePrimeCountingModel(text)` - Parse a text or structured value into a prime counting model. +6. `analyticNumberTheoryFormatPrimeCountingModel(value)` - Format a prime counting model for deterministic user-facing output. +7. `analyticNumberTheoryComparePrimeCountingModel(left, right)` - Compare two prime counting model values under the conventions of Analytic Number Theory. +8. `analyticNumberTheoryCombinePrimeCountingModel(left, right)` - Combine two prime counting model values with the natural operation for Analytic Number Theory. +9. `analyticNumberTheoryDecomposePrimeCountingModel(value)` - Decompose a prime counting model into simpler or canonical components. +10. `analyticNumberTheoryEvaluatePrimeCountingModel(value, point=None)` - Evaluate a prime counting model at a point, sample, or finite model. +11. `analyticNumberTheoryComputePrimeCountingModel(value)` - Compute the central numerical or symbolic data of a prime counting model. +12. `analyticNumberTheoryEstimatePrimeCountingModel(value, samples=None)` - Estimate a prime counting model property from finite samples or approximations. +13. `analyticNumberTheoryApproximatePrimeCountingModel(value, tolerance=1e-9)` - Approximate a prime counting model with explicit tolerance controls. +14. `analyticNumberTheoryTransformPrimeCountingModel(value, mapping)` - Transform a prime counting model through a map, operator, or representation change. +15. `analyticNumberTheorySimplifyPrimeCountingModel(value)` - Simplify a prime counting model without changing its mathematical meaning. +16. `analyticNumberTheoryEnumeratePrimeCountingModel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a prime counting model. +17. `analyticNumberTheoryClassifyPrimeCountingModel(value)` - Classify a prime counting model by its standard Analytic Number Theory invariants. +18. `analyticNumberTheoryTestEquivalencePrimeCountingModel(left, right)` - Test whether two prime counting model values are equivalent in Analytic Number Theory. +19. `analyticNumberTheoryGenerateExamplePrimeCountingModel(size=3)` - Generate a small documented example of a prime counting model. +20. `analyticNumberTheoryDocumentPrimeCountingModel(value)` - Return a structured explanation of a prime counting model and related assumptions. +21. `analyticNumberTheoryValidateZetaApproximation(value)` - Validate the zeta approximation representation and domain rules for Analytic Number Theory. +22. `analyticNumberTheoryConstructZetaApproximation(*args)` - Construct a zeta approximation from explicit inputs for Analytic Number Theory. +23. `analyticNumberTheoryNormalizeZetaApproximation(value)` - Normalize a zeta approximation into the standard Analytic Number Theory representation. +24. `analyticNumberTheoryCanonicalizeZetaApproximation(value)` - Canonicalize a zeta approximation so equivalent inputs share one form. +25. `analyticNumberTheoryParseZetaApproximation(text)` - Parse a text or structured value into a zeta approximation. +26. `analyticNumberTheoryFormatZetaApproximation(value)` - Format a zeta approximation for deterministic user-facing output. +27. `analyticNumberTheoryCompareZetaApproximation(left, right)` - Compare two zeta approximation values under the conventions of Analytic Number Theory. +28. `analyticNumberTheoryCombineZetaApproximation(left, right)` - Combine two zeta approximation values with the natural operation for Analytic Number Theory. +29. `analyticNumberTheoryDecomposeZetaApproximation(value)` - Decompose a zeta approximation into simpler or canonical components. +30. `analyticNumberTheoryEvaluateZetaApproximation(value, point=None)` - Evaluate a zeta approximation at a point, sample, or finite model. +31. `analyticNumberTheoryComputeZetaApproximation(value)` - Compute the central numerical or symbolic data of a zeta approximation. +32. `analyticNumberTheoryEstimateZetaApproximation(value, samples=None)` - Estimate a zeta approximation property from finite samples or approximations. +33. `analyticNumberTheoryApproximateZetaApproximation(value, tolerance=1e-9)` - Approximate a zeta approximation with explicit tolerance controls. +34. `analyticNumberTheoryTransformZetaApproximation(value, mapping)` - Transform a zeta approximation through a map, operator, or representation change. +35. `analyticNumberTheorySimplifyZetaApproximation(value)` - Simplify a zeta approximation without changing its mathematical meaning. +36. `analyticNumberTheoryEnumerateZetaApproximation(value, limit=None)` - Enumerate finite members, cases, or derived objects for a zeta approximation. +37. `analyticNumberTheoryClassifyZetaApproximation(value)` - Classify a zeta approximation by its standard Analytic Number Theory invariants. +38. `analyticNumberTheoryTestEquivalenceZetaApproximation(left, right)` - Test whether two zeta approximation values are equivalent in Analytic Number Theory. +39. `analyticNumberTheoryGenerateExampleZetaApproximation(size=3)` - Generate a small documented example of a zeta approximation. +40. `analyticNumberTheoryDocumentZetaApproximation(value)` - Return a structured explanation of a zeta approximation and related assumptions. +41. `analyticNumberTheoryValidateArithmeticSum(value)` - Validate the arithmetic sum representation and domain rules for Analytic Number Theory. +42. `analyticNumberTheoryConstructArithmeticSum(*args)` - Construct a arithmetic sum from explicit inputs for Analytic Number Theory. +43. `analyticNumberTheoryNormalizeArithmeticSum(value)` - Normalize a arithmetic sum into the standard Analytic Number Theory representation. +44. `analyticNumberTheoryCanonicalizeArithmeticSum(value)` - Canonicalize a arithmetic sum so equivalent inputs share one form. +45. `analyticNumberTheoryParseArithmeticSum(text)` - Parse a text or structured value into a arithmetic sum. +46. `analyticNumberTheoryFormatArithmeticSum(value)` - Format a arithmetic sum for deterministic user-facing output. +47. `analyticNumberTheoryCompareArithmeticSum(left, right)` - Compare two arithmetic sum values under the conventions of Analytic Number Theory. +48. `analyticNumberTheoryCombineArithmeticSum(left, right)` - Combine two arithmetic sum values with the natural operation for Analytic Number Theory. +49. `analyticNumberTheoryDecomposeArithmeticSum(value)` - Decompose a arithmetic sum into simpler or canonical components. +50. `analyticNumberTheoryEvaluateArithmeticSum(value, point=None)` - Evaluate a arithmetic sum at a point, sample, or finite model. +51. `analyticNumberTheoryComputeArithmeticSum(value)` - Compute the central numerical or symbolic data of a arithmetic sum. +52. `analyticNumberTheoryEstimateArithmeticSum(value, samples=None)` - Estimate a arithmetic sum property from finite samples or approximations. +53. `analyticNumberTheoryApproximateArithmeticSum(value, tolerance=1e-9)` - Approximate a arithmetic sum with explicit tolerance controls. +54. `analyticNumberTheoryTransformArithmeticSum(value, mapping)` - Transform a arithmetic sum through a map, operator, or representation change. +55. `analyticNumberTheorySimplifyArithmeticSum(value)` - Simplify a arithmetic sum without changing its mathematical meaning. +56. `analyticNumberTheoryEnumerateArithmeticSum(value, limit=None)` - Enumerate finite members, cases, or derived objects for a arithmetic sum. +57. `analyticNumberTheoryClassifyArithmeticSum(value)` - Classify a arithmetic sum by its standard Analytic Number Theory invariants. +58. `analyticNumberTheoryTestEquivalenceArithmeticSum(left, right)` - Test whether two arithmetic sum values are equivalent in Analytic Number Theory. +59. `analyticNumberTheoryGenerateExampleArithmeticSum(size=3)` - Generate a small documented example of a arithmetic sum. +60. `analyticNumberTheoryDocumentArithmeticSum(value)` - Return a structured explanation of a arithmetic sum and related assumptions. +61. `analyticNumberTheoryValidateChebyshevFunction(value)` - Validate the Chebyshev function representation and domain rules for Analytic Number Theory. +62. `analyticNumberTheoryConstructChebyshevFunction(*args)` - Construct a Chebyshev function from explicit inputs for Analytic Number Theory. +63. `analyticNumberTheoryNormalizeChebyshevFunction(value)` - Normalize a Chebyshev function into the standard Analytic Number Theory representation. +64. `analyticNumberTheoryCanonicalizeChebyshevFunction(value)` - Canonicalize a Chebyshev function so equivalent inputs share one form. +65. `analyticNumberTheoryParseChebyshevFunction(text)` - Parse a text or structured value into a Chebyshev function. +66. `analyticNumberTheoryFormatChebyshevFunction(value)` - Format a Chebyshev function for deterministic user-facing output. +67. `analyticNumberTheoryCompareChebyshevFunction(left, right)` - Compare two Chebyshev function values under the conventions of Analytic Number Theory. +68. `analyticNumberTheoryCombineChebyshevFunction(left, right)` - Combine two Chebyshev function values with the natural operation for Analytic Number Theory. +69. `analyticNumberTheoryDecomposeChebyshevFunction(value)` - Decompose a Chebyshev function into simpler or canonical components. +70. `analyticNumberTheoryEvaluateChebyshevFunction(value, point=None)` - Evaluate a Chebyshev function at a point, sample, or finite model. +71. `analyticNumberTheoryComputeChebyshevFunction(value)` - Compute the central numerical or symbolic data of a Chebyshev function. +72. `analyticNumberTheoryEstimateChebyshevFunction(value, samples=None)` - Estimate a Chebyshev function property from finite samples or approximations. +73. `analyticNumberTheoryApproximateChebyshevFunction(value, tolerance=1e-9)` - Approximate a Chebyshev function with explicit tolerance controls. +74. `analyticNumberTheoryTransformChebyshevFunction(value, mapping)` - Transform a Chebyshev function through a map, operator, or representation change. +75. `analyticNumberTheorySimplifyChebyshevFunction(value)` - Simplify a Chebyshev function without changing its mathematical meaning. +76. `analyticNumberTheoryEnumerateChebyshevFunction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a Chebyshev function. +77. `analyticNumberTheoryClassifyChebyshevFunction(value)` - Classify a Chebyshev function by its standard Analytic Number Theory invariants. +78. `analyticNumberTheoryTestEquivalenceChebyshevFunction(left, right)` - Test whether two Chebyshev function values are equivalent in Analytic Number Theory. +79. `analyticNumberTheoryGenerateExampleChebyshevFunction(size=3)` - Generate a small documented example of a Chebyshev function. +80. `analyticNumberTheoryDocumentChebyshevFunction(value)` - Return a structured explanation of a Chebyshev function and related assumptions. +81. `analyticNumberTheoryValidateDirichletSeries(value)` - Validate the Dirichlet series representation and domain rules for Analytic Number Theory. +82. `analyticNumberTheoryConstructDirichletSeries(*args)` - Construct a Dirichlet series from explicit inputs for Analytic Number Theory. +83. `analyticNumberTheoryNormalizeDirichletSeries(value)` - Normalize a Dirichlet series into the standard Analytic Number Theory representation. +84. `analyticNumberTheoryCanonicalizeDirichletSeries(value)` - Canonicalize a Dirichlet series so equivalent inputs share one form. +85. `analyticNumberTheoryParseDirichletSeries(text)` - Parse a text or structured value into a Dirichlet series. +86. `analyticNumberTheoryFormatDirichletSeries(value)` - Format a Dirichlet series for deterministic user-facing output. +87. `analyticNumberTheoryCompareDirichletSeries(left, right)` - Compare two Dirichlet series values under the conventions of Analytic Number Theory. +88. `analyticNumberTheoryCombineDirichletSeries(left, right)` - Combine two Dirichlet series values with the natural operation for Analytic Number Theory. +89. `analyticNumberTheoryDecomposeDirichletSeries(value)` - Decompose a Dirichlet series into simpler or canonical components. +90. `analyticNumberTheoryEvaluateDirichletSeries(value, point=None)` - Evaluate a Dirichlet series at a point, sample, or finite model. +91. `analyticNumberTheoryComputeDirichletSeries(value)` - Compute the central numerical or symbolic data of a Dirichlet series. +92. `analyticNumberTheoryEstimateDirichletSeries(value, samples=None)` - Estimate a Dirichlet series property from finite samples or approximations. +93. `analyticNumberTheoryApproximateDirichletSeries(value, tolerance=1e-9)` - Approximate a Dirichlet series with explicit tolerance controls. +94. `analyticNumberTheoryTransformDirichletSeries(value, mapping)` - Transform a Dirichlet series through a map, operator, or representation change. +95. `analyticNumberTheorySimplifyDirichletSeries(value)` - Simplify a Dirichlet series without changing its mathematical meaning. +96. `analyticNumberTheoryEnumerateDirichletSeries(value, limit=None)` - Enumerate finite members, cases, or derived objects for a Dirichlet series. +97. `analyticNumberTheoryClassifyDirichletSeries(value)` - Classify a Dirichlet series by its standard Analytic Number Theory invariants. +98. `analyticNumberTheoryTestEquivalenceDirichletSeries(left, right)` - Test whether two Dirichlet series values are equivalent in Analytic Number Theory. +99. `analyticNumberTheoryGenerateExampleDirichletSeries(size=3)` - Generate a small documented example of a Dirichlet series. +100. `analyticNumberTheoryDocumentDirichletSeries(value)` - Return a structured explanation of a Dirichlet series and related assumptions. + +### Algebraic Number Theory + +Core object families: + +- number field element +- algebraic integer +- ideal class +- norm map +- trace map + +Candidate functions: + +1. `algebraicNumberTheoryValidateNumberFieldElement(value)` - Validate the number field element representation and domain rules for Algebraic Number Theory. +2. `algebraicNumberTheoryConstructNumberFieldElement(*args)` - Construct a number field element from explicit inputs for Algebraic Number Theory. +3. `algebraicNumberTheoryNormalizeNumberFieldElement(value)` - Normalize a number field element into the standard Algebraic Number Theory representation. +4. `algebraicNumberTheoryCanonicalizeNumberFieldElement(value)` - Canonicalize a number field element so equivalent inputs share one form. +5. `algebraicNumberTheoryParseNumberFieldElement(text)` - Parse a text or structured value into a number field element. +6. `algebraicNumberTheoryFormatNumberFieldElement(value)` - Format a number field element for deterministic user-facing output. +7. `algebraicNumberTheoryCompareNumberFieldElement(left, right)` - Compare two number field element values under the conventions of Algebraic Number Theory. +8. `algebraicNumberTheoryCombineNumberFieldElement(left, right)` - Combine two number field element values with the natural operation for Algebraic Number Theory. +9. `algebraicNumberTheoryDecomposeNumberFieldElement(value)` - Decompose a number field element into simpler or canonical components. +10. `algebraicNumberTheoryEvaluateNumberFieldElement(value, point=None)` - Evaluate a number field element at a point, sample, or finite model. +11. `algebraicNumberTheoryComputeNumberFieldElement(value)` - Compute the central numerical or symbolic data of a number field element. +12. `algebraicNumberTheoryEstimateNumberFieldElement(value, samples=None)` - Estimate a number field element property from finite samples or approximations. +13. `algebraicNumberTheoryApproximateNumberFieldElement(value, tolerance=1e-9)` - Approximate a number field element with explicit tolerance controls. +14. `algebraicNumberTheoryTransformNumberFieldElement(value, mapping)` - Transform a number field element through a map, operator, or representation change. +15. `algebraicNumberTheorySimplifyNumberFieldElement(value)` - Simplify a number field element without changing its mathematical meaning. +16. `algebraicNumberTheoryEnumerateNumberFieldElement(value, limit=None)` - Enumerate finite members, cases, or derived objects for a number field element. +17. `algebraicNumberTheoryClassifyNumberFieldElement(value)` - Classify a number field element by its standard Algebraic Number Theory invariants. +18. `algebraicNumberTheoryTestEquivalenceNumberFieldElement(left, right)` - Test whether two number field element values are equivalent in Algebraic Number Theory. +19. `algebraicNumberTheoryGenerateExampleNumberFieldElement(size=3)` - Generate a small documented example of a number field element. +20. `algebraicNumberTheoryDocumentNumberFieldElement(value)` - Return a structured explanation of a number field element and related assumptions. +21. `algebraicNumberTheoryValidateAlgebraicInteger(value)` - Validate the algebraic integer representation and domain rules for Algebraic Number Theory. +22. `algebraicNumberTheoryConstructAlgebraicInteger(*args)` - Construct a algebraic integer from explicit inputs for Algebraic Number Theory. +23. `algebraicNumberTheoryNormalizeAlgebraicInteger(value)` - Normalize a algebraic integer into the standard Algebraic Number Theory representation. +24. `algebraicNumberTheoryCanonicalizeAlgebraicInteger(value)` - Canonicalize a algebraic integer so equivalent inputs share one form. +25. `algebraicNumberTheoryParseAlgebraicInteger(text)` - Parse a text or structured value into a algebraic integer. +26. `algebraicNumberTheoryFormatAlgebraicInteger(value)` - Format a algebraic integer for deterministic user-facing output. +27. `algebraicNumberTheoryCompareAlgebraicInteger(left, right)` - Compare two algebraic integer values under the conventions of Algebraic Number Theory. +28. `algebraicNumberTheoryCombineAlgebraicInteger(left, right)` - Combine two algebraic integer values with the natural operation for Algebraic Number Theory. +29. `algebraicNumberTheoryDecomposeAlgebraicInteger(value)` - Decompose a algebraic integer into simpler or canonical components. +30. `algebraicNumberTheoryEvaluateAlgebraicInteger(value, point=None)` - Evaluate a algebraic integer at a point, sample, or finite model. +31. `algebraicNumberTheoryComputeAlgebraicInteger(value)` - Compute the central numerical or symbolic data of a algebraic integer. +32. `algebraicNumberTheoryEstimateAlgebraicInteger(value, samples=None)` - Estimate a algebraic integer property from finite samples or approximations. +33. `algebraicNumberTheoryApproximateAlgebraicInteger(value, tolerance=1e-9)` - Approximate a algebraic integer with explicit tolerance controls. +34. `algebraicNumberTheoryTransformAlgebraicInteger(value, mapping)` - Transform a algebraic integer through a map, operator, or representation change. +35. `algebraicNumberTheorySimplifyAlgebraicInteger(value)` - Simplify a algebraic integer without changing its mathematical meaning. +36. `algebraicNumberTheoryEnumerateAlgebraicInteger(value, limit=None)` - Enumerate finite members, cases, or derived objects for a algebraic integer. +37. `algebraicNumberTheoryClassifyAlgebraicInteger(value)` - Classify a algebraic integer by its standard Algebraic Number Theory invariants. +38. `algebraicNumberTheoryTestEquivalenceAlgebraicInteger(left, right)` - Test whether two algebraic integer values are equivalent in Algebraic Number Theory. +39. `algebraicNumberTheoryGenerateExampleAlgebraicInteger(size=3)` - Generate a small documented example of a algebraic integer. +40. `algebraicNumberTheoryDocumentAlgebraicInteger(value)` - Return a structured explanation of a algebraic integer and related assumptions. +41. `algebraicNumberTheoryValidateIdealClass(value)` - Validate the ideal class representation and domain rules for Algebraic Number Theory. +42. `algebraicNumberTheoryConstructIdealClass(*args)` - Construct a ideal class from explicit inputs for Algebraic Number Theory. +43. `algebraicNumberTheoryNormalizeIdealClass(value)` - Normalize a ideal class into the standard Algebraic Number Theory representation. +44. `algebraicNumberTheoryCanonicalizeIdealClass(value)` - Canonicalize a ideal class so equivalent inputs share one form. +45. `algebraicNumberTheoryParseIdealClass(text)` - Parse a text or structured value into a ideal class. +46. `algebraicNumberTheoryFormatIdealClass(value)` - Format a ideal class for deterministic user-facing output. +47. `algebraicNumberTheoryCompareIdealClass(left, right)` - Compare two ideal class values under the conventions of Algebraic Number Theory. +48. `algebraicNumberTheoryCombineIdealClass(left, right)` - Combine two ideal class values with the natural operation for Algebraic Number Theory. +49. `algebraicNumberTheoryDecomposeIdealClass(value)` - Decompose a ideal class into simpler or canonical components. +50. `algebraicNumberTheoryEvaluateIdealClass(value, point=None)` - Evaluate a ideal class at a point, sample, or finite model. +51. `algebraicNumberTheoryComputeIdealClass(value)` - Compute the central numerical or symbolic data of a ideal class. +52. `algebraicNumberTheoryEstimateIdealClass(value, samples=None)` - Estimate a ideal class property from finite samples or approximations. +53. `algebraicNumberTheoryApproximateIdealClass(value, tolerance=1e-9)` - Approximate a ideal class with explicit tolerance controls. +54. `algebraicNumberTheoryTransformIdealClass(value, mapping)` - Transform a ideal class through a map, operator, or representation change. +55. `algebraicNumberTheorySimplifyIdealClass(value)` - Simplify a ideal class without changing its mathematical meaning. +56. `algebraicNumberTheoryEnumerateIdealClass(value, limit=None)` - Enumerate finite members, cases, or derived objects for a ideal class. +57. `algebraicNumberTheoryClassifyIdealClass(value)` - Classify a ideal class by its standard Algebraic Number Theory invariants. +58. `algebraicNumberTheoryTestEquivalenceIdealClass(left, right)` - Test whether two ideal class values are equivalent in Algebraic Number Theory. +59. `algebraicNumberTheoryGenerateExampleIdealClass(size=3)` - Generate a small documented example of a ideal class. +60. `algebraicNumberTheoryDocumentIdealClass(value)` - Return a structured explanation of a ideal class and related assumptions. +61. `algebraicNumberTheoryValidateNormMap(value)` - Validate the norm map representation and domain rules for Algebraic Number Theory. +62. `algebraicNumberTheoryConstructNormMap(*args)` - Construct a norm map from explicit inputs for Algebraic Number Theory. +63. `algebraicNumberTheoryNormalizeNormMap(value)` - Normalize a norm map into the standard Algebraic Number Theory representation. +64. `algebraicNumberTheoryCanonicalizeNormMap(value)` - Canonicalize a norm map so equivalent inputs share one form. +65. `algebraicNumberTheoryParseNormMap(text)` - Parse a text or structured value into a norm map. +66. `algebraicNumberTheoryFormatNormMap(value)` - Format a norm map for deterministic user-facing output. +67. `algebraicNumberTheoryCompareNormMap(left, right)` - Compare two norm map values under the conventions of Algebraic Number Theory. +68. `algebraicNumberTheoryCombineNormMap(left, right)` - Combine two norm map values with the natural operation for Algebraic Number Theory. +69. `algebraicNumberTheoryDecomposeNormMap(value)` - Decompose a norm map into simpler or canonical components. +70. `algebraicNumberTheoryEvaluateNormMap(value, point=None)` - Evaluate a norm map at a point, sample, or finite model. +71. `algebraicNumberTheoryComputeNormMap(value)` - Compute the central numerical or symbolic data of a norm map. +72. `algebraicNumberTheoryEstimateNormMap(value, samples=None)` - Estimate a norm map property from finite samples or approximations. +73. `algebraicNumberTheoryApproximateNormMap(value, tolerance=1e-9)` - Approximate a norm map with explicit tolerance controls. +74. `algebraicNumberTheoryTransformNormMap(value, mapping)` - Transform a norm map through a map, operator, or representation change. +75. `algebraicNumberTheorySimplifyNormMap(value)` - Simplify a norm map without changing its mathematical meaning. +76. `algebraicNumberTheoryEnumerateNormMap(value, limit=None)` - Enumerate finite members, cases, or derived objects for a norm map. +77. `algebraicNumberTheoryClassifyNormMap(value)` - Classify a norm map by its standard Algebraic Number Theory invariants. +78. `algebraicNumberTheoryTestEquivalenceNormMap(left, right)` - Test whether two norm map values are equivalent in Algebraic Number Theory. +79. `algebraicNumberTheoryGenerateExampleNormMap(size=3)` - Generate a small documented example of a norm map. +80. `algebraicNumberTheoryDocumentNormMap(value)` - Return a structured explanation of a norm map and related assumptions. +81. `algebraicNumberTheoryValidateTraceMap(value)` - Validate the trace map representation and domain rules for Algebraic Number Theory. +82. `algebraicNumberTheoryConstructTraceMap(*args)` - Construct a trace map from explicit inputs for Algebraic Number Theory. +83. `algebraicNumberTheoryNormalizeTraceMap(value)` - Normalize a trace map into the standard Algebraic Number Theory representation. +84. `algebraicNumberTheoryCanonicalizeTraceMap(value)` - Canonicalize a trace map so equivalent inputs share one form. +85. `algebraicNumberTheoryParseTraceMap(text)` - Parse a text or structured value into a trace map. +86. `algebraicNumberTheoryFormatTraceMap(value)` - Format a trace map for deterministic user-facing output. +87. `algebraicNumberTheoryCompareTraceMap(left, right)` - Compare two trace map values under the conventions of Algebraic Number Theory. +88. `algebraicNumberTheoryCombineTraceMap(left, right)` - Combine two trace map values with the natural operation for Algebraic Number Theory. +89. `algebraicNumberTheoryDecomposeTraceMap(value)` - Decompose a trace map into simpler or canonical components. +90. `algebraicNumberTheoryEvaluateTraceMap(value, point=None)` - Evaluate a trace map at a point, sample, or finite model. +91. `algebraicNumberTheoryComputeTraceMap(value)` - Compute the central numerical or symbolic data of a trace map. +92. `algebraicNumberTheoryEstimateTraceMap(value, samples=None)` - Estimate a trace map property from finite samples or approximations. +93. `algebraicNumberTheoryApproximateTraceMap(value, tolerance=1e-9)` - Approximate a trace map with explicit tolerance controls. +94. `algebraicNumberTheoryTransformTraceMap(value, mapping)` - Transform a trace map through a map, operator, or representation change. +95. `algebraicNumberTheorySimplifyTraceMap(value)` - Simplify a trace map without changing its mathematical meaning. +96. `algebraicNumberTheoryEnumerateTraceMap(value, limit=None)` - Enumerate finite members, cases, or derived objects for a trace map. +97. `algebraicNumberTheoryClassifyTraceMap(value)` - Classify a trace map by its standard Algebraic Number Theory invariants. +98. `algebraicNumberTheoryTestEquivalenceTraceMap(left, right)` - Test whether two trace map values are equivalent in Algebraic Number Theory. +99. `algebraicNumberTheoryGenerateExampleTraceMap(size=3)` - Generate a small documented example of a trace map. +100. `algebraicNumberTheoryDocumentTraceMap(value)` - Return a structured explanation of a trace map and related assumptions. + +### Diophantine Approximation + +Core object families: + +- continued fraction +- convergent +- rational approximation +- Pell equation +- Farey sequence + +Candidate functions: + +1. `diophantineApproximationValidateContinuedFraction(value)` - Validate the continued fraction representation and domain rules for Diophantine Approximation. +2. `diophantineApproximationConstructContinuedFraction(*args)` - Construct a continued fraction from explicit inputs for Diophantine Approximation. +3. `diophantineApproximationNormalizeContinuedFraction(value)` - Normalize a continued fraction into the standard Diophantine Approximation representation. +4. `diophantineApproximationCanonicalizeContinuedFraction(value)` - Canonicalize a continued fraction so equivalent inputs share one form. +5. `diophantineApproximationParseContinuedFraction(text)` - Parse a text or structured value into a continued fraction. +6. `diophantineApproximationFormatContinuedFraction(value)` - Format a continued fraction for deterministic user-facing output. +7. `diophantineApproximationCompareContinuedFraction(left, right)` - Compare two continued fraction values under the conventions of Diophantine Approximation. +8. `diophantineApproximationCombineContinuedFraction(left, right)` - Combine two continued fraction values with the natural operation for Diophantine Approximation. +9. `diophantineApproximationDecomposeContinuedFraction(value)` - Decompose a continued fraction into simpler or canonical components. +10. `diophantineApproximationEvaluateContinuedFraction(value, point=None)` - Evaluate a continued fraction at a point, sample, or finite model. +11. `diophantineApproximationComputeContinuedFraction(value)` - Compute the central numerical or symbolic data of a continued fraction. +12. `diophantineApproximationEstimateContinuedFraction(value, samples=None)` - Estimate a continued fraction property from finite samples or approximations. +13. `diophantineApproximationApproximateContinuedFraction(value, tolerance=1e-9)` - Approximate a continued fraction with explicit tolerance controls. +14. `diophantineApproximationTransformContinuedFraction(value, mapping)` - Transform a continued fraction through a map, operator, or representation change. +15. `diophantineApproximationSimplifyContinuedFraction(value)` - Simplify a continued fraction without changing its mathematical meaning. +16. `diophantineApproximationEnumerateContinuedFraction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a continued fraction. +17. `diophantineApproximationClassifyContinuedFraction(value)` - Classify a continued fraction by its standard Diophantine Approximation invariants. +18. `diophantineApproximationTestEquivalenceContinuedFraction(left, right)` - Test whether two continued fraction values are equivalent in Diophantine Approximation. +19. `diophantineApproximationGenerateExampleContinuedFraction(size=3)` - Generate a small documented example of a continued fraction. +20. `diophantineApproximationDocumentContinuedFraction(value)` - Return a structured explanation of a continued fraction and related assumptions. +21. `diophantineApproximationValidateConvergent(value)` - Validate the convergent representation and domain rules for Diophantine Approximation. +22. `diophantineApproximationConstructConvergent(*args)` - Construct a convergent from explicit inputs for Diophantine Approximation. +23. `diophantineApproximationNormalizeConvergent(value)` - Normalize a convergent into the standard Diophantine Approximation representation. +24. `diophantineApproximationCanonicalizeConvergent(value)` - Canonicalize a convergent so equivalent inputs share one form. +25. `diophantineApproximationParseConvergent(text)` - Parse a text or structured value into a convergent. +26. `diophantineApproximationFormatConvergent(value)` - Format a convergent for deterministic user-facing output. +27. `diophantineApproximationCompareConvergent(left, right)` - Compare two convergent values under the conventions of Diophantine Approximation. +28. `diophantineApproximationCombineConvergent(left, right)` - Combine two convergent values with the natural operation for Diophantine Approximation. +29. `diophantineApproximationDecomposeConvergent(value)` - Decompose a convergent into simpler or canonical components. +30. `diophantineApproximationEvaluateConvergent(value, point=None)` - Evaluate a convergent at a point, sample, or finite model. +31. `diophantineApproximationComputeConvergent(value)` - Compute the central numerical or symbolic data of a convergent. +32. `diophantineApproximationEstimateConvergent(value, samples=None)` - Estimate a convergent property from finite samples or approximations. +33. `diophantineApproximationApproximateConvergent(value, tolerance=1e-9)` - Approximate a convergent with explicit tolerance controls. +34. `diophantineApproximationTransformConvergent(value, mapping)` - Transform a convergent through a map, operator, or representation change. +35. `diophantineApproximationSimplifyConvergent(value)` - Simplify a convergent without changing its mathematical meaning. +36. `diophantineApproximationEnumerateConvergent(value, limit=None)` - Enumerate finite members, cases, or derived objects for a convergent. +37. `diophantineApproximationClassifyConvergent(value)` - Classify a convergent by its standard Diophantine Approximation invariants. +38. `diophantineApproximationTestEquivalenceConvergent(left, right)` - Test whether two convergent values are equivalent in Diophantine Approximation. +39. `diophantineApproximationGenerateExampleConvergent(size=3)` - Generate a small documented example of a convergent. +40. `diophantineApproximationDocumentConvergent(value)` - Return a structured explanation of a convergent and related assumptions. +41. `diophantineApproximationValidateRationalApproximation(value)` - Validate the rational approximation representation and domain rules for Diophantine Approximation. +42. `diophantineApproximationConstructRationalApproximation(*args)` - Construct a rational approximation from explicit inputs for Diophantine Approximation. +43. `diophantineApproximationNormalizeRationalApproximation(value)` - Normalize a rational approximation into the standard Diophantine Approximation representation. +44. `diophantineApproximationCanonicalizeRationalApproximation(value)` - Canonicalize a rational approximation so equivalent inputs share one form. +45. `diophantineApproximationParseRationalApproximation(text)` - Parse a text or structured value into a rational approximation. +46. `diophantineApproximationFormatRationalApproximation(value)` - Format a rational approximation for deterministic user-facing output. +47. `diophantineApproximationCompareRationalApproximation(left, right)` - Compare two rational approximation values under the conventions of Diophantine Approximation. +48. `diophantineApproximationCombineRationalApproximation(left, right)` - Combine two rational approximation values with the natural operation for Diophantine Approximation. +49. `diophantineApproximationDecomposeRationalApproximation(value)` - Decompose a rational approximation into simpler or canonical components. +50. `diophantineApproximationEvaluateRationalApproximation(value, point=None)` - Evaluate a rational approximation at a point, sample, or finite model. +51. `diophantineApproximationComputeRationalApproximation(value)` - Compute the central numerical or symbolic data of a rational approximation. +52. `diophantineApproximationEstimateRationalApproximation(value, samples=None)` - Estimate a rational approximation property from finite samples or approximations. +53. `diophantineApproximationApproximateRationalApproximation(value, tolerance=1e-9)` - Approximate a rational approximation with explicit tolerance controls. +54. `diophantineApproximationTransformRationalApproximation(value, mapping)` - Transform a rational approximation through a map, operator, or representation change. +55. `diophantineApproximationSimplifyRationalApproximation(value)` - Simplify a rational approximation without changing its mathematical meaning. +56. `diophantineApproximationEnumerateRationalApproximation(value, limit=None)` - Enumerate finite members, cases, or derived objects for a rational approximation. +57. `diophantineApproximationClassifyRationalApproximation(value)` - Classify a rational approximation by its standard Diophantine Approximation invariants. +58. `diophantineApproximationTestEquivalenceRationalApproximation(left, right)` - Test whether two rational approximation values are equivalent in Diophantine Approximation. +59. `diophantineApproximationGenerateExampleRationalApproximation(size=3)` - Generate a small documented example of a rational approximation. +60. `diophantineApproximationDocumentRationalApproximation(value)` - Return a structured explanation of a rational approximation and related assumptions. +61. `diophantineApproximationValidatePellEquation(value)` - Validate the Pell equation representation and domain rules for Diophantine Approximation. +62. `diophantineApproximationConstructPellEquation(*args)` - Construct a Pell equation from explicit inputs for Diophantine Approximation. +63. `diophantineApproximationNormalizePellEquation(value)` - Normalize a Pell equation into the standard Diophantine Approximation representation. +64. `diophantineApproximationCanonicalizePellEquation(value)` - Canonicalize a Pell equation so equivalent inputs share one form. +65. `diophantineApproximationParsePellEquation(text)` - Parse a text or structured value into a Pell equation. +66. `diophantineApproximationFormatPellEquation(value)` - Format a Pell equation for deterministic user-facing output. +67. `diophantineApproximationComparePellEquation(left, right)` - Compare two Pell equation values under the conventions of Diophantine Approximation. +68. `diophantineApproximationCombinePellEquation(left, right)` - Combine two Pell equation values with the natural operation for Diophantine Approximation. +69. `diophantineApproximationDecomposePellEquation(value)` - Decompose a Pell equation into simpler or canonical components. +70. `diophantineApproximationEvaluatePellEquation(value, point=None)` - Evaluate a Pell equation at a point, sample, or finite model. +71. `diophantineApproximationComputePellEquation(value)` - Compute the central numerical or symbolic data of a Pell equation. +72. `diophantineApproximationEstimatePellEquation(value, samples=None)` - Estimate a Pell equation property from finite samples or approximations. +73. `diophantineApproximationApproximatePellEquation(value, tolerance=1e-9)` - Approximate a Pell equation with explicit tolerance controls. +74. `diophantineApproximationTransformPellEquation(value, mapping)` - Transform a Pell equation through a map, operator, or representation change. +75. `diophantineApproximationSimplifyPellEquation(value)` - Simplify a Pell equation without changing its mathematical meaning. +76. `diophantineApproximationEnumeratePellEquation(value, limit=None)` - Enumerate finite members, cases, or derived objects for a Pell equation. +77. `diophantineApproximationClassifyPellEquation(value)` - Classify a Pell equation by its standard Diophantine Approximation invariants. +78. `diophantineApproximationTestEquivalencePellEquation(left, right)` - Test whether two Pell equation values are equivalent in Diophantine Approximation. +79. `diophantineApproximationGenerateExamplePellEquation(size=3)` - Generate a small documented example of a Pell equation. +80. `diophantineApproximationDocumentPellEquation(value)` - Return a structured explanation of a Pell equation and related assumptions. +81. `diophantineApproximationValidateFareySequence(value)` - Validate the Farey sequence representation and domain rules for Diophantine Approximation. +82. `diophantineApproximationConstructFareySequence(*args)` - Construct a Farey sequence from explicit inputs for Diophantine Approximation. +83. `diophantineApproximationNormalizeFareySequence(value)` - Normalize a Farey sequence into the standard Diophantine Approximation representation. +84. `diophantineApproximationCanonicalizeFareySequence(value)` - Canonicalize a Farey sequence so equivalent inputs share one form. +85. `diophantineApproximationParseFareySequence(text)` - Parse a text or structured value into a Farey sequence. +86. `diophantineApproximationFormatFareySequence(value)` - Format a Farey sequence for deterministic user-facing output. +87. `diophantineApproximationCompareFareySequence(left, right)` - Compare two Farey sequence values under the conventions of Diophantine Approximation. +88. `diophantineApproximationCombineFareySequence(left, right)` - Combine two Farey sequence values with the natural operation for Diophantine Approximation. +89. `diophantineApproximationDecomposeFareySequence(value)` - Decompose a Farey sequence into simpler or canonical components. +90. `diophantineApproximationEvaluateFareySequence(value, point=None)` - Evaluate a Farey sequence at a point, sample, or finite model. +91. `diophantineApproximationComputeFareySequence(value)` - Compute the central numerical or symbolic data of a Farey sequence. +92. `diophantineApproximationEstimateFareySequence(value, samples=None)` - Estimate a Farey sequence property from finite samples or approximations. +93. `diophantineApproximationApproximateFareySequence(value, tolerance=1e-9)` - Approximate a Farey sequence with explicit tolerance controls. +94. `diophantineApproximationTransformFareySequence(value, mapping)` - Transform a Farey sequence through a map, operator, or representation change. +95. `diophantineApproximationSimplifyFareySequence(value)` - Simplify a Farey sequence without changing its mathematical meaning. +96. `diophantineApproximationEnumerateFareySequence(value, limit=None)` - Enumerate finite members, cases, or derived objects for a Farey sequence. +97. `diophantineApproximationClassifyFareySequence(value)` - Classify a Farey sequence by its standard Diophantine Approximation invariants. +98. `diophantineApproximationTestEquivalenceFareySequence(left, right)` - Test whether two Farey sequence values are equivalent in Diophantine Approximation. +99. `diophantineApproximationGenerateExampleFareySequence(size=3)` - Generate a small documented example of a Farey sequence. +100. `diophantineApproximationDocumentFareySequence(value)` - Return a structured explanation of a Farey sequence and related assumptions. + +### Ergodic Theory + +Core object families: + +- measure preserving map +- orbit average +- invariant set +- return time +- mixing sample + +Candidate functions: + +1. `ergodicTheoryValidateMeasurePreservingMap(value)` - Validate the measure preserving map representation and domain rules for Ergodic Theory. +2. `ergodicTheoryConstructMeasurePreservingMap(*args)` - Construct a measure preserving map from explicit inputs for Ergodic Theory. +3. `ergodicTheoryNormalizeMeasurePreservingMap(value)` - Normalize a measure preserving map into the standard Ergodic Theory representation. +4. `ergodicTheoryCanonicalizeMeasurePreservingMap(value)` - Canonicalize a measure preserving map so equivalent inputs share one form. +5. `ergodicTheoryParseMeasurePreservingMap(text)` - Parse a text or structured value into a measure preserving map. +6. `ergodicTheoryFormatMeasurePreservingMap(value)` - Format a measure preserving map for deterministic user-facing output. +7. `ergodicTheoryCompareMeasurePreservingMap(left, right)` - Compare two measure preserving map values under the conventions of Ergodic Theory. +8. `ergodicTheoryCombineMeasurePreservingMap(left, right)` - Combine two measure preserving map values with the natural operation for Ergodic Theory. +9. `ergodicTheoryDecomposeMeasurePreservingMap(value)` - Decompose a measure preserving map into simpler or canonical components. +10. `ergodicTheoryEvaluateMeasurePreservingMap(value, point=None)` - Evaluate a measure preserving map at a point, sample, or finite model. +11. `ergodicTheoryComputeMeasurePreservingMap(value)` - Compute the central numerical or symbolic data of a measure preserving map. +12. `ergodicTheoryEstimateMeasurePreservingMap(value, samples=None)` - Estimate a measure preserving map property from finite samples or approximations. +13. `ergodicTheoryApproximateMeasurePreservingMap(value, tolerance=1e-9)` - Approximate a measure preserving map with explicit tolerance controls. +14. `ergodicTheoryTransformMeasurePreservingMap(value, mapping)` - Transform a measure preserving map through a map, operator, or representation change. +15. `ergodicTheorySimplifyMeasurePreservingMap(value)` - Simplify a measure preserving map without changing its mathematical meaning. +16. `ergodicTheoryEnumerateMeasurePreservingMap(value, limit=None)` - Enumerate finite members, cases, or derived objects for a measure preserving map. +17. `ergodicTheoryClassifyMeasurePreservingMap(value)` - Classify a measure preserving map by its standard Ergodic Theory invariants. +18. `ergodicTheoryTestEquivalenceMeasurePreservingMap(left, right)` - Test whether two measure preserving map values are equivalent in Ergodic Theory. +19. `ergodicTheoryGenerateExampleMeasurePreservingMap(size=3)` - Generate a small documented example of a measure preserving map. +20. `ergodicTheoryDocumentMeasurePreservingMap(value)` - Return a structured explanation of a measure preserving map and related assumptions. +21. `ergodicTheoryValidateOrbitAverage(value)` - Validate the orbit average representation and domain rules for Ergodic Theory. +22. `ergodicTheoryConstructOrbitAverage(*args)` - Construct a orbit average from explicit inputs for Ergodic Theory. +23. `ergodicTheoryNormalizeOrbitAverage(value)` - Normalize a orbit average into the standard Ergodic Theory representation. +24. `ergodicTheoryCanonicalizeOrbitAverage(value)` - Canonicalize a orbit average so equivalent inputs share one form. +25. `ergodicTheoryParseOrbitAverage(text)` - Parse a text or structured value into a orbit average. +26. `ergodicTheoryFormatOrbitAverage(value)` - Format a orbit average for deterministic user-facing output. +27. `ergodicTheoryCompareOrbitAverage(left, right)` - Compare two orbit average values under the conventions of Ergodic Theory. +28. `ergodicTheoryCombineOrbitAverage(left, right)` - Combine two orbit average values with the natural operation for Ergodic Theory. +29. `ergodicTheoryDecomposeOrbitAverage(value)` - Decompose a orbit average into simpler or canonical components. +30. `ergodicTheoryEvaluateOrbitAverage(value, point=None)` - Evaluate a orbit average at a point, sample, or finite model. +31. `ergodicTheoryComputeOrbitAverage(value)` - Compute the central numerical or symbolic data of a orbit average. +32. `ergodicTheoryEstimateOrbitAverage(value, samples=None)` - Estimate a orbit average property from finite samples or approximations. +33. `ergodicTheoryApproximateOrbitAverage(value, tolerance=1e-9)` - Approximate a orbit average with explicit tolerance controls. +34. `ergodicTheoryTransformOrbitAverage(value, mapping)` - Transform a orbit average through a map, operator, or representation change. +35. `ergodicTheorySimplifyOrbitAverage(value)` - Simplify a orbit average without changing its mathematical meaning. +36. `ergodicTheoryEnumerateOrbitAverage(value, limit=None)` - Enumerate finite members, cases, or derived objects for a orbit average. +37. `ergodicTheoryClassifyOrbitAverage(value)` - Classify a orbit average by its standard Ergodic Theory invariants. +38. `ergodicTheoryTestEquivalenceOrbitAverage(left, right)` - Test whether two orbit average values are equivalent in Ergodic Theory. +39. `ergodicTheoryGenerateExampleOrbitAverage(size=3)` - Generate a small documented example of a orbit average. +40. `ergodicTheoryDocumentOrbitAverage(value)` - Return a structured explanation of a orbit average and related assumptions. +41. `ergodicTheoryValidateInvariantSet(value)` - Validate the invariant set representation and domain rules for Ergodic Theory. +42. `ergodicTheoryConstructInvariantSet(*args)` - Construct a invariant set from explicit inputs for Ergodic Theory. +43. `ergodicTheoryNormalizeInvariantSet(value)` - Normalize a invariant set into the standard Ergodic Theory representation. +44. `ergodicTheoryCanonicalizeInvariantSet(value)` - Canonicalize a invariant set so equivalent inputs share one form. +45. `ergodicTheoryParseInvariantSet(text)` - Parse a text or structured value into a invariant set. +46. `ergodicTheoryFormatInvariantSet(value)` - Format a invariant set for deterministic user-facing output. +47. `ergodicTheoryCompareInvariantSet(left, right)` - Compare two invariant set values under the conventions of Ergodic Theory. +48. `ergodicTheoryCombineInvariantSet(left, right)` - Combine two invariant set values with the natural operation for Ergodic Theory. +49. `ergodicTheoryDecomposeInvariantSet(value)` - Decompose a invariant set into simpler or canonical components. +50. `ergodicTheoryEvaluateInvariantSet(value, point=None)` - Evaluate a invariant set at a point, sample, or finite model. +51. `ergodicTheoryComputeInvariantSet(value)` - Compute the central numerical or symbolic data of a invariant set. +52. `ergodicTheoryEstimateInvariantSet(value, samples=None)` - Estimate a invariant set property from finite samples or approximations. +53. `ergodicTheoryApproximateInvariantSet(value, tolerance=1e-9)` - Approximate a invariant set with explicit tolerance controls. +54. `ergodicTheoryTransformInvariantSet(value, mapping)` - Transform a invariant set through a map, operator, or representation change. +55. `ergodicTheorySimplifyInvariantSet(value)` - Simplify a invariant set without changing its mathematical meaning. +56. `ergodicTheoryEnumerateInvariantSet(value, limit=None)` - Enumerate finite members, cases, or derived objects for a invariant set. +57. `ergodicTheoryClassifyInvariantSet(value)` - Classify a invariant set by its standard Ergodic Theory invariants. +58. `ergodicTheoryTestEquivalenceInvariantSet(left, right)` - Test whether two invariant set values are equivalent in Ergodic Theory. +59. `ergodicTheoryGenerateExampleInvariantSet(size=3)` - Generate a small documented example of a invariant set. +60. `ergodicTheoryDocumentInvariantSet(value)` - Return a structured explanation of a invariant set and related assumptions. +61. `ergodicTheoryValidateReturnTime(value)` - Validate the return time representation and domain rules for Ergodic Theory. +62. `ergodicTheoryConstructReturnTime(*args)` - Construct a return time from explicit inputs for Ergodic Theory. +63. `ergodicTheoryNormalizeReturnTime(value)` - Normalize a return time into the standard Ergodic Theory representation. +64. `ergodicTheoryCanonicalizeReturnTime(value)` - Canonicalize a return time so equivalent inputs share one form. +65. `ergodicTheoryParseReturnTime(text)` - Parse a text or structured value into a return time. +66. `ergodicTheoryFormatReturnTime(value)` - Format a return time for deterministic user-facing output. +67. `ergodicTheoryCompareReturnTime(left, right)` - Compare two return time values under the conventions of Ergodic Theory. +68. `ergodicTheoryCombineReturnTime(left, right)` - Combine two return time values with the natural operation for Ergodic Theory. +69. `ergodicTheoryDecomposeReturnTime(value)` - Decompose a return time into simpler or canonical components. +70. `ergodicTheoryEvaluateReturnTime(value, point=None)` - Evaluate a return time at a point, sample, or finite model. +71. `ergodicTheoryComputeReturnTime(value)` - Compute the central numerical or symbolic data of a return time. +72. `ergodicTheoryEstimateReturnTime(value, samples=None)` - Estimate a return time property from finite samples or approximations. +73. `ergodicTheoryApproximateReturnTime(value, tolerance=1e-9)` - Approximate a return time with explicit tolerance controls. +74. `ergodicTheoryTransformReturnTime(value, mapping)` - Transform a return time through a map, operator, or representation change. +75. `ergodicTheorySimplifyReturnTime(value)` - Simplify a return time without changing its mathematical meaning. +76. `ergodicTheoryEnumerateReturnTime(value, limit=None)` - Enumerate finite members, cases, or derived objects for a return time. +77. `ergodicTheoryClassifyReturnTime(value)` - Classify a return time by its standard Ergodic Theory invariants. +78. `ergodicTheoryTestEquivalenceReturnTime(left, right)` - Test whether two return time values are equivalent in Ergodic Theory. +79. `ergodicTheoryGenerateExampleReturnTime(size=3)` - Generate a small documented example of a return time. +80. `ergodicTheoryDocumentReturnTime(value)` - Return a structured explanation of a return time and related assumptions. +81. `ergodicTheoryValidateMixingSample(value)` - Validate the mixing sample representation and domain rules for Ergodic Theory. +82. `ergodicTheoryConstructMixingSample(*args)` - Construct a mixing sample from explicit inputs for Ergodic Theory. +83. `ergodicTheoryNormalizeMixingSample(value)` - Normalize a mixing sample into the standard Ergodic Theory representation. +84. `ergodicTheoryCanonicalizeMixingSample(value)` - Canonicalize a mixing sample so equivalent inputs share one form. +85. `ergodicTheoryParseMixingSample(text)` - Parse a text or structured value into a mixing sample. +86. `ergodicTheoryFormatMixingSample(value)` - Format a mixing sample for deterministic user-facing output. +87. `ergodicTheoryCompareMixingSample(left, right)` - Compare two mixing sample values under the conventions of Ergodic Theory. +88. `ergodicTheoryCombineMixingSample(left, right)` - Combine two mixing sample values with the natural operation for Ergodic Theory. +89. `ergodicTheoryDecomposeMixingSample(value)` - Decompose a mixing sample into simpler or canonical components. +90. `ergodicTheoryEvaluateMixingSample(value, point=None)` - Evaluate a mixing sample at a point, sample, or finite model. +91. `ergodicTheoryComputeMixingSample(value)` - Compute the central numerical or symbolic data of a mixing sample. +92. `ergodicTheoryEstimateMixingSample(value, samples=None)` - Estimate a mixing sample property from finite samples or approximations. +93. `ergodicTheoryApproximateMixingSample(value, tolerance=1e-9)` - Approximate a mixing sample with explicit tolerance controls. +94. `ergodicTheoryTransformMixingSample(value, mapping)` - Transform a mixing sample through a map, operator, or representation change. +95. `ergodicTheorySimplifyMixingSample(value)` - Simplify a mixing sample without changing its mathematical meaning. +96. `ergodicTheoryEnumerateMixingSample(value, limit=None)` - Enumerate finite members, cases, or derived objects for a mixing sample. +97. `ergodicTheoryClassifyMixingSample(value)` - Classify a mixing sample by its standard Ergodic Theory invariants. +98. `ergodicTheoryTestEquivalenceMixingSample(left, right)` - Test whether two mixing sample values are equivalent in Ergodic Theory. +99. `ergodicTheoryGenerateExampleMixingSample(size=3)` - Generate a small documented example of a mixing sample. +100. `ergodicTheoryDocumentMixingSample(value)` - Return a structured explanation of a mixing sample and related assumptions. + +### Chaos Theory + +Core object families: + +- chaotic map +- bifurcation sample +- Lyapunov estimate +- attractor +- sensitive orbit + +Candidate functions: + +1. `chaosTheoryValidateChaoticMap(value)` - Validate the chaotic map representation and domain rules for Chaos Theory. +2. `chaosTheoryConstructChaoticMap(*args)` - Construct a chaotic map from explicit inputs for Chaos Theory. +3. `chaosTheoryNormalizeChaoticMap(value)` - Normalize a chaotic map into the standard Chaos Theory representation. +4. `chaosTheoryCanonicalizeChaoticMap(value)` - Canonicalize a chaotic map so equivalent inputs share one form. +5. `chaosTheoryParseChaoticMap(text)` - Parse a text or structured value into a chaotic map. +6. `chaosTheoryFormatChaoticMap(value)` - Format a chaotic map for deterministic user-facing output. +7. `chaosTheoryCompareChaoticMap(left, right)` - Compare two chaotic map values under the conventions of Chaos Theory. +8. `chaosTheoryCombineChaoticMap(left, right)` - Combine two chaotic map values with the natural operation for Chaos Theory. +9. `chaosTheoryDecomposeChaoticMap(value)` - Decompose a chaotic map into simpler or canonical components. +10. `chaosTheoryEvaluateChaoticMap(value, point=None)` - Evaluate a chaotic map at a point, sample, or finite model. +11. `chaosTheoryComputeChaoticMap(value)` - Compute the central numerical or symbolic data of a chaotic map. +12. `chaosTheoryEstimateChaoticMap(value, samples=None)` - Estimate a chaotic map property from finite samples or approximations. +13. `chaosTheoryApproximateChaoticMap(value, tolerance=1e-9)` - Approximate a chaotic map with explicit tolerance controls. +14. `chaosTheoryTransformChaoticMap(value, mapping)` - Transform a chaotic map through a map, operator, or representation change. +15. `chaosTheorySimplifyChaoticMap(value)` - Simplify a chaotic map without changing its mathematical meaning. +16. `chaosTheoryEnumerateChaoticMap(value, limit=None)` - Enumerate finite members, cases, or derived objects for a chaotic map. +17. `chaosTheoryClassifyChaoticMap(value)` - Classify a chaotic map by its standard Chaos Theory invariants. +18. `chaosTheoryTestEquivalenceChaoticMap(left, right)` - Test whether two chaotic map values are equivalent in Chaos Theory. +19. `chaosTheoryGenerateExampleChaoticMap(size=3)` - Generate a small documented example of a chaotic map. +20. `chaosTheoryDocumentChaoticMap(value)` - Return a structured explanation of a chaotic map and related assumptions. +21. `chaosTheoryValidateBifurcationSample(value)` - Validate the bifurcation sample representation and domain rules for Chaos Theory. +22. `chaosTheoryConstructBifurcationSample(*args)` - Construct a bifurcation sample from explicit inputs for Chaos Theory. +23. `chaosTheoryNormalizeBifurcationSample(value)` - Normalize a bifurcation sample into the standard Chaos Theory representation. +24. `chaosTheoryCanonicalizeBifurcationSample(value)` - Canonicalize a bifurcation sample so equivalent inputs share one form. +25. `chaosTheoryParseBifurcationSample(text)` - Parse a text or structured value into a bifurcation sample. +26. `chaosTheoryFormatBifurcationSample(value)` - Format a bifurcation sample for deterministic user-facing output. +27. `chaosTheoryCompareBifurcationSample(left, right)` - Compare two bifurcation sample values under the conventions of Chaos Theory. +28. `chaosTheoryCombineBifurcationSample(left, right)` - Combine two bifurcation sample values with the natural operation for Chaos Theory. +29. `chaosTheoryDecomposeBifurcationSample(value)` - Decompose a bifurcation sample into simpler or canonical components. +30. `chaosTheoryEvaluateBifurcationSample(value, point=None)` - Evaluate a bifurcation sample at a point, sample, or finite model. +31. `chaosTheoryComputeBifurcationSample(value)` - Compute the central numerical or symbolic data of a bifurcation sample. +32. `chaosTheoryEstimateBifurcationSample(value, samples=None)` - Estimate a bifurcation sample property from finite samples or approximations. +33. `chaosTheoryApproximateBifurcationSample(value, tolerance=1e-9)` - Approximate a bifurcation sample with explicit tolerance controls. +34. `chaosTheoryTransformBifurcationSample(value, mapping)` - Transform a bifurcation sample through a map, operator, or representation change. +35. `chaosTheorySimplifyBifurcationSample(value)` - Simplify a bifurcation sample without changing its mathematical meaning. +36. `chaosTheoryEnumerateBifurcationSample(value, limit=None)` - Enumerate finite members, cases, or derived objects for a bifurcation sample. +37. `chaosTheoryClassifyBifurcationSample(value)` - Classify a bifurcation sample by its standard Chaos Theory invariants. +38. `chaosTheoryTestEquivalenceBifurcationSample(left, right)` - Test whether two bifurcation sample values are equivalent in Chaos Theory. +39. `chaosTheoryGenerateExampleBifurcationSample(size=3)` - Generate a small documented example of a bifurcation sample. +40. `chaosTheoryDocumentBifurcationSample(value)` - Return a structured explanation of a bifurcation sample and related assumptions. +41. `chaosTheoryValidateLyapunovEstimate(value)` - Validate the Lyapunov estimate representation and domain rules for Chaos Theory. +42. `chaosTheoryConstructLyapunovEstimate(*args)` - Construct a Lyapunov estimate from explicit inputs for Chaos Theory. +43. `chaosTheoryNormalizeLyapunovEstimate(value)` - Normalize a Lyapunov estimate into the standard Chaos Theory representation. +44. `chaosTheoryCanonicalizeLyapunovEstimate(value)` - Canonicalize a Lyapunov estimate so equivalent inputs share one form. +45. `chaosTheoryParseLyapunovEstimate(text)` - Parse a text or structured value into a Lyapunov estimate. +46. `chaosTheoryFormatLyapunovEstimate(value)` - Format a Lyapunov estimate for deterministic user-facing output. +47. `chaosTheoryCompareLyapunovEstimate(left, right)` - Compare two Lyapunov estimate values under the conventions of Chaos Theory. +48. `chaosTheoryCombineLyapunovEstimate(left, right)` - Combine two Lyapunov estimate values with the natural operation for Chaos Theory. +49. `chaosTheoryDecomposeLyapunovEstimate(value)` - Decompose a Lyapunov estimate into simpler or canonical components. +50. `chaosTheoryEvaluateLyapunovEstimate(value, point=None)` - Evaluate a Lyapunov estimate at a point, sample, or finite model. +51. `chaosTheoryComputeLyapunovEstimate(value)` - Compute the central numerical or symbolic data of a Lyapunov estimate. +52. `chaosTheoryEstimateLyapunovEstimate(value, samples=None)` - Estimate a Lyapunov estimate property from finite samples or approximations. +53. `chaosTheoryApproximateLyapunovEstimate(value, tolerance=1e-9)` - Approximate a Lyapunov estimate with explicit tolerance controls. +54. `chaosTheoryTransformLyapunovEstimate(value, mapping)` - Transform a Lyapunov estimate through a map, operator, or representation change. +55. `chaosTheorySimplifyLyapunovEstimate(value)` - Simplify a Lyapunov estimate without changing its mathematical meaning. +56. `chaosTheoryEnumerateLyapunovEstimate(value, limit=None)` - Enumerate finite members, cases, or derived objects for a Lyapunov estimate. +57. `chaosTheoryClassifyLyapunovEstimate(value)` - Classify a Lyapunov estimate by its standard Chaos Theory invariants. +58. `chaosTheoryTestEquivalenceLyapunovEstimate(left, right)` - Test whether two Lyapunov estimate values are equivalent in Chaos Theory. +59. `chaosTheoryGenerateExampleLyapunovEstimate(size=3)` - Generate a small documented example of a Lyapunov estimate. +60. `chaosTheoryDocumentLyapunovEstimate(value)` - Return a structured explanation of a Lyapunov estimate and related assumptions. +61. `chaosTheoryValidateAttractor(value)` - Validate the attractor representation and domain rules for Chaos Theory. +62. `chaosTheoryConstructAttractor(*args)` - Construct a attractor from explicit inputs for Chaos Theory. +63. `chaosTheoryNormalizeAttractor(value)` - Normalize a attractor into the standard Chaos Theory representation. +64. `chaosTheoryCanonicalizeAttractor(value)` - Canonicalize a attractor so equivalent inputs share one form. +65. `chaosTheoryParseAttractor(text)` - Parse a text or structured value into a attractor. +66. `chaosTheoryFormatAttractor(value)` - Format a attractor for deterministic user-facing output. +67. `chaosTheoryCompareAttractor(left, right)` - Compare two attractor values under the conventions of Chaos Theory. +68. `chaosTheoryCombineAttractor(left, right)` - Combine two attractor values with the natural operation for Chaos Theory. +69. `chaosTheoryDecomposeAttractor(value)` - Decompose a attractor into simpler or canonical components. +70. `chaosTheoryEvaluateAttractor(value, point=None)` - Evaluate a attractor at a point, sample, or finite model. +71. `chaosTheoryComputeAttractor(value)` - Compute the central numerical or symbolic data of a attractor. +72. `chaosTheoryEstimateAttractor(value, samples=None)` - Estimate a attractor property from finite samples or approximations. +73. `chaosTheoryApproximateAttractor(value, tolerance=1e-9)` - Approximate a attractor with explicit tolerance controls. +74. `chaosTheoryTransformAttractor(value, mapping)` - Transform a attractor through a map, operator, or representation change. +75. `chaosTheorySimplifyAttractor(value)` - Simplify a attractor without changing its mathematical meaning. +76. `chaosTheoryEnumerateAttractor(value, limit=None)` - Enumerate finite members, cases, or derived objects for a attractor. +77. `chaosTheoryClassifyAttractor(value)` - Classify a attractor by its standard Chaos Theory invariants. +78. `chaosTheoryTestEquivalenceAttractor(left, right)` - Test whether two attractor values are equivalent in Chaos Theory. +79. `chaosTheoryGenerateExampleAttractor(size=3)` - Generate a small documented example of a attractor. +80. `chaosTheoryDocumentAttractor(value)` - Return a structured explanation of a attractor and related assumptions. +81. `chaosTheoryValidateSensitiveOrbit(value)` - Validate the sensitive orbit representation and domain rules for Chaos Theory. +82. `chaosTheoryConstructSensitiveOrbit(*args)` - Construct a sensitive orbit from explicit inputs for Chaos Theory. +83. `chaosTheoryNormalizeSensitiveOrbit(value)` - Normalize a sensitive orbit into the standard Chaos Theory representation. +84. `chaosTheoryCanonicalizeSensitiveOrbit(value)` - Canonicalize a sensitive orbit so equivalent inputs share one form. +85. `chaosTheoryParseSensitiveOrbit(text)` - Parse a text or structured value into a sensitive orbit. +86. `chaosTheoryFormatSensitiveOrbit(value)` - Format a sensitive orbit for deterministic user-facing output. +87. `chaosTheoryCompareSensitiveOrbit(left, right)` - Compare two sensitive orbit values under the conventions of Chaos Theory. +88. `chaosTheoryCombineSensitiveOrbit(left, right)` - Combine two sensitive orbit values with the natural operation for Chaos Theory. +89. `chaosTheoryDecomposeSensitiveOrbit(value)` - Decompose a sensitive orbit into simpler or canonical components. +90. `chaosTheoryEvaluateSensitiveOrbit(value, point=None)` - Evaluate a sensitive orbit at a point, sample, or finite model. +91. `chaosTheoryComputeSensitiveOrbit(value)` - Compute the central numerical or symbolic data of a sensitive orbit. +92. `chaosTheoryEstimateSensitiveOrbit(value, samples=None)` - Estimate a sensitive orbit property from finite samples or approximations. +93. `chaosTheoryApproximateSensitiveOrbit(value, tolerance=1e-9)` - Approximate a sensitive orbit with explicit tolerance controls. +94. `chaosTheoryTransformSensitiveOrbit(value, mapping)` - Transform a sensitive orbit through a map, operator, or representation change. +95. `chaosTheorySimplifySensitiveOrbit(value)` - Simplify a sensitive orbit without changing its mathematical meaning. +96. `chaosTheoryEnumerateSensitiveOrbit(value, limit=None)` - Enumerate finite members, cases, or derived objects for a sensitive orbit. +97. `chaosTheoryClassifySensitiveOrbit(value)` - Classify a sensitive orbit by its standard Chaos Theory invariants. +98. `chaosTheoryTestEquivalenceSensitiveOrbit(left, right)` - Test whether two sensitive orbit values are equivalent in Chaos Theory. +99. `chaosTheoryGenerateExampleSensitiveOrbit(size=3)` - Generate a small documented example of a sensitive orbit. +100. `chaosTheoryDocumentSensitiveOrbit(value)` - Return a structured explanation of a sensitive orbit and related assumptions. + +### Control Theory + +Core object families: + +- state space model +- control input +- observability matrix +- controllability matrix +- feedback law + +Candidate functions: + +1. `controlTheoryValidateStateSpaceModel(value)` - Validate the state space model representation and domain rules for Control Theory. +2. `controlTheoryConstructStateSpaceModel(*args)` - Construct a state space model from explicit inputs for Control Theory. +3. `controlTheoryNormalizeStateSpaceModel(value)` - Normalize a state space model into the standard Control Theory representation. +4. `controlTheoryCanonicalizeStateSpaceModel(value)` - Canonicalize a state space model so equivalent inputs share one form. +5. `controlTheoryParseStateSpaceModel(text)` - Parse a text or structured value into a state space model. +6. `controlTheoryFormatStateSpaceModel(value)` - Format a state space model for deterministic user-facing output. +7. `controlTheoryCompareStateSpaceModel(left, right)` - Compare two state space model values under the conventions of Control Theory. +8. `controlTheoryCombineStateSpaceModel(left, right)` - Combine two state space model values with the natural operation for Control Theory. +9. `controlTheoryDecomposeStateSpaceModel(value)` - Decompose a state space model into simpler or canonical components. +10. `controlTheoryEvaluateStateSpaceModel(value, point=None)` - Evaluate a state space model at a point, sample, or finite model. +11. `controlTheoryComputeStateSpaceModel(value)` - Compute the central numerical or symbolic data of a state space model. +12. `controlTheoryEstimateStateSpaceModel(value, samples=None)` - Estimate a state space model property from finite samples or approximations. +13. `controlTheoryApproximateStateSpaceModel(value, tolerance=1e-9)` - Approximate a state space model with explicit tolerance controls. +14. `controlTheoryTransformStateSpaceModel(value, mapping)` - Transform a state space model through a map, operator, or representation change. +15. `controlTheorySimplifyStateSpaceModel(value)` - Simplify a state space model without changing its mathematical meaning. +16. `controlTheoryEnumerateStateSpaceModel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a state space model. +17. `controlTheoryClassifyStateSpaceModel(value)` - Classify a state space model by its standard Control Theory invariants. +18. `controlTheoryTestEquivalenceStateSpaceModel(left, right)` - Test whether two state space model values are equivalent in Control Theory. +19. `controlTheoryGenerateExampleStateSpaceModel(size=3)` - Generate a small documented example of a state space model. +20. `controlTheoryDocumentStateSpaceModel(value)` - Return a structured explanation of a state space model and related assumptions. +21. `controlTheoryValidateControlInput(value)` - Validate the control input representation and domain rules for Control Theory. +22. `controlTheoryConstructControlInput(*args)` - Construct a control input from explicit inputs for Control Theory. +23. `controlTheoryNormalizeControlInput(value)` - Normalize a control input into the standard Control Theory representation. +24. `controlTheoryCanonicalizeControlInput(value)` - Canonicalize a control input so equivalent inputs share one form. +25. `controlTheoryParseControlInput(text)` - Parse a text or structured value into a control input. +26. `controlTheoryFormatControlInput(value)` - Format a control input for deterministic user-facing output. +27. `controlTheoryCompareControlInput(left, right)` - Compare two control input values under the conventions of Control Theory. +28. `controlTheoryCombineControlInput(left, right)` - Combine two control input values with the natural operation for Control Theory. +29. `controlTheoryDecomposeControlInput(value)` - Decompose a control input into simpler or canonical components. +30. `controlTheoryEvaluateControlInput(value, point=None)` - Evaluate a control input at a point, sample, or finite model. +31. `controlTheoryComputeControlInput(value)` - Compute the central numerical or symbolic data of a control input. +32. `controlTheoryEstimateControlInput(value, samples=None)` - Estimate a control input property from finite samples or approximations. +33. `controlTheoryApproximateControlInput(value, tolerance=1e-9)` - Approximate a control input with explicit tolerance controls. +34. `controlTheoryTransformControlInput(value, mapping)` - Transform a control input through a map, operator, or representation change. +35. `controlTheorySimplifyControlInput(value)` - Simplify a control input without changing its mathematical meaning. +36. `controlTheoryEnumerateControlInput(value, limit=None)` - Enumerate finite members, cases, or derived objects for a control input. +37. `controlTheoryClassifyControlInput(value)` - Classify a control input by its standard Control Theory invariants. +38. `controlTheoryTestEquivalenceControlInput(left, right)` - Test whether two control input values are equivalent in Control Theory. +39. `controlTheoryGenerateExampleControlInput(size=3)` - Generate a small documented example of a control input. +40. `controlTheoryDocumentControlInput(value)` - Return a structured explanation of a control input and related assumptions. +41. `controlTheoryValidateObservabilityMatrix(value)` - Validate the observability matrix representation and domain rules for Control Theory. +42. `controlTheoryConstructObservabilityMatrix(*args)` - Construct a observability matrix from explicit inputs for Control Theory. +43. `controlTheoryNormalizeObservabilityMatrix(value)` - Normalize a observability matrix into the standard Control Theory representation. +44. `controlTheoryCanonicalizeObservabilityMatrix(value)` - Canonicalize a observability matrix so equivalent inputs share one form. +45. `controlTheoryParseObservabilityMatrix(text)` - Parse a text or structured value into a observability matrix. +46. `controlTheoryFormatObservabilityMatrix(value)` - Format a observability matrix for deterministic user-facing output. +47. `controlTheoryCompareObservabilityMatrix(left, right)` - Compare two observability matrix values under the conventions of Control Theory. +48. `controlTheoryCombineObservabilityMatrix(left, right)` - Combine two observability matrix values with the natural operation for Control Theory. +49. `controlTheoryDecomposeObservabilityMatrix(value)` - Decompose a observability matrix into simpler or canonical components. +50. `controlTheoryEvaluateObservabilityMatrix(value, point=None)` - Evaluate a observability matrix at a point, sample, or finite model. +51. `controlTheoryComputeObservabilityMatrix(value)` - Compute the central numerical or symbolic data of a observability matrix. +52. `controlTheoryEstimateObservabilityMatrix(value, samples=None)` - Estimate a observability matrix property from finite samples or approximations. +53. `controlTheoryApproximateObservabilityMatrix(value, tolerance=1e-9)` - Approximate a observability matrix with explicit tolerance controls. +54. `controlTheoryTransformObservabilityMatrix(value, mapping)` - Transform a observability matrix through a map, operator, or representation change. +55. `controlTheorySimplifyObservabilityMatrix(value)` - Simplify a observability matrix without changing its mathematical meaning. +56. `controlTheoryEnumerateObservabilityMatrix(value, limit=None)` - Enumerate finite members, cases, or derived objects for a observability matrix. +57. `controlTheoryClassifyObservabilityMatrix(value)` - Classify a observability matrix by its standard Control Theory invariants. +58. `controlTheoryTestEquivalenceObservabilityMatrix(left, right)` - Test whether two observability matrix values are equivalent in Control Theory. +59. `controlTheoryGenerateExampleObservabilityMatrix(size=3)` - Generate a small documented example of a observability matrix. +60. `controlTheoryDocumentObservabilityMatrix(value)` - Return a structured explanation of a observability matrix and related assumptions. +61. `controlTheoryValidateControllabilityMatrix(value)` - Validate the controllability matrix representation and domain rules for Control Theory. +62. `controlTheoryConstructControllabilityMatrix(*args)` - Construct a controllability matrix from explicit inputs for Control Theory. +63. `controlTheoryNormalizeControllabilityMatrix(value)` - Normalize a controllability matrix into the standard Control Theory representation. +64. `controlTheoryCanonicalizeControllabilityMatrix(value)` - Canonicalize a controllability matrix so equivalent inputs share one form. +65. `controlTheoryParseControllabilityMatrix(text)` - Parse a text or structured value into a controllability matrix. +66. `controlTheoryFormatControllabilityMatrix(value)` - Format a controllability matrix for deterministic user-facing output. +67. `controlTheoryCompareControllabilityMatrix(left, right)` - Compare two controllability matrix values under the conventions of Control Theory. +68. `controlTheoryCombineControllabilityMatrix(left, right)` - Combine two controllability matrix values with the natural operation for Control Theory. +69. `controlTheoryDecomposeControllabilityMatrix(value)` - Decompose a controllability matrix into simpler or canonical components. +70. `controlTheoryEvaluateControllabilityMatrix(value, point=None)` - Evaluate a controllability matrix at a point, sample, or finite model. +71. `controlTheoryComputeControllabilityMatrix(value)` - Compute the central numerical or symbolic data of a controllability matrix. +72. `controlTheoryEstimateControllabilityMatrix(value, samples=None)` - Estimate a controllability matrix property from finite samples or approximations. +73. `controlTheoryApproximateControllabilityMatrix(value, tolerance=1e-9)` - Approximate a controllability matrix with explicit tolerance controls. +74. `controlTheoryTransformControllabilityMatrix(value, mapping)` - Transform a controllability matrix through a map, operator, or representation change. +75. `controlTheorySimplifyControllabilityMatrix(value)` - Simplify a controllability matrix without changing its mathematical meaning. +76. `controlTheoryEnumerateControllabilityMatrix(value, limit=None)` - Enumerate finite members, cases, or derived objects for a controllability matrix. +77. `controlTheoryClassifyControllabilityMatrix(value)` - Classify a controllability matrix by its standard Control Theory invariants. +78. `controlTheoryTestEquivalenceControllabilityMatrix(left, right)` - Test whether two controllability matrix values are equivalent in Control Theory. +79. `controlTheoryGenerateExampleControllabilityMatrix(size=3)` - Generate a small documented example of a controllability matrix. +80. `controlTheoryDocumentControllabilityMatrix(value)` - Return a structured explanation of a controllability matrix and related assumptions. +81. `controlTheoryValidateFeedbackLaw(value)` - Validate the feedback law representation and domain rules for Control Theory. +82. `controlTheoryConstructFeedbackLaw(*args)` - Construct a feedback law from explicit inputs for Control Theory. +83. `controlTheoryNormalizeFeedbackLaw(value)` - Normalize a feedback law into the standard Control Theory representation. +84. `controlTheoryCanonicalizeFeedbackLaw(value)` - Canonicalize a feedback law so equivalent inputs share one form. +85. `controlTheoryParseFeedbackLaw(text)` - Parse a text or structured value into a feedback law. +86. `controlTheoryFormatFeedbackLaw(value)` - Format a feedback law for deterministic user-facing output. +87. `controlTheoryCompareFeedbackLaw(left, right)` - Compare two feedback law values under the conventions of Control Theory. +88. `controlTheoryCombineFeedbackLaw(left, right)` - Combine two feedback law values with the natural operation for Control Theory. +89. `controlTheoryDecomposeFeedbackLaw(value)` - Decompose a feedback law into simpler or canonical components. +90. `controlTheoryEvaluateFeedbackLaw(value, point=None)` - Evaluate a feedback law at a point, sample, or finite model. +91. `controlTheoryComputeFeedbackLaw(value)` - Compute the central numerical or symbolic data of a feedback law. +92. `controlTheoryEstimateFeedbackLaw(value, samples=None)` - Estimate a feedback law property from finite samples or approximations. +93. `controlTheoryApproximateFeedbackLaw(value, tolerance=1e-9)` - Approximate a feedback law with explicit tolerance controls. +94. `controlTheoryTransformFeedbackLaw(value, mapping)` - Transform a feedback law through a map, operator, or representation change. +95. `controlTheorySimplifyFeedbackLaw(value)` - Simplify a feedback law without changing its mathematical meaning. +96. `controlTheoryEnumerateFeedbackLaw(value, limit=None)` - Enumerate finite members, cases, or derived objects for a feedback law. +97. `controlTheoryClassifyFeedbackLaw(value)` - Classify a feedback law by its standard Control Theory invariants. +98. `controlTheoryTestEquivalenceFeedbackLaw(left, right)` - Test whether two feedback law values are equivalent in Control Theory. +99. `controlTheoryGenerateExampleFeedbackLaw(size=3)` - Generate a small documented example of a feedback law. +100. `controlTheoryDocumentFeedbackLaw(value)` - Return a structured explanation of a feedback law and related assumptions. + +### Convex Analysis + +Core object families: + +- convex set +- convex function +- subgradient +- support function +- projection + +Candidate functions: + +1. `convexAnalysisValidateConvexSet(value)` - Validate the convex set representation and domain rules for Convex Analysis. +2. `convexAnalysisConstructConvexSet(*args)` - Construct a convex set from explicit inputs for Convex Analysis. +3. `convexAnalysisNormalizeConvexSet(value)` - Normalize a convex set into the standard Convex Analysis representation. +4. `convexAnalysisCanonicalizeConvexSet(value)` - Canonicalize a convex set so equivalent inputs share one form. +5. `convexAnalysisParseConvexSet(text)` - Parse a text or structured value into a convex set. +6. `convexAnalysisFormatConvexSet(value)` - Format a convex set for deterministic user-facing output. +7. `convexAnalysisCompareConvexSet(left, right)` - Compare two convex set values under the conventions of Convex Analysis. +8. `convexAnalysisCombineConvexSet(left, right)` - Combine two convex set values with the natural operation for Convex Analysis. +9. `convexAnalysisDecomposeConvexSet(value)` - Decompose a convex set into simpler or canonical components. +10. `convexAnalysisEvaluateConvexSet(value, point=None)` - Evaluate a convex set at a point, sample, or finite model. +11. `convexAnalysisComputeConvexSet(value)` - Compute the central numerical or symbolic data of a convex set. +12. `convexAnalysisEstimateConvexSet(value, samples=None)` - Estimate a convex set property from finite samples or approximations. +13. `convexAnalysisApproximateConvexSet(value, tolerance=1e-9)` - Approximate a convex set with explicit tolerance controls. +14. `convexAnalysisTransformConvexSet(value, mapping)` - Transform a convex set through a map, operator, or representation change. +15. `convexAnalysisSimplifyConvexSet(value)` - Simplify a convex set without changing its mathematical meaning. +16. `convexAnalysisEnumerateConvexSet(value, limit=None)` - Enumerate finite members, cases, or derived objects for a convex set. +17. `convexAnalysisClassifyConvexSet(value)` - Classify a convex set by its standard Convex Analysis invariants. +18. `convexAnalysisTestEquivalenceConvexSet(left, right)` - Test whether two convex set values are equivalent in Convex Analysis. +19. `convexAnalysisGenerateExampleConvexSet(size=3)` - Generate a small documented example of a convex set. +20. `convexAnalysisDocumentConvexSet(value)` - Return a structured explanation of a convex set and related assumptions. +21. `convexAnalysisValidateConvexFunction(value)` - Validate the convex function representation and domain rules for Convex Analysis. +22. `convexAnalysisConstructConvexFunction(*args)` - Construct a convex function from explicit inputs for Convex Analysis. +23. `convexAnalysisNormalizeConvexFunction(value)` - Normalize a convex function into the standard Convex Analysis representation. +24. `convexAnalysisCanonicalizeConvexFunction(value)` - Canonicalize a convex function so equivalent inputs share one form. +25. `convexAnalysisParseConvexFunction(text)` - Parse a text or structured value into a convex function. +26. `convexAnalysisFormatConvexFunction(value)` - Format a convex function for deterministic user-facing output. +27. `convexAnalysisCompareConvexFunction(left, right)` - Compare two convex function values under the conventions of Convex Analysis. +28. `convexAnalysisCombineConvexFunction(left, right)` - Combine two convex function values with the natural operation for Convex Analysis. +29. `convexAnalysisDecomposeConvexFunction(value)` - Decompose a convex function into simpler or canonical components. +30. `convexAnalysisEvaluateConvexFunction(value, point=None)` - Evaluate a convex function at a point, sample, or finite model. +31. `convexAnalysisComputeConvexFunction(value)` - Compute the central numerical or symbolic data of a convex function. +32. `convexAnalysisEstimateConvexFunction(value, samples=None)` - Estimate a convex function property from finite samples or approximations. +33. `convexAnalysisApproximateConvexFunction(value, tolerance=1e-9)` - Approximate a convex function with explicit tolerance controls. +34. `convexAnalysisTransformConvexFunction(value, mapping)` - Transform a convex function through a map, operator, or representation change. +35. `convexAnalysisSimplifyConvexFunction(value)` - Simplify a convex function without changing its mathematical meaning. +36. `convexAnalysisEnumerateConvexFunction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a convex function. +37. `convexAnalysisClassifyConvexFunction(value)` - Classify a convex function by its standard Convex Analysis invariants. +38. `convexAnalysisTestEquivalenceConvexFunction(left, right)` - Test whether two convex function values are equivalent in Convex Analysis. +39. `convexAnalysisGenerateExampleConvexFunction(size=3)` - Generate a small documented example of a convex function. +40. `convexAnalysisDocumentConvexFunction(value)` - Return a structured explanation of a convex function and related assumptions. +41. `convexAnalysisValidateSubgradient(value)` - Validate the subgradient representation and domain rules for Convex Analysis. +42. `convexAnalysisConstructSubgradient(*args)` - Construct a subgradient from explicit inputs for Convex Analysis. +43. `convexAnalysisNormalizeSubgradient(value)` - Normalize a subgradient into the standard Convex Analysis representation. +44. `convexAnalysisCanonicalizeSubgradient(value)` - Canonicalize a subgradient so equivalent inputs share one form. +45. `convexAnalysisParseSubgradient(text)` - Parse a text or structured value into a subgradient. +46. `convexAnalysisFormatSubgradient(value)` - Format a subgradient for deterministic user-facing output. +47. `convexAnalysisCompareSubgradient(left, right)` - Compare two subgradient values under the conventions of Convex Analysis. +48. `convexAnalysisCombineSubgradient(left, right)` - Combine two subgradient values with the natural operation for Convex Analysis. +49. `convexAnalysisDecomposeSubgradient(value)` - Decompose a subgradient into simpler or canonical components. +50. `convexAnalysisEvaluateSubgradient(value, point=None)` - Evaluate a subgradient at a point, sample, or finite model. +51. `convexAnalysisComputeSubgradient(value)` - Compute the central numerical or symbolic data of a subgradient. +52. `convexAnalysisEstimateSubgradient(value, samples=None)` - Estimate a subgradient property from finite samples or approximations. +53. `convexAnalysisApproximateSubgradient(value, tolerance=1e-9)` - Approximate a subgradient with explicit tolerance controls. +54. `convexAnalysisTransformSubgradient(value, mapping)` - Transform a subgradient through a map, operator, or representation change. +55. `convexAnalysisSimplifySubgradient(value)` - Simplify a subgradient without changing its mathematical meaning. +56. `convexAnalysisEnumerateSubgradient(value, limit=None)` - Enumerate finite members, cases, or derived objects for a subgradient. +57. `convexAnalysisClassifySubgradient(value)` - Classify a subgradient by its standard Convex Analysis invariants. +58. `convexAnalysisTestEquivalenceSubgradient(left, right)` - Test whether two subgradient values are equivalent in Convex Analysis. +59. `convexAnalysisGenerateExampleSubgradient(size=3)` - Generate a small documented example of a subgradient. +60. `convexAnalysisDocumentSubgradient(value)` - Return a structured explanation of a subgradient and related assumptions. +61. `convexAnalysisValidateSupportFunction(value)` - Validate the support function representation and domain rules for Convex Analysis. +62. `convexAnalysisConstructSupportFunction(*args)` - Construct a support function from explicit inputs for Convex Analysis. +63. `convexAnalysisNormalizeSupportFunction(value)` - Normalize a support function into the standard Convex Analysis representation. +64. `convexAnalysisCanonicalizeSupportFunction(value)` - Canonicalize a support function so equivalent inputs share one form. +65. `convexAnalysisParseSupportFunction(text)` - Parse a text or structured value into a support function. +66. `convexAnalysisFormatSupportFunction(value)` - Format a support function for deterministic user-facing output. +67. `convexAnalysisCompareSupportFunction(left, right)` - Compare two support function values under the conventions of Convex Analysis. +68. `convexAnalysisCombineSupportFunction(left, right)` - Combine two support function values with the natural operation for Convex Analysis. +69. `convexAnalysisDecomposeSupportFunction(value)` - Decompose a support function into simpler or canonical components. +70. `convexAnalysisEvaluateSupportFunction(value, point=None)` - Evaluate a support function at a point, sample, or finite model. +71. `convexAnalysisComputeSupportFunction(value)` - Compute the central numerical or symbolic data of a support function. +72. `convexAnalysisEstimateSupportFunction(value, samples=None)` - Estimate a support function property from finite samples or approximations. +73. `convexAnalysisApproximateSupportFunction(value, tolerance=1e-9)` - Approximate a support function with explicit tolerance controls. +74. `convexAnalysisTransformSupportFunction(value, mapping)` - Transform a support function through a map, operator, or representation change. +75. `convexAnalysisSimplifySupportFunction(value)` - Simplify a support function without changing its mathematical meaning. +76. `convexAnalysisEnumerateSupportFunction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a support function. +77. `convexAnalysisClassifySupportFunction(value)` - Classify a support function by its standard Convex Analysis invariants. +78. `convexAnalysisTestEquivalenceSupportFunction(left, right)` - Test whether two support function values are equivalent in Convex Analysis. +79. `convexAnalysisGenerateExampleSupportFunction(size=3)` - Generate a small documented example of a support function. +80. `convexAnalysisDocumentSupportFunction(value)` - Return a structured explanation of a support function and related assumptions. +81. `convexAnalysisValidateProjection(value)` - Validate the projection representation and domain rules for Convex Analysis. +82. `convexAnalysisConstructProjection(*args)` - Construct a projection from explicit inputs for Convex Analysis. +83. `convexAnalysisNormalizeProjection(value)` - Normalize a projection into the standard Convex Analysis representation. +84. `convexAnalysisCanonicalizeProjection(value)` - Canonicalize a projection so equivalent inputs share one form. +85. `convexAnalysisParseProjection(text)` - Parse a text or structured value into a projection. +86. `convexAnalysisFormatProjection(value)` - Format a projection for deterministic user-facing output. +87. `convexAnalysisCompareProjection(left, right)` - Compare two projection values under the conventions of Convex Analysis. +88. `convexAnalysisCombineProjection(left, right)` - Combine two projection values with the natural operation for Convex Analysis. +89. `convexAnalysisDecomposeProjection(value)` - Decompose a projection into simpler or canonical components. +90. `convexAnalysisEvaluateProjection(value, point=None)` - Evaluate a projection at a point, sample, or finite model. +91. `convexAnalysisComputeProjection(value)` - Compute the central numerical or symbolic data of a projection. +92. `convexAnalysisEstimateProjection(value, samples=None)` - Estimate a projection property from finite samples or approximations. +93. `convexAnalysisApproximateProjection(value, tolerance=1e-9)` - Approximate a projection with explicit tolerance controls. +94. `convexAnalysisTransformProjection(value, mapping)` - Transform a projection through a map, operator, or representation change. +95. `convexAnalysisSimplifyProjection(value)` - Simplify a projection without changing its mathematical meaning. +96. `convexAnalysisEnumerateProjection(value, limit=None)` - Enumerate finite members, cases, or derived objects for a projection. +97. `convexAnalysisClassifyProjection(value)` - Classify a projection by its standard Convex Analysis invariants. +98. `convexAnalysisTestEquivalenceProjection(left, right)` - Test whether two projection values are equivalent in Convex Analysis. +99. `convexAnalysisGenerateExampleProjection(size=3)` - Generate a small documented example of a projection. +100. `convexAnalysisDocumentProjection(value)` - Return a structured explanation of a projection and related assumptions. + +### Calculus of Variations + +Core object families: + +- functional +- variation +- Euler Lagrange residual +- path energy +- extremal curve + +Candidate functions: + +1. `calculusOfVariationsValidateFunctional(value)` - Validate the functional representation and domain rules for Calculus of Variations. +2. `calculusOfVariationsConstructFunctional(*args)` - Construct a functional from explicit inputs for Calculus of Variations. +3. `calculusOfVariationsNormalizeFunctional(value)` - Normalize a functional into the standard Calculus of Variations representation. +4. `calculusOfVariationsCanonicalizeFunctional(value)` - Canonicalize a functional so equivalent inputs share one form. +5. `calculusOfVariationsParseFunctional(text)` - Parse a text or structured value into a functional. +6. `calculusOfVariationsFormatFunctional(value)` - Format a functional for deterministic user-facing output. +7. `calculusOfVariationsCompareFunctional(left, right)` - Compare two functional values under the conventions of Calculus of Variations. +8. `calculusOfVariationsCombineFunctional(left, right)` - Combine two functional values with the natural operation for Calculus of Variations. +9. `calculusOfVariationsDecomposeFunctional(value)` - Decompose a functional into simpler or canonical components. +10. `calculusOfVariationsEvaluateFunctional(value, point=None)` - Evaluate a functional at a point, sample, or finite model. +11. `calculusOfVariationsComputeFunctional(value)` - Compute the central numerical or symbolic data of a functional. +12. `calculusOfVariationsEstimateFunctional(value, samples=None)` - Estimate a functional property from finite samples or approximations. +13. `calculusOfVariationsApproximateFunctional(value, tolerance=1e-9)` - Approximate a functional with explicit tolerance controls. +14. `calculusOfVariationsTransformFunctional(value, mapping)` - Transform a functional through a map, operator, or representation change. +15. `calculusOfVariationsSimplifyFunctional(value)` - Simplify a functional without changing its mathematical meaning. +16. `calculusOfVariationsEnumerateFunctional(value, limit=None)` - Enumerate finite members, cases, or derived objects for a functional. +17. `calculusOfVariationsClassifyFunctional(value)` - Classify a functional by its standard Calculus of Variations invariants. +18. `calculusOfVariationsTestEquivalenceFunctional(left, right)` - Test whether two functional values are equivalent in Calculus of Variations. +19. `calculusOfVariationsGenerateExampleFunctional(size=3)` - Generate a small documented example of a functional. +20. `calculusOfVariationsDocumentFunctional(value)` - Return a structured explanation of a functional and related assumptions. +21. `calculusOfVariationsValidateVariation(value)` - Validate the variation representation and domain rules for Calculus of Variations. +22. `calculusOfVariationsConstructVariation(*args)` - Construct a variation from explicit inputs for Calculus of Variations. +23. `calculusOfVariationsNormalizeVariation(value)` - Normalize a variation into the standard Calculus of Variations representation. +24. `calculusOfVariationsCanonicalizeVariation(value)` - Canonicalize a variation so equivalent inputs share one form. +25. `calculusOfVariationsParseVariation(text)` - Parse a text or structured value into a variation. +26. `calculusOfVariationsFormatVariation(value)` - Format a variation for deterministic user-facing output. +27. `calculusOfVariationsCompareVariation(left, right)` - Compare two variation values under the conventions of Calculus of Variations. +28. `calculusOfVariationsCombineVariation(left, right)` - Combine two variation values with the natural operation for Calculus of Variations. +29. `calculusOfVariationsDecomposeVariation(value)` - Decompose a variation into simpler or canonical components. +30. `calculusOfVariationsEvaluateVariation(value, point=None)` - Evaluate a variation at a point, sample, or finite model. +31. `calculusOfVariationsComputeVariation(value)` - Compute the central numerical or symbolic data of a variation. +32. `calculusOfVariationsEstimateVariation(value, samples=None)` - Estimate a variation property from finite samples or approximations. +33. `calculusOfVariationsApproximateVariation(value, tolerance=1e-9)` - Approximate a variation with explicit tolerance controls. +34. `calculusOfVariationsTransformVariation(value, mapping)` - Transform a variation through a map, operator, or representation change. +35. `calculusOfVariationsSimplifyVariation(value)` - Simplify a variation without changing its mathematical meaning. +36. `calculusOfVariationsEnumerateVariation(value, limit=None)` - Enumerate finite members, cases, or derived objects for a variation. +37. `calculusOfVariationsClassifyVariation(value)` - Classify a variation by its standard Calculus of Variations invariants. +38. `calculusOfVariationsTestEquivalenceVariation(left, right)` - Test whether two variation values are equivalent in Calculus of Variations. +39. `calculusOfVariationsGenerateExampleVariation(size=3)` - Generate a small documented example of a variation. +40. `calculusOfVariationsDocumentVariation(value)` - Return a structured explanation of a variation and related assumptions. +41. `calculusOfVariationsValidateEulerLagrangeResidual(value)` - Validate the Euler Lagrange residual representation and domain rules for Calculus of Variations. +42. `calculusOfVariationsConstructEulerLagrangeResidual(*args)` - Construct a Euler Lagrange residual from explicit inputs for Calculus of Variations. +43. `calculusOfVariationsNormalizeEulerLagrangeResidual(value)` - Normalize a Euler Lagrange residual into the standard Calculus of Variations representation. +44. `calculusOfVariationsCanonicalizeEulerLagrangeResidual(value)` - Canonicalize a Euler Lagrange residual so equivalent inputs share one form. +45. `calculusOfVariationsParseEulerLagrangeResidual(text)` - Parse a text or structured value into a Euler Lagrange residual. +46. `calculusOfVariationsFormatEulerLagrangeResidual(value)` - Format a Euler Lagrange residual for deterministic user-facing output. +47. `calculusOfVariationsCompareEulerLagrangeResidual(left, right)` - Compare two Euler Lagrange residual values under the conventions of Calculus of Variations. +48. `calculusOfVariationsCombineEulerLagrangeResidual(left, right)` - Combine two Euler Lagrange residual values with the natural operation for Calculus of Variations. +49. `calculusOfVariationsDecomposeEulerLagrangeResidual(value)` - Decompose a Euler Lagrange residual into simpler or canonical components. +50. `calculusOfVariationsEvaluateEulerLagrangeResidual(value, point=None)` - Evaluate a Euler Lagrange residual at a point, sample, or finite model. +51. `calculusOfVariationsComputeEulerLagrangeResidual(value)` - Compute the central numerical or symbolic data of a Euler Lagrange residual. +52. `calculusOfVariationsEstimateEulerLagrangeResidual(value, samples=None)` - Estimate a Euler Lagrange residual property from finite samples or approximations. +53. `calculusOfVariationsApproximateEulerLagrangeResidual(value, tolerance=1e-9)` - Approximate a Euler Lagrange residual with explicit tolerance controls. +54. `calculusOfVariationsTransformEulerLagrangeResidual(value, mapping)` - Transform a Euler Lagrange residual through a map, operator, or representation change. +55. `calculusOfVariationsSimplifyEulerLagrangeResidual(value)` - Simplify a Euler Lagrange residual without changing its mathematical meaning. +56. `calculusOfVariationsEnumerateEulerLagrangeResidual(value, limit=None)` - Enumerate finite members, cases, or derived objects for a Euler Lagrange residual. +57. `calculusOfVariationsClassifyEulerLagrangeResidual(value)` - Classify a Euler Lagrange residual by its standard Calculus of Variations invariants. +58. `calculusOfVariationsTestEquivalenceEulerLagrangeResidual(left, right)` - Test whether two Euler Lagrange residual values are equivalent in Calculus of Variations. +59. `calculusOfVariationsGenerateExampleEulerLagrangeResidual(size=3)` - Generate a small documented example of a Euler Lagrange residual. +60. `calculusOfVariationsDocumentEulerLagrangeResidual(value)` - Return a structured explanation of a Euler Lagrange residual and related assumptions. +61. `calculusOfVariationsValidatePathEnergy(value)` - Validate the path energy representation and domain rules for Calculus of Variations. +62. `calculusOfVariationsConstructPathEnergy(*args)` - Construct a path energy from explicit inputs for Calculus of Variations. +63. `calculusOfVariationsNormalizePathEnergy(value)` - Normalize a path energy into the standard Calculus of Variations representation. +64. `calculusOfVariationsCanonicalizePathEnergy(value)` - Canonicalize a path energy so equivalent inputs share one form. +65. `calculusOfVariationsParsePathEnergy(text)` - Parse a text or structured value into a path energy. +66. `calculusOfVariationsFormatPathEnergy(value)` - Format a path energy for deterministic user-facing output. +67. `calculusOfVariationsComparePathEnergy(left, right)` - Compare two path energy values under the conventions of Calculus of Variations. +68. `calculusOfVariationsCombinePathEnergy(left, right)` - Combine two path energy values with the natural operation for Calculus of Variations. +69. `calculusOfVariationsDecomposePathEnergy(value)` - Decompose a path energy into simpler or canonical components. +70. `calculusOfVariationsEvaluatePathEnergy(value, point=None)` - Evaluate a path energy at a point, sample, or finite model. +71. `calculusOfVariationsComputePathEnergy(value)` - Compute the central numerical or symbolic data of a path energy. +72. `calculusOfVariationsEstimatePathEnergy(value, samples=None)` - Estimate a path energy property from finite samples or approximations. +73. `calculusOfVariationsApproximatePathEnergy(value, tolerance=1e-9)` - Approximate a path energy with explicit tolerance controls. +74. `calculusOfVariationsTransformPathEnergy(value, mapping)` - Transform a path energy through a map, operator, or representation change. +75. `calculusOfVariationsSimplifyPathEnergy(value)` - Simplify a path energy without changing its mathematical meaning. +76. `calculusOfVariationsEnumeratePathEnergy(value, limit=None)` - Enumerate finite members, cases, or derived objects for a path energy. +77. `calculusOfVariationsClassifyPathEnergy(value)` - Classify a path energy by its standard Calculus of Variations invariants. +78. `calculusOfVariationsTestEquivalencePathEnergy(left, right)` - Test whether two path energy values are equivalent in Calculus of Variations. +79. `calculusOfVariationsGenerateExamplePathEnergy(size=3)` - Generate a small documented example of a path energy. +80. `calculusOfVariationsDocumentPathEnergy(value)` - Return a structured explanation of a path energy and related assumptions. +81. `calculusOfVariationsValidateExtremalCurve(value)` - Validate the extremal curve representation and domain rules for Calculus of Variations. +82. `calculusOfVariationsConstructExtremalCurve(*args)` - Construct a extremal curve from explicit inputs for Calculus of Variations. +83. `calculusOfVariationsNormalizeExtremalCurve(value)` - Normalize a extremal curve into the standard Calculus of Variations representation. +84. `calculusOfVariationsCanonicalizeExtremalCurve(value)` - Canonicalize a extremal curve so equivalent inputs share one form. +85. `calculusOfVariationsParseExtremalCurve(text)` - Parse a text or structured value into a extremal curve. +86. `calculusOfVariationsFormatExtremalCurve(value)` - Format a extremal curve for deterministic user-facing output. +87. `calculusOfVariationsCompareExtremalCurve(left, right)` - Compare two extremal curve values under the conventions of Calculus of Variations. +88. `calculusOfVariationsCombineExtremalCurve(left, right)` - Combine two extremal curve values with the natural operation for Calculus of Variations. +89. `calculusOfVariationsDecomposeExtremalCurve(value)` - Decompose a extremal curve into simpler or canonical components. +90. `calculusOfVariationsEvaluateExtremalCurve(value, point=None)` - Evaluate a extremal curve at a point, sample, or finite model. +91. `calculusOfVariationsComputeExtremalCurve(value)` - Compute the central numerical or symbolic data of a extremal curve. +92. `calculusOfVariationsEstimateExtremalCurve(value, samples=None)` - Estimate a extremal curve property from finite samples or approximations. +93. `calculusOfVariationsApproximateExtremalCurve(value, tolerance=1e-9)` - Approximate a extremal curve with explicit tolerance controls. +94. `calculusOfVariationsTransformExtremalCurve(value, mapping)` - Transform a extremal curve through a map, operator, or representation change. +95. `calculusOfVariationsSimplifyExtremalCurve(value)` - Simplify a extremal curve without changing its mathematical meaning. +96. `calculusOfVariationsEnumerateExtremalCurve(value, limit=None)` - Enumerate finite members, cases, or derived objects for a extremal curve. +97. `calculusOfVariationsClassifyExtremalCurve(value)` - Classify a extremal curve by its standard Calculus of Variations invariants. +98. `calculusOfVariationsTestEquivalenceExtremalCurve(left, right)` - Test whether two extremal curve values are equivalent in Calculus of Variations. +99. `calculusOfVariationsGenerateExampleExtremalCurve(size=3)` - Generate a small documented example of a extremal curve. +100. `calculusOfVariationsDocumentExtremalCurve(value)` - Return a structured explanation of a extremal curve and related assumptions. + +### Optimal Transport + +Core object families: + +- discrete measure +- coupling +- cost matrix +- transport plan +- Wasserstein estimate + +Candidate functions: + +1. `optimalTransportValidateDiscreteMeasure(value)` - Validate the discrete measure representation and domain rules for Optimal Transport. +2. `optimalTransportConstructDiscreteMeasure(*args)` - Construct a discrete measure from explicit inputs for Optimal Transport. +3. `optimalTransportNormalizeDiscreteMeasure(value)` - Normalize a discrete measure into the standard Optimal Transport representation. +4. `optimalTransportCanonicalizeDiscreteMeasure(value)` - Canonicalize a discrete measure so equivalent inputs share one form. +5. `optimalTransportParseDiscreteMeasure(text)` - Parse a text or structured value into a discrete measure. +6. `optimalTransportFormatDiscreteMeasure(value)` - Format a discrete measure for deterministic user-facing output. +7. `optimalTransportCompareDiscreteMeasure(left, right)` - Compare two discrete measure values under the conventions of Optimal Transport. +8. `optimalTransportCombineDiscreteMeasure(left, right)` - Combine two discrete measure values with the natural operation for Optimal Transport. +9. `optimalTransportDecomposeDiscreteMeasure(value)` - Decompose a discrete measure into simpler or canonical components. +10. `optimalTransportEvaluateDiscreteMeasure(value, point=None)` - Evaluate a discrete measure at a point, sample, or finite model. +11. `optimalTransportComputeDiscreteMeasure(value)` - Compute the central numerical or symbolic data of a discrete measure. +12. `optimalTransportEstimateDiscreteMeasure(value, samples=None)` - Estimate a discrete measure property from finite samples or approximations. +13. `optimalTransportApproximateDiscreteMeasure(value, tolerance=1e-9)` - Approximate a discrete measure with explicit tolerance controls. +14. `optimalTransportTransformDiscreteMeasure(value, mapping)` - Transform a discrete measure through a map, operator, or representation change. +15. `optimalTransportSimplifyDiscreteMeasure(value)` - Simplify a discrete measure without changing its mathematical meaning. +16. `optimalTransportEnumerateDiscreteMeasure(value, limit=None)` - Enumerate finite members, cases, or derived objects for a discrete measure. +17. `optimalTransportClassifyDiscreteMeasure(value)` - Classify a discrete measure by its standard Optimal Transport invariants. +18. `optimalTransportTestEquivalenceDiscreteMeasure(left, right)` - Test whether two discrete measure values are equivalent in Optimal Transport. +19. `optimalTransportGenerateExampleDiscreteMeasure(size=3)` - Generate a small documented example of a discrete measure. +20. `optimalTransportDocumentDiscreteMeasure(value)` - Return a structured explanation of a discrete measure and related assumptions. +21. `optimalTransportValidateCoupling(value)` - Validate the coupling representation and domain rules for Optimal Transport. +22. `optimalTransportConstructCoupling(*args)` - Construct a coupling from explicit inputs for Optimal Transport. +23. `optimalTransportNormalizeCoupling(value)` - Normalize a coupling into the standard Optimal Transport representation. +24. `optimalTransportCanonicalizeCoupling(value)` - Canonicalize a coupling so equivalent inputs share one form. +25. `optimalTransportParseCoupling(text)` - Parse a text or structured value into a coupling. +26. `optimalTransportFormatCoupling(value)` - Format a coupling for deterministic user-facing output. +27. `optimalTransportCompareCoupling(left, right)` - Compare two coupling values under the conventions of Optimal Transport. +28. `optimalTransportCombineCoupling(left, right)` - Combine two coupling values with the natural operation for Optimal Transport. +29. `optimalTransportDecomposeCoupling(value)` - Decompose a coupling into simpler or canonical components. +30. `optimalTransportEvaluateCoupling(value, point=None)` - Evaluate a coupling at a point, sample, or finite model. +31. `optimalTransportComputeCoupling(value)` - Compute the central numerical or symbolic data of a coupling. +32. `optimalTransportEstimateCoupling(value, samples=None)` - Estimate a coupling property from finite samples or approximations. +33. `optimalTransportApproximateCoupling(value, tolerance=1e-9)` - Approximate a coupling with explicit tolerance controls. +34. `optimalTransportTransformCoupling(value, mapping)` - Transform a coupling through a map, operator, or representation change. +35. `optimalTransportSimplifyCoupling(value)` - Simplify a coupling without changing its mathematical meaning. +36. `optimalTransportEnumerateCoupling(value, limit=None)` - Enumerate finite members, cases, or derived objects for a coupling. +37. `optimalTransportClassifyCoupling(value)` - Classify a coupling by its standard Optimal Transport invariants. +38. `optimalTransportTestEquivalenceCoupling(left, right)` - Test whether two coupling values are equivalent in Optimal Transport. +39. `optimalTransportGenerateExampleCoupling(size=3)` - Generate a small documented example of a coupling. +40. `optimalTransportDocumentCoupling(value)` - Return a structured explanation of a coupling and related assumptions. +41. `optimalTransportValidateCostMatrix(value)` - Validate the cost matrix representation and domain rules for Optimal Transport. +42. `optimalTransportConstructCostMatrix(*args)` - Construct a cost matrix from explicit inputs for Optimal Transport. +43. `optimalTransportNormalizeCostMatrix(value)` - Normalize a cost matrix into the standard Optimal Transport representation. +44. `optimalTransportCanonicalizeCostMatrix(value)` - Canonicalize a cost matrix so equivalent inputs share one form. +45. `optimalTransportParseCostMatrix(text)` - Parse a text or structured value into a cost matrix. +46. `optimalTransportFormatCostMatrix(value)` - Format a cost matrix for deterministic user-facing output. +47. `optimalTransportCompareCostMatrix(left, right)` - Compare two cost matrix values under the conventions of Optimal Transport. +48. `optimalTransportCombineCostMatrix(left, right)` - Combine two cost matrix values with the natural operation for Optimal Transport. +49. `optimalTransportDecomposeCostMatrix(value)` - Decompose a cost matrix into simpler or canonical components. +50. `optimalTransportEvaluateCostMatrix(value, point=None)` - Evaluate a cost matrix at a point, sample, or finite model. +51. `optimalTransportComputeCostMatrix(value)` - Compute the central numerical or symbolic data of a cost matrix. +52. `optimalTransportEstimateCostMatrix(value, samples=None)` - Estimate a cost matrix property from finite samples or approximations. +53. `optimalTransportApproximateCostMatrix(value, tolerance=1e-9)` - Approximate a cost matrix with explicit tolerance controls. +54. `optimalTransportTransformCostMatrix(value, mapping)` - Transform a cost matrix through a map, operator, or representation change. +55. `optimalTransportSimplifyCostMatrix(value)` - Simplify a cost matrix without changing its mathematical meaning. +56. `optimalTransportEnumerateCostMatrix(value, limit=None)` - Enumerate finite members, cases, or derived objects for a cost matrix. +57. `optimalTransportClassifyCostMatrix(value)` - Classify a cost matrix by its standard Optimal Transport invariants. +58. `optimalTransportTestEquivalenceCostMatrix(left, right)` - Test whether two cost matrix values are equivalent in Optimal Transport. +59. `optimalTransportGenerateExampleCostMatrix(size=3)` - Generate a small documented example of a cost matrix. +60. `optimalTransportDocumentCostMatrix(value)` - Return a structured explanation of a cost matrix and related assumptions. +61. `optimalTransportValidateTransportPlan(value)` - Validate the transport plan representation and domain rules for Optimal Transport. +62. `optimalTransportConstructTransportPlan(*args)` - Construct a transport plan from explicit inputs for Optimal Transport. +63. `optimalTransportNormalizeTransportPlan(value)` - Normalize a transport plan into the standard Optimal Transport representation. +64. `optimalTransportCanonicalizeTransportPlan(value)` - Canonicalize a transport plan so equivalent inputs share one form. +65. `optimalTransportParseTransportPlan(text)` - Parse a text or structured value into a transport plan. +66. `optimalTransportFormatTransportPlan(value)` - Format a transport plan for deterministic user-facing output. +67. `optimalTransportCompareTransportPlan(left, right)` - Compare two transport plan values under the conventions of Optimal Transport. +68. `optimalTransportCombineTransportPlan(left, right)` - Combine two transport plan values with the natural operation for Optimal Transport. +69. `optimalTransportDecomposeTransportPlan(value)` - Decompose a transport plan into simpler or canonical components. +70. `optimalTransportEvaluateTransportPlan(value, point=None)` - Evaluate a transport plan at a point, sample, or finite model. +71. `optimalTransportComputeTransportPlan(value)` - Compute the central numerical or symbolic data of a transport plan. +72. `optimalTransportEstimateTransportPlan(value, samples=None)` - Estimate a transport plan property from finite samples or approximations. +73. `optimalTransportApproximateTransportPlan(value, tolerance=1e-9)` - Approximate a transport plan with explicit tolerance controls. +74. `optimalTransportTransformTransportPlan(value, mapping)` - Transform a transport plan through a map, operator, or representation change. +75. `optimalTransportSimplifyTransportPlan(value)` - Simplify a transport plan without changing its mathematical meaning. +76. `optimalTransportEnumerateTransportPlan(value, limit=None)` - Enumerate finite members, cases, or derived objects for a transport plan. +77. `optimalTransportClassifyTransportPlan(value)` - Classify a transport plan by its standard Optimal Transport invariants. +78. `optimalTransportTestEquivalenceTransportPlan(left, right)` - Test whether two transport plan values are equivalent in Optimal Transport. +79. `optimalTransportGenerateExampleTransportPlan(size=3)` - Generate a small documented example of a transport plan. +80. `optimalTransportDocumentTransportPlan(value)` - Return a structured explanation of a transport plan and related assumptions. +81. `optimalTransportValidateWassersteinEstimate(value)` - Validate the Wasserstein estimate representation and domain rules for Optimal Transport. +82. `optimalTransportConstructWassersteinEstimate(*args)` - Construct a Wasserstein estimate from explicit inputs for Optimal Transport. +83. `optimalTransportNormalizeWassersteinEstimate(value)` - Normalize a Wasserstein estimate into the standard Optimal Transport representation. +84. `optimalTransportCanonicalizeWassersteinEstimate(value)` - Canonicalize a Wasserstein estimate so equivalent inputs share one form. +85. `optimalTransportParseWassersteinEstimate(text)` - Parse a text or structured value into a Wasserstein estimate. +86. `optimalTransportFormatWassersteinEstimate(value)` - Format a Wasserstein estimate for deterministic user-facing output. +87. `optimalTransportCompareWassersteinEstimate(left, right)` - Compare two Wasserstein estimate values under the conventions of Optimal Transport. +88. `optimalTransportCombineWassersteinEstimate(left, right)` - Combine two Wasserstein estimate values with the natural operation for Optimal Transport. +89. `optimalTransportDecomposeWassersteinEstimate(value)` - Decompose a Wasserstein estimate into simpler or canonical components. +90. `optimalTransportEvaluateWassersteinEstimate(value, point=None)` - Evaluate a Wasserstein estimate at a point, sample, or finite model. +91. `optimalTransportComputeWassersteinEstimate(value)` - Compute the central numerical or symbolic data of a Wasserstein estimate. +92. `optimalTransportEstimateWassersteinEstimate(value, samples=None)` - Estimate a Wasserstein estimate property from finite samples or approximations. +93. `optimalTransportApproximateWassersteinEstimate(value, tolerance=1e-9)` - Approximate a Wasserstein estimate with explicit tolerance controls. +94. `optimalTransportTransformWassersteinEstimate(value, mapping)` - Transform a Wasserstein estimate through a map, operator, or representation change. +95. `optimalTransportSimplifyWassersteinEstimate(value)` - Simplify a Wasserstein estimate without changing its mathematical meaning. +96. `optimalTransportEnumerateWassersteinEstimate(value, limit=None)` - Enumerate finite members, cases, or derived objects for a Wasserstein estimate. +97. `optimalTransportClassifyWassersteinEstimate(value)` - Classify a Wasserstein estimate by its standard Optimal Transport invariants. +98. `optimalTransportTestEquivalenceWassersteinEstimate(left, right)` - Test whether two Wasserstein estimate values are equivalent in Optimal Transport. +99. `optimalTransportGenerateExampleWassersteinEstimate(size=3)` - Generate a small documented example of a Wasserstein estimate. +100. `optimalTransportDocumentWassersteinEstimate(value)` - Return a structured explanation of a Wasserstein estimate and related assumptions. + +### Numerical Linear Algebra + +Core object families: + +- matrix factorization +- iterative solver +- condition estimate +- orthogonal basis +- eigen iteration + +Candidate functions: + +1. `numericalLinearAlgebraValidateMatrixFactorization(value)` - Validate the matrix factorization representation and domain rules for Numerical Linear Algebra. +2. `numericalLinearAlgebraConstructMatrixFactorization(*args)` - Construct a matrix factorization from explicit inputs for Numerical Linear Algebra. +3. `numericalLinearAlgebraNormalizeMatrixFactorization(value)` - Normalize a matrix factorization into the standard Numerical Linear Algebra representation. +4. `numericalLinearAlgebraCanonicalizeMatrixFactorization(value)` - Canonicalize a matrix factorization so equivalent inputs share one form. +5. `numericalLinearAlgebraParseMatrixFactorization(text)` - Parse a text or structured value into a matrix factorization. +6. `numericalLinearAlgebraFormatMatrixFactorization(value)` - Format a matrix factorization for deterministic user-facing output. +7. `numericalLinearAlgebraCompareMatrixFactorization(left, right)` - Compare two matrix factorization values under the conventions of Numerical Linear Algebra. +8. `numericalLinearAlgebraCombineMatrixFactorization(left, right)` - Combine two matrix factorization values with the natural operation for Numerical Linear Algebra. +9. `numericalLinearAlgebraDecomposeMatrixFactorization(value)` - Decompose a matrix factorization into simpler or canonical components. +10. `numericalLinearAlgebraEvaluateMatrixFactorization(value, point=None)` - Evaluate a matrix factorization at a point, sample, or finite model. +11. `numericalLinearAlgebraComputeMatrixFactorization(value)` - Compute the central numerical or symbolic data of a matrix factorization. +12. `numericalLinearAlgebraEstimateMatrixFactorization(value, samples=None)` - Estimate a matrix factorization property from finite samples or approximations. +13. `numericalLinearAlgebraApproximateMatrixFactorization(value, tolerance=1e-9)` - Approximate a matrix factorization with explicit tolerance controls. +14. `numericalLinearAlgebraTransformMatrixFactorization(value, mapping)` - Transform a matrix factorization through a map, operator, or representation change. +15. `numericalLinearAlgebraSimplifyMatrixFactorization(value)` - Simplify a matrix factorization without changing its mathematical meaning. +16. `numericalLinearAlgebraEnumerateMatrixFactorization(value, limit=None)` - Enumerate finite members, cases, or derived objects for a matrix factorization. +17. `numericalLinearAlgebraClassifyMatrixFactorization(value)` - Classify a matrix factorization by its standard Numerical Linear Algebra invariants. +18. `numericalLinearAlgebraTestEquivalenceMatrixFactorization(left, right)` - Test whether two matrix factorization values are equivalent in Numerical Linear Algebra. +19. `numericalLinearAlgebraGenerateExampleMatrixFactorization(size=3)` - Generate a small documented example of a matrix factorization. +20. `numericalLinearAlgebraDocumentMatrixFactorization(value)` - Return a structured explanation of a matrix factorization and related assumptions. +21. `numericalLinearAlgebraValidateIterativeSolver(value)` - Validate the iterative solver representation and domain rules for Numerical Linear Algebra. +22. `numericalLinearAlgebraConstructIterativeSolver(*args)` - Construct a iterative solver from explicit inputs for Numerical Linear Algebra. +23. `numericalLinearAlgebraNormalizeIterativeSolver(value)` - Normalize a iterative solver into the standard Numerical Linear Algebra representation. +24. `numericalLinearAlgebraCanonicalizeIterativeSolver(value)` - Canonicalize a iterative solver so equivalent inputs share one form. +25. `numericalLinearAlgebraParseIterativeSolver(text)` - Parse a text or structured value into a iterative solver. +26. `numericalLinearAlgebraFormatIterativeSolver(value)` - Format a iterative solver for deterministic user-facing output. +27. `numericalLinearAlgebraCompareIterativeSolver(left, right)` - Compare two iterative solver values under the conventions of Numerical Linear Algebra. +28. `numericalLinearAlgebraCombineIterativeSolver(left, right)` - Combine two iterative solver values with the natural operation for Numerical Linear Algebra. +29. `numericalLinearAlgebraDecomposeIterativeSolver(value)` - Decompose a iterative solver into simpler or canonical components. +30. `numericalLinearAlgebraEvaluateIterativeSolver(value, point=None)` - Evaluate a iterative solver at a point, sample, or finite model. +31. `numericalLinearAlgebraComputeIterativeSolver(value)` - Compute the central numerical or symbolic data of a iterative solver. +32. `numericalLinearAlgebraEstimateIterativeSolver(value, samples=None)` - Estimate a iterative solver property from finite samples or approximations. +33. `numericalLinearAlgebraApproximateIterativeSolver(value, tolerance=1e-9)` - Approximate a iterative solver with explicit tolerance controls. +34. `numericalLinearAlgebraTransformIterativeSolver(value, mapping)` - Transform a iterative solver through a map, operator, or representation change. +35. `numericalLinearAlgebraSimplifyIterativeSolver(value)` - Simplify a iterative solver without changing its mathematical meaning. +36. `numericalLinearAlgebraEnumerateIterativeSolver(value, limit=None)` - Enumerate finite members, cases, or derived objects for a iterative solver. +37. `numericalLinearAlgebraClassifyIterativeSolver(value)` - Classify a iterative solver by its standard Numerical Linear Algebra invariants. +38. `numericalLinearAlgebraTestEquivalenceIterativeSolver(left, right)` - Test whether two iterative solver values are equivalent in Numerical Linear Algebra. +39. `numericalLinearAlgebraGenerateExampleIterativeSolver(size=3)` - Generate a small documented example of a iterative solver. +40. `numericalLinearAlgebraDocumentIterativeSolver(value)` - Return a structured explanation of a iterative solver and related assumptions. +41. `numericalLinearAlgebraValidateConditionEstimate(value)` - Validate the condition estimate representation and domain rules for Numerical Linear Algebra. +42. `numericalLinearAlgebraConstructConditionEstimate(*args)` - Construct a condition estimate from explicit inputs for Numerical Linear Algebra. +43. `numericalLinearAlgebraNormalizeConditionEstimate(value)` - Normalize a condition estimate into the standard Numerical Linear Algebra representation. +44. `numericalLinearAlgebraCanonicalizeConditionEstimate(value)` - Canonicalize a condition estimate so equivalent inputs share one form. +45. `numericalLinearAlgebraParseConditionEstimate(text)` - Parse a text or structured value into a condition estimate. +46. `numericalLinearAlgebraFormatConditionEstimate(value)` - Format a condition estimate for deterministic user-facing output. +47. `numericalLinearAlgebraCompareConditionEstimate(left, right)` - Compare two condition estimate values under the conventions of Numerical Linear Algebra. +48. `numericalLinearAlgebraCombineConditionEstimate(left, right)` - Combine two condition estimate values with the natural operation for Numerical Linear Algebra. +49. `numericalLinearAlgebraDecomposeConditionEstimate(value)` - Decompose a condition estimate into simpler or canonical components. +50. `numericalLinearAlgebraEvaluateConditionEstimate(value, point=None)` - Evaluate a condition estimate at a point, sample, or finite model. +51. `numericalLinearAlgebraComputeConditionEstimate(value)` - Compute the central numerical or symbolic data of a condition estimate. +52. `numericalLinearAlgebraEstimateConditionEstimate(value, samples=None)` - Estimate a condition estimate property from finite samples or approximations. +53. `numericalLinearAlgebraApproximateConditionEstimate(value, tolerance=1e-9)` - Approximate a condition estimate with explicit tolerance controls. +54. `numericalLinearAlgebraTransformConditionEstimate(value, mapping)` - Transform a condition estimate through a map, operator, or representation change. +55. `numericalLinearAlgebraSimplifyConditionEstimate(value)` - Simplify a condition estimate without changing its mathematical meaning. +56. `numericalLinearAlgebraEnumerateConditionEstimate(value, limit=None)` - Enumerate finite members, cases, or derived objects for a condition estimate. +57. `numericalLinearAlgebraClassifyConditionEstimate(value)` - Classify a condition estimate by its standard Numerical Linear Algebra invariants. +58. `numericalLinearAlgebraTestEquivalenceConditionEstimate(left, right)` - Test whether two condition estimate values are equivalent in Numerical Linear Algebra. +59. `numericalLinearAlgebraGenerateExampleConditionEstimate(size=3)` - Generate a small documented example of a condition estimate. +60. `numericalLinearAlgebraDocumentConditionEstimate(value)` - Return a structured explanation of a condition estimate and related assumptions. +61. `numericalLinearAlgebraValidateOrthogonalBasis(value)` - Validate the orthogonal basis representation and domain rules for Numerical Linear Algebra. +62. `numericalLinearAlgebraConstructOrthogonalBasis(*args)` - Construct a orthogonal basis from explicit inputs for Numerical Linear Algebra. +63. `numericalLinearAlgebraNormalizeOrthogonalBasis(value)` - Normalize a orthogonal basis into the standard Numerical Linear Algebra representation. +64. `numericalLinearAlgebraCanonicalizeOrthogonalBasis(value)` - Canonicalize a orthogonal basis so equivalent inputs share one form. +65. `numericalLinearAlgebraParseOrthogonalBasis(text)` - Parse a text or structured value into a orthogonal basis. +66. `numericalLinearAlgebraFormatOrthogonalBasis(value)` - Format a orthogonal basis for deterministic user-facing output. +67. `numericalLinearAlgebraCompareOrthogonalBasis(left, right)` - Compare two orthogonal basis values under the conventions of Numerical Linear Algebra. +68. `numericalLinearAlgebraCombineOrthogonalBasis(left, right)` - Combine two orthogonal basis values with the natural operation for Numerical Linear Algebra. +69. `numericalLinearAlgebraDecomposeOrthogonalBasis(value)` - Decompose a orthogonal basis into simpler or canonical components. +70. `numericalLinearAlgebraEvaluateOrthogonalBasis(value, point=None)` - Evaluate a orthogonal basis at a point, sample, or finite model. +71. `numericalLinearAlgebraComputeOrthogonalBasis(value)` - Compute the central numerical or symbolic data of a orthogonal basis. +72. `numericalLinearAlgebraEstimateOrthogonalBasis(value, samples=None)` - Estimate a orthogonal basis property from finite samples or approximations. +73. `numericalLinearAlgebraApproximateOrthogonalBasis(value, tolerance=1e-9)` - Approximate a orthogonal basis with explicit tolerance controls. +74. `numericalLinearAlgebraTransformOrthogonalBasis(value, mapping)` - Transform a orthogonal basis through a map, operator, or representation change. +75. `numericalLinearAlgebraSimplifyOrthogonalBasis(value)` - Simplify a orthogonal basis without changing its mathematical meaning. +76. `numericalLinearAlgebraEnumerateOrthogonalBasis(value, limit=None)` - Enumerate finite members, cases, or derived objects for a orthogonal basis. +77. `numericalLinearAlgebraClassifyOrthogonalBasis(value)` - Classify a orthogonal basis by its standard Numerical Linear Algebra invariants. +78. `numericalLinearAlgebraTestEquivalenceOrthogonalBasis(left, right)` - Test whether two orthogonal basis values are equivalent in Numerical Linear Algebra. +79. `numericalLinearAlgebraGenerateExampleOrthogonalBasis(size=3)` - Generate a small documented example of a orthogonal basis. +80. `numericalLinearAlgebraDocumentOrthogonalBasis(value)` - Return a structured explanation of a orthogonal basis and related assumptions. +81. `numericalLinearAlgebraValidateEigenIteration(value)` - Validate the eigen iteration representation and domain rules for Numerical Linear Algebra. +82. `numericalLinearAlgebraConstructEigenIteration(*args)` - Construct a eigen iteration from explicit inputs for Numerical Linear Algebra. +83. `numericalLinearAlgebraNormalizeEigenIteration(value)` - Normalize a eigen iteration into the standard Numerical Linear Algebra representation. +84. `numericalLinearAlgebraCanonicalizeEigenIteration(value)` - Canonicalize a eigen iteration so equivalent inputs share one form. +85. `numericalLinearAlgebraParseEigenIteration(text)` - Parse a text or structured value into a eigen iteration. +86. `numericalLinearAlgebraFormatEigenIteration(value)` - Format a eigen iteration for deterministic user-facing output. +87. `numericalLinearAlgebraCompareEigenIteration(left, right)` - Compare two eigen iteration values under the conventions of Numerical Linear Algebra. +88. `numericalLinearAlgebraCombineEigenIteration(left, right)` - Combine two eigen iteration values with the natural operation for Numerical Linear Algebra. +89. `numericalLinearAlgebraDecomposeEigenIteration(value)` - Decompose a eigen iteration into simpler or canonical components. +90. `numericalLinearAlgebraEvaluateEigenIteration(value, point=None)` - Evaluate a eigen iteration at a point, sample, or finite model. +91. `numericalLinearAlgebraComputeEigenIteration(value)` - Compute the central numerical or symbolic data of a eigen iteration. +92. `numericalLinearAlgebraEstimateEigenIteration(value, samples=None)` - Estimate a eigen iteration property from finite samples or approximations. +93. `numericalLinearAlgebraApproximateEigenIteration(value, tolerance=1e-9)` - Approximate a eigen iteration with explicit tolerance controls. +94. `numericalLinearAlgebraTransformEigenIteration(value, mapping)` - Transform a eigen iteration through a map, operator, or representation change. +95. `numericalLinearAlgebraSimplifyEigenIteration(value)` - Simplify a eigen iteration without changing its mathematical meaning. +96. `numericalLinearAlgebraEnumerateEigenIteration(value, limit=None)` - Enumerate finite members, cases, or derived objects for a eigen iteration. +97. `numericalLinearAlgebraClassifyEigenIteration(value)` - Classify a eigen iteration by its standard Numerical Linear Algebra invariants. +98. `numericalLinearAlgebraTestEquivalenceEigenIteration(left, right)` - Test whether two eigen iteration values are equivalent in Numerical Linear Algebra. +99. `numericalLinearAlgebraGenerateExampleEigenIteration(size=3)` - Generate a small documented example of a eigen iteration. +100. `numericalLinearAlgebraDocumentEigenIteration(value)` - Return a structured explanation of a eigen iteration and related assumptions. + +### Approximation Theory + +Core object families: + +- approximant +- interpolation node +- orthogonal polynomial +- basis coefficient +- approximation error + +Candidate functions: + +1. `approximationTheoryValidateApproximant(value)` - Validate the approximant representation and domain rules for Approximation Theory. +2. `approximationTheoryConstructApproximant(*args)` - Construct a approximant from explicit inputs for Approximation Theory. +3. `approximationTheoryNormalizeApproximant(value)` - Normalize a approximant into the standard Approximation Theory representation. +4. `approximationTheoryCanonicalizeApproximant(value)` - Canonicalize a approximant so equivalent inputs share one form. +5. `approximationTheoryParseApproximant(text)` - Parse a text or structured value into a approximant. +6. `approximationTheoryFormatApproximant(value)` - Format a approximant for deterministic user-facing output. +7. `approximationTheoryCompareApproximant(left, right)` - Compare two approximant values under the conventions of Approximation Theory. +8. `approximationTheoryCombineApproximant(left, right)` - Combine two approximant values with the natural operation for Approximation Theory. +9. `approximationTheoryDecomposeApproximant(value)` - Decompose a approximant into simpler or canonical components. +10. `approximationTheoryEvaluateApproximant(value, point=None)` - Evaluate a approximant at a point, sample, or finite model. +11. `approximationTheoryComputeApproximant(value)` - Compute the central numerical or symbolic data of a approximant. +12. `approximationTheoryEstimateApproximant(value, samples=None)` - Estimate a approximant property from finite samples or approximations. +13. `approximationTheoryApproximateApproximant(value, tolerance=1e-9)` - Approximate a approximant with explicit tolerance controls. +14. `approximationTheoryTransformApproximant(value, mapping)` - Transform a approximant through a map, operator, or representation change. +15. `approximationTheorySimplifyApproximant(value)` - Simplify a approximant without changing its mathematical meaning. +16. `approximationTheoryEnumerateApproximant(value, limit=None)` - Enumerate finite members, cases, or derived objects for a approximant. +17. `approximationTheoryClassifyApproximant(value)` - Classify a approximant by its standard Approximation Theory invariants. +18. `approximationTheoryTestEquivalenceApproximant(left, right)` - Test whether two approximant values are equivalent in Approximation Theory. +19. `approximationTheoryGenerateExampleApproximant(size=3)` - Generate a small documented example of a approximant. +20. `approximationTheoryDocumentApproximant(value)` - Return a structured explanation of a approximant and related assumptions. +21. `approximationTheoryValidateInterpolationNode(value)` - Validate the interpolation node representation and domain rules for Approximation Theory. +22. `approximationTheoryConstructInterpolationNode(*args)` - Construct a interpolation node from explicit inputs for Approximation Theory. +23. `approximationTheoryNormalizeInterpolationNode(value)` - Normalize a interpolation node into the standard Approximation Theory representation. +24. `approximationTheoryCanonicalizeInterpolationNode(value)` - Canonicalize a interpolation node so equivalent inputs share one form. +25. `approximationTheoryParseInterpolationNode(text)` - Parse a text or structured value into a interpolation node. +26. `approximationTheoryFormatInterpolationNode(value)` - Format a interpolation node for deterministic user-facing output. +27. `approximationTheoryCompareInterpolationNode(left, right)` - Compare two interpolation node values under the conventions of Approximation Theory. +28. `approximationTheoryCombineInterpolationNode(left, right)` - Combine two interpolation node values with the natural operation for Approximation Theory. +29. `approximationTheoryDecomposeInterpolationNode(value)` - Decompose a interpolation node into simpler or canonical components. +30. `approximationTheoryEvaluateInterpolationNode(value, point=None)` - Evaluate a interpolation node at a point, sample, or finite model. +31. `approximationTheoryComputeInterpolationNode(value)` - Compute the central numerical or symbolic data of a interpolation node. +32. `approximationTheoryEstimateInterpolationNode(value, samples=None)` - Estimate a interpolation node property from finite samples or approximations. +33. `approximationTheoryApproximateInterpolationNode(value, tolerance=1e-9)` - Approximate a interpolation node with explicit tolerance controls. +34. `approximationTheoryTransformInterpolationNode(value, mapping)` - Transform a interpolation node through a map, operator, or representation change. +35. `approximationTheorySimplifyInterpolationNode(value)` - Simplify a interpolation node without changing its mathematical meaning. +36. `approximationTheoryEnumerateInterpolationNode(value, limit=None)` - Enumerate finite members, cases, or derived objects for a interpolation node. +37. `approximationTheoryClassifyInterpolationNode(value)` - Classify a interpolation node by its standard Approximation Theory invariants. +38. `approximationTheoryTestEquivalenceInterpolationNode(left, right)` - Test whether two interpolation node values are equivalent in Approximation Theory. +39. `approximationTheoryGenerateExampleInterpolationNode(size=3)` - Generate a small documented example of a interpolation node. +40. `approximationTheoryDocumentInterpolationNode(value)` - Return a structured explanation of a interpolation node and related assumptions. +41. `approximationTheoryValidateOrthogonalPolynomial(value)` - Validate the orthogonal polynomial representation and domain rules for Approximation Theory. +42. `approximationTheoryConstructOrthogonalPolynomial(*args)` - Construct a orthogonal polynomial from explicit inputs for Approximation Theory. +43. `approximationTheoryNormalizeOrthogonalPolynomial(value)` - Normalize a orthogonal polynomial into the standard Approximation Theory representation. +44. `approximationTheoryCanonicalizeOrthogonalPolynomial(value)` - Canonicalize a orthogonal polynomial so equivalent inputs share one form. +45. `approximationTheoryParseOrthogonalPolynomial(text)` - Parse a text or structured value into a orthogonal polynomial. +46. `approximationTheoryFormatOrthogonalPolynomial(value)` - Format a orthogonal polynomial for deterministic user-facing output. +47. `approximationTheoryCompareOrthogonalPolynomial(left, right)` - Compare two orthogonal polynomial values under the conventions of Approximation Theory. +48. `approximationTheoryCombineOrthogonalPolynomial(left, right)` - Combine two orthogonal polynomial values with the natural operation for Approximation Theory. +49. `approximationTheoryDecomposeOrthogonalPolynomial(value)` - Decompose a orthogonal polynomial into simpler or canonical components. +50. `approximationTheoryEvaluateOrthogonalPolynomial(value, point=None)` - Evaluate a orthogonal polynomial at a point, sample, or finite model. +51. `approximationTheoryComputeOrthogonalPolynomial(value)` - Compute the central numerical or symbolic data of a orthogonal polynomial. +52. `approximationTheoryEstimateOrthogonalPolynomial(value, samples=None)` - Estimate a orthogonal polynomial property from finite samples or approximations. +53. `approximationTheoryApproximateOrthogonalPolynomial(value, tolerance=1e-9)` - Approximate a orthogonal polynomial with explicit tolerance controls. +54. `approximationTheoryTransformOrthogonalPolynomial(value, mapping)` - Transform a orthogonal polynomial through a map, operator, or representation change. +55. `approximationTheorySimplifyOrthogonalPolynomial(value)` - Simplify a orthogonal polynomial without changing its mathematical meaning. +56. `approximationTheoryEnumerateOrthogonalPolynomial(value, limit=None)` - Enumerate finite members, cases, or derived objects for a orthogonal polynomial. +57. `approximationTheoryClassifyOrthogonalPolynomial(value)` - Classify a orthogonal polynomial by its standard Approximation Theory invariants. +58. `approximationTheoryTestEquivalenceOrthogonalPolynomial(left, right)` - Test whether two orthogonal polynomial values are equivalent in Approximation Theory. +59. `approximationTheoryGenerateExampleOrthogonalPolynomial(size=3)` - Generate a small documented example of a orthogonal polynomial. +60. `approximationTheoryDocumentOrthogonalPolynomial(value)` - Return a structured explanation of a orthogonal polynomial and related assumptions. +61. `approximationTheoryValidateBasisCoefficient(value)` - Validate the basis coefficient representation and domain rules for Approximation Theory. +62. `approximationTheoryConstructBasisCoefficient(*args)` - Construct a basis coefficient from explicit inputs for Approximation Theory. +63. `approximationTheoryNormalizeBasisCoefficient(value)` - Normalize a basis coefficient into the standard Approximation Theory representation. +64. `approximationTheoryCanonicalizeBasisCoefficient(value)` - Canonicalize a basis coefficient so equivalent inputs share one form. +65. `approximationTheoryParseBasisCoefficient(text)` - Parse a text or structured value into a basis coefficient. +66. `approximationTheoryFormatBasisCoefficient(value)` - Format a basis coefficient for deterministic user-facing output. +67. `approximationTheoryCompareBasisCoefficient(left, right)` - Compare two basis coefficient values under the conventions of Approximation Theory. +68. `approximationTheoryCombineBasisCoefficient(left, right)` - Combine two basis coefficient values with the natural operation for Approximation Theory. +69. `approximationTheoryDecomposeBasisCoefficient(value)` - Decompose a basis coefficient into simpler or canonical components. +70. `approximationTheoryEvaluateBasisCoefficient(value, point=None)` - Evaluate a basis coefficient at a point, sample, or finite model. +71. `approximationTheoryComputeBasisCoefficient(value)` - Compute the central numerical or symbolic data of a basis coefficient. +72. `approximationTheoryEstimateBasisCoefficient(value, samples=None)` - Estimate a basis coefficient property from finite samples or approximations. +73. `approximationTheoryApproximateBasisCoefficient(value, tolerance=1e-9)` - Approximate a basis coefficient with explicit tolerance controls. +74. `approximationTheoryTransformBasisCoefficient(value, mapping)` - Transform a basis coefficient through a map, operator, or representation change. +75. `approximationTheorySimplifyBasisCoefficient(value)` - Simplify a basis coefficient without changing its mathematical meaning. +76. `approximationTheoryEnumerateBasisCoefficient(value, limit=None)` - Enumerate finite members, cases, or derived objects for a basis coefficient. +77. `approximationTheoryClassifyBasisCoefficient(value)` - Classify a basis coefficient by its standard Approximation Theory invariants. +78. `approximationTheoryTestEquivalenceBasisCoefficient(left, right)` - Test whether two basis coefficient values are equivalent in Approximation Theory. +79. `approximationTheoryGenerateExampleBasisCoefficient(size=3)` - Generate a small documented example of a basis coefficient. +80. `approximationTheoryDocumentBasisCoefficient(value)` - Return a structured explanation of a basis coefficient and related assumptions. +81. `approximationTheoryValidateApproximationError(value)` - Validate the approximation error representation and domain rules for Approximation Theory. +82. `approximationTheoryConstructApproximationError(*args)` - Construct a approximation error from explicit inputs for Approximation Theory. +83. `approximationTheoryNormalizeApproximationError(value)` - Normalize a approximation error into the standard Approximation Theory representation. +84. `approximationTheoryCanonicalizeApproximationError(value)` - Canonicalize a approximation error so equivalent inputs share one form. +85. `approximationTheoryParseApproximationError(text)` - Parse a text or structured value into a approximation error. +86. `approximationTheoryFormatApproximationError(value)` - Format a approximation error for deterministic user-facing output. +87. `approximationTheoryCompareApproximationError(left, right)` - Compare two approximation error values under the conventions of Approximation Theory. +88. `approximationTheoryCombineApproximationError(left, right)` - Combine two approximation error values with the natural operation for Approximation Theory. +89. `approximationTheoryDecomposeApproximationError(value)` - Decompose a approximation error into simpler or canonical components. +90. `approximationTheoryEvaluateApproximationError(value, point=None)` - Evaluate a approximation error at a point, sample, or finite model. +91. `approximationTheoryComputeApproximationError(value)` - Compute the central numerical or symbolic data of a approximation error. +92. `approximationTheoryEstimateApproximationError(value, samples=None)` - Estimate a approximation error property from finite samples or approximations. +93. `approximationTheoryApproximateApproximationError(value, tolerance=1e-9)` - Approximate a approximation error with explicit tolerance controls. +94. `approximationTheoryTransformApproximationError(value, mapping)` - Transform a approximation error through a map, operator, or representation change. +95. `approximationTheorySimplifyApproximationError(value)` - Simplify a approximation error without changing its mathematical meaning. +96. `approximationTheoryEnumerateApproximationError(value, limit=None)` - Enumerate finite members, cases, or derived objects for a approximation error. +97. `approximationTheoryClassifyApproximationError(value)` - Classify a approximation error by its standard Approximation Theory invariants. +98. `approximationTheoryTestEquivalenceApproximationError(left, right)` - Test whether two approximation error values are equivalent in Approximation Theory. +99. `approximationTheoryGenerateExampleApproximationError(size=3)` - Generate a small documented example of a approximation error. +100. `approximationTheoryDocumentApproximationError(value)` - Return a structured explanation of a approximation error and related assumptions. + +### Wavelet Theory + +Core object families: + +- wavelet coefficient +- scaling coefficient +- filter bank +- multiresolution level +- signal detail + +Candidate functions: + +1. `waveletTheoryValidateWaveletCoefficient(value)` - Validate the wavelet coefficient representation and domain rules for Wavelet Theory. +2. `waveletTheoryConstructWaveletCoefficient(*args)` - Construct a wavelet coefficient from explicit inputs for Wavelet Theory. +3. `waveletTheoryNormalizeWaveletCoefficient(value)` - Normalize a wavelet coefficient into the standard Wavelet Theory representation. +4. `waveletTheoryCanonicalizeWaveletCoefficient(value)` - Canonicalize a wavelet coefficient so equivalent inputs share one form. +5. `waveletTheoryParseWaveletCoefficient(text)` - Parse a text or structured value into a wavelet coefficient. +6. `waveletTheoryFormatWaveletCoefficient(value)` - Format a wavelet coefficient for deterministic user-facing output. +7. `waveletTheoryCompareWaveletCoefficient(left, right)` - Compare two wavelet coefficient values under the conventions of Wavelet Theory. +8. `waveletTheoryCombineWaveletCoefficient(left, right)` - Combine two wavelet coefficient values with the natural operation for Wavelet Theory. +9. `waveletTheoryDecomposeWaveletCoefficient(value)` - Decompose a wavelet coefficient into simpler or canonical components. +10. `waveletTheoryEvaluateWaveletCoefficient(value, point=None)` - Evaluate a wavelet coefficient at a point, sample, or finite model. +11. `waveletTheoryComputeWaveletCoefficient(value)` - Compute the central numerical or symbolic data of a wavelet coefficient. +12. `waveletTheoryEstimateWaveletCoefficient(value, samples=None)` - Estimate a wavelet coefficient property from finite samples or approximations. +13. `waveletTheoryApproximateWaveletCoefficient(value, tolerance=1e-9)` - Approximate a wavelet coefficient with explicit tolerance controls. +14. `waveletTheoryTransformWaveletCoefficient(value, mapping)` - Transform a wavelet coefficient through a map, operator, or representation change. +15. `waveletTheorySimplifyWaveletCoefficient(value)` - Simplify a wavelet coefficient without changing its mathematical meaning. +16. `waveletTheoryEnumerateWaveletCoefficient(value, limit=None)` - Enumerate finite members, cases, or derived objects for a wavelet coefficient. +17. `waveletTheoryClassifyWaveletCoefficient(value)` - Classify a wavelet coefficient by its standard Wavelet Theory invariants. +18. `waveletTheoryTestEquivalenceWaveletCoefficient(left, right)` - Test whether two wavelet coefficient values are equivalent in Wavelet Theory. +19. `waveletTheoryGenerateExampleWaveletCoefficient(size=3)` - Generate a small documented example of a wavelet coefficient. +20. `waveletTheoryDocumentWaveletCoefficient(value)` - Return a structured explanation of a wavelet coefficient and related assumptions. +21. `waveletTheoryValidateScalingCoefficient(value)` - Validate the scaling coefficient representation and domain rules for Wavelet Theory. +22. `waveletTheoryConstructScalingCoefficient(*args)` - Construct a scaling coefficient from explicit inputs for Wavelet Theory. +23. `waveletTheoryNormalizeScalingCoefficient(value)` - Normalize a scaling coefficient into the standard Wavelet Theory representation. +24. `waveletTheoryCanonicalizeScalingCoefficient(value)` - Canonicalize a scaling coefficient so equivalent inputs share one form. +25. `waveletTheoryParseScalingCoefficient(text)` - Parse a text or structured value into a scaling coefficient. +26. `waveletTheoryFormatScalingCoefficient(value)` - Format a scaling coefficient for deterministic user-facing output. +27. `waveletTheoryCompareScalingCoefficient(left, right)` - Compare two scaling coefficient values under the conventions of Wavelet Theory. +28. `waveletTheoryCombineScalingCoefficient(left, right)` - Combine two scaling coefficient values with the natural operation for Wavelet Theory. +29. `waveletTheoryDecomposeScalingCoefficient(value)` - Decompose a scaling coefficient into simpler or canonical components. +30. `waveletTheoryEvaluateScalingCoefficient(value, point=None)` - Evaluate a scaling coefficient at a point, sample, or finite model. +31. `waveletTheoryComputeScalingCoefficient(value)` - Compute the central numerical or symbolic data of a scaling coefficient. +32. `waveletTheoryEstimateScalingCoefficient(value, samples=None)` - Estimate a scaling coefficient property from finite samples or approximations. +33. `waveletTheoryApproximateScalingCoefficient(value, tolerance=1e-9)` - Approximate a scaling coefficient with explicit tolerance controls. +34. `waveletTheoryTransformScalingCoefficient(value, mapping)` - Transform a scaling coefficient through a map, operator, or representation change. +35. `waveletTheorySimplifyScalingCoefficient(value)` - Simplify a scaling coefficient without changing its mathematical meaning. +36. `waveletTheoryEnumerateScalingCoefficient(value, limit=None)` - Enumerate finite members, cases, or derived objects for a scaling coefficient. +37. `waveletTheoryClassifyScalingCoefficient(value)` - Classify a scaling coefficient by its standard Wavelet Theory invariants. +38. `waveletTheoryTestEquivalenceScalingCoefficient(left, right)` - Test whether two scaling coefficient values are equivalent in Wavelet Theory. +39. `waveletTheoryGenerateExampleScalingCoefficient(size=3)` - Generate a small documented example of a scaling coefficient. +40. `waveletTheoryDocumentScalingCoefficient(value)` - Return a structured explanation of a scaling coefficient and related assumptions. +41. `waveletTheoryValidateFilterBank(value)` - Validate the filter bank representation and domain rules for Wavelet Theory. +42. `waveletTheoryConstructFilterBank(*args)` - Construct a filter bank from explicit inputs for Wavelet Theory. +43. `waveletTheoryNormalizeFilterBank(value)` - Normalize a filter bank into the standard Wavelet Theory representation. +44. `waveletTheoryCanonicalizeFilterBank(value)` - Canonicalize a filter bank so equivalent inputs share one form. +45. `waveletTheoryParseFilterBank(text)` - Parse a text or structured value into a filter bank. +46. `waveletTheoryFormatFilterBank(value)` - Format a filter bank for deterministic user-facing output. +47. `waveletTheoryCompareFilterBank(left, right)` - Compare two filter bank values under the conventions of Wavelet Theory. +48. `waveletTheoryCombineFilterBank(left, right)` - Combine two filter bank values with the natural operation for Wavelet Theory. +49. `waveletTheoryDecomposeFilterBank(value)` - Decompose a filter bank into simpler or canonical components. +50. `waveletTheoryEvaluateFilterBank(value, point=None)` - Evaluate a filter bank at a point, sample, or finite model. +51. `waveletTheoryComputeFilterBank(value)` - Compute the central numerical or symbolic data of a filter bank. +52. `waveletTheoryEstimateFilterBank(value, samples=None)` - Estimate a filter bank property from finite samples or approximations. +53. `waveletTheoryApproximateFilterBank(value, tolerance=1e-9)` - Approximate a filter bank with explicit tolerance controls. +54. `waveletTheoryTransformFilterBank(value, mapping)` - Transform a filter bank through a map, operator, or representation change. +55. `waveletTheorySimplifyFilterBank(value)` - Simplify a filter bank without changing its mathematical meaning. +56. `waveletTheoryEnumerateFilterBank(value, limit=None)` - Enumerate finite members, cases, or derived objects for a filter bank. +57. `waveletTheoryClassifyFilterBank(value)` - Classify a filter bank by its standard Wavelet Theory invariants. +58. `waveletTheoryTestEquivalenceFilterBank(left, right)` - Test whether two filter bank values are equivalent in Wavelet Theory. +59. `waveletTheoryGenerateExampleFilterBank(size=3)` - Generate a small documented example of a filter bank. +60. `waveletTheoryDocumentFilterBank(value)` - Return a structured explanation of a filter bank and related assumptions. +61. `waveletTheoryValidateMultiresolutionLevel(value)` - Validate the multiresolution level representation and domain rules for Wavelet Theory. +62. `waveletTheoryConstructMultiresolutionLevel(*args)` - Construct a multiresolution level from explicit inputs for Wavelet Theory. +63. `waveletTheoryNormalizeMultiresolutionLevel(value)` - Normalize a multiresolution level into the standard Wavelet Theory representation. +64. `waveletTheoryCanonicalizeMultiresolutionLevel(value)` - Canonicalize a multiresolution level so equivalent inputs share one form. +65. `waveletTheoryParseMultiresolutionLevel(text)` - Parse a text or structured value into a multiresolution level. +66. `waveletTheoryFormatMultiresolutionLevel(value)` - Format a multiresolution level for deterministic user-facing output. +67. `waveletTheoryCompareMultiresolutionLevel(left, right)` - Compare two multiresolution level values under the conventions of Wavelet Theory. +68. `waveletTheoryCombineMultiresolutionLevel(left, right)` - Combine two multiresolution level values with the natural operation for Wavelet Theory. +69. `waveletTheoryDecomposeMultiresolutionLevel(value)` - Decompose a multiresolution level into simpler or canonical components. +70. `waveletTheoryEvaluateMultiresolutionLevel(value, point=None)` - Evaluate a multiresolution level at a point, sample, or finite model. +71. `waveletTheoryComputeMultiresolutionLevel(value)` - Compute the central numerical or symbolic data of a multiresolution level. +72. `waveletTheoryEstimateMultiresolutionLevel(value, samples=None)` - Estimate a multiresolution level property from finite samples or approximations. +73. `waveletTheoryApproximateMultiresolutionLevel(value, tolerance=1e-9)` - Approximate a multiresolution level with explicit tolerance controls. +74. `waveletTheoryTransformMultiresolutionLevel(value, mapping)` - Transform a multiresolution level through a map, operator, or representation change. +75. `waveletTheorySimplifyMultiresolutionLevel(value)` - Simplify a multiresolution level without changing its mathematical meaning. +76. `waveletTheoryEnumerateMultiresolutionLevel(value, limit=None)` - Enumerate finite members, cases, or derived objects for a multiresolution level. +77. `waveletTheoryClassifyMultiresolutionLevel(value)` - Classify a multiresolution level by its standard Wavelet Theory invariants. +78. `waveletTheoryTestEquivalenceMultiresolutionLevel(left, right)` - Test whether two multiresolution level values are equivalent in Wavelet Theory. +79. `waveletTheoryGenerateExampleMultiresolutionLevel(size=3)` - Generate a small documented example of a multiresolution level. +80. `waveletTheoryDocumentMultiresolutionLevel(value)` - Return a structured explanation of a multiresolution level and related assumptions. +81. `waveletTheoryValidateSignalDetail(value)` - Validate the signal detail representation and domain rules for Wavelet Theory. +82. `waveletTheoryConstructSignalDetail(*args)` - Construct a signal detail from explicit inputs for Wavelet Theory. +83. `waveletTheoryNormalizeSignalDetail(value)` - Normalize a signal detail into the standard Wavelet Theory representation. +84. `waveletTheoryCanonicalizeSignalDetail(value)` - Canonicalize a signal detail so equivalent inputs share one form. +85. `waveletTheoryParseSignalDetail(text)` - Parse a text or structured value into a signal detail. +86. `waveletTheoryFormatSignalDetail(value)` - Format a signal detail for deterministic user-facing output. +87. `waveletTheoryCompareSignalDetail(left, right)` - Compare two signal detail values under the conventions of Wavelet Theory. +88. `waveletTheoryCombineSignalDetail(left, right)` - Combine two signal detail values with the natural operation for Wavelet Theory. +89. `waveletTheoryDecomposeSignalDetail(value)` - Decompose a signal detail into simpler or canonical components. +90. `waveletTheoryEvaluateSignalDetail(value, point=None)` - Evaluate a signal detail at a point, sample, or finite model. +91. `waveletTheoryComputeSignalDetail(value)` - Compute the central numerical or symbolic data of a signal detail. +92. `waveletTheoryEstimateSignalDetail(value, samples=None)` - Estimate a signal detail property from finite samples or approximations. +93. `waveletTheoryApproximateSignalDetail(value, tolerance=1e-9)` - Approximate a signal detail with explicit tolerance controls. +94. `waveletTheoryTransformSignalDetail(value, mapping)` - Transform a signal detail through a map, operator, or representation change. +95. `waveletTheorySimplifySignalDetail(value)` - Simplify a signal detail without changing its mathematical meaning. +96. `waveletTheoryEnumerateSignalDetail(value, limit=None)` - Enumerate finite members, cases, or derived objects for a signal detail. +97. `waveletTheoryClassifySignalDetail(value)` - Classify a signal detail by its standard Wavelet Theory invariants. +98. `waveletTheoryTestEquivalenceSignalDetail(left, right)` - Test whether two signal detail values are equivalent in Wavelet Theory. +99. `waveletTheoryGenerateExampleSignalDetail(size=3)` - Generate a small documented example of a signal detail. +100. `waveletTheoryDocumentSignalDetail(value)` - Return a structured explanation of a signal detail and related assumptions. + +### Splines and Computer-Aided Geometric Design + +Core object families: + +- control point +- Bezier curve +- spline basis +- knot vector +- subdivision curve + +Candidate functions: + +1. `splinesAndComputerAidedGeometricDesignValidateControlPoint(value)` - Validate the control point representation and domain rules for Splines and Computer-Aided Geometric Design. +2. `splinesAndComputerAidedGeometricDesignConstructControlPoint(*args)` - Construct a control point from explicit inputs for Splines and Computer-Aided Geometric Design. +3. `splinesAndComputerAidedGeometricDesignNormalizeControlPoint(value)` - Normalize a control point into the standard Splines and Computer-Aided Geometric Design representation. +4. `splinesAndComputerAidedGeometricDesignCanonicalizeControlPoint(value)` - Canonicalize a control point so equivalent inputs share one form. +5. `splinesAndComputerAidedGeometricDesignParseControlPoint(text)` - Parse a text or structured value into a control point. +6. `splinesAndComputerAidedGeometricDesignFormatControlPoint(value)` - Format a control point for deterministic user-facing output. +7. `splinesAndComputerAidedGeometricDesignCompareControlPoint(left, right)` - Compare two control point values under the conventions of Splines and Computer-Aided Geometric Design. +8. `splinesAndComputerAidedGeometricDesignCombineControlPoint(left, right)` - Combine two control point values with the natural operation for Splines and Computer-Aided Geometric Design. +9. `splinesAndComputerAidedGeometricDesignDecomposeControlPoint(value)` - Decompose a control point into simpler or canonical components. +10. `splinesAndComputerAidedGeometricDesignEvaluateControlPoint(value, point=None)` - Evaluate a control point at a point, sample, or finite model. +11. `splinesAndComputerAidedGeometricDesignComputeControlPoint(value)` - Compute the central numerical or symbolic data of a control point. +12. `splinesAndComputerAidedGeometricDesignEstimateControlPoint(value, samples=None)` - Estimate a control point property from finite samples or approximations. +13. `splinesAndComputerAidedGeometricDesignApproximateControlPoint(value, tolerance=1e-9)` - Approximate a control point with explicit tolerance controls. +14. `splinesAndComputerAidedGeometricDesignTransformControlPoint(value, mapping)` - Transform a control point through a map, operator, or representation change. +15. `splinesAndComputerAidedGeometricDesignSimplifyControlPoint(value)` - Simplify a control point without changing its mathematical meaning. +16. `splinesAndComputerAidedGeometricDesignEnumerateControlPoint(value, limit=None)` - Enumerate finite members, cases, or derived objects for a control point. +17. `splinesAndComputerAidedGeometricDesignClassifyControlPoint(value)` - Classify a control point by its standard Splines and Computer-Aided Geometric Design invariants. +18. `splinesAndComputerAidedGeometricDesignTestEquivalenceControlPoint(left, right)` - Test whether two control point values are equivalent in Splines and Computer-Aided Geometric Design. +19. `splinesAndComputerAidedGeometricDesignGenerateExampleControlPoint(size=3)` - Generate a small documented example of a control point. +20. `splinesAndComputerAidedGeometricDesignDocumentControlPoint(value)` - Return a structured explanation of a control point and related assumptions. +21. `splinesAndComputerAidedGeometricDesignValidateBezierCurve(value)` - Validate the Bezier curve representation and domain rules for Splines and Computer-Aided Geometric Design. +22. `splinesAndComputerAidedGeometricDesignConstructBezierCurve(*args)` - Construct a Bezier curve from explicit inputs for Splines and Computer-Aided Geometric Design. +23. `splinesAndComputerAidedGeometricDesignNormalizeBezierCurve(value)` - Normalize a Bezier curve into the standard Splines and Computer-Aided Geometric Design representation. +24. `splinesAndComputerAidedGeometricDesignCanonicalizeBezierCurve(value)` - Canonicalize a Bezier curve so equivalent inputs share one form. +25. `splinesAndComputerAidedGeometricDesignParseBezierCurve(text)` - Parse a text or structured value into a Bezier curve. +26. `splinesAndComputerAidedGeometricDesignFormatBezierCurve(value)` - Format a Bezier curve for deterministic user-facing output. +27. `splinesAndComputerAidedGeometricDesignCompareBezierCurve(left, right)` - Compare two Bezier curve values under the conventions of Splines and Computer-Aided Geometric Design. +28. `splinesAndComputerAidedGeometricDesignCombineBezierCurve(left, right)` - Combine two Bezier curve values with the natural operation for Splines and Computer-Aided Geometric Design. +29. `splinesAndComputerAidedGeometricDesignDecomposeBezierCurve(value)` - Decompose a Bezier curve into simpler or canonical components. +30. `splinesAndComputerAidedGeometricDesignEvaluateBezierCurve(value, point=None)` - Evaluate a Bezier curve at a point, sample, or finite model. +31. `splinesAndComputerAidedGeometricDesignComputeBezierCurve(value)` - Compute the central numerical or symbolic data of a Bezier curve. +32. `splinesAndComputerAidedGeometricDesignEstimateBezierCurve(value, samples=None)` - Estimate a Bezier curve property from finite samples or approximations. +33. `splinesAndComputerAidedGeometricDesignApproximateBezierCurve(value, tolerance=1e-9)` - Approximate a Bezier curve with explicit tolerance controls. +34. `splinesAndComputerAidedGeometricDesignTransformBezierCurve(value, mapping)` - Transform a Bezier curve through a map, operator, or representation change. +35. `splinesAndComputerAidedGeometricDesignSimplifyBezierCurve(value)` - Simplify a Bezier curve without changing its mathematical meaning. +36. `splinesAndComputerAidedGeometricDesignEnumerateBezierCurve(value, limit=None)` - Enumerate finite members, cases, or derived objects for a Bezier curve. +37. `splinesAndComputerAidedGeometricDesignClassifyBezierCurve(value)` - Classify a Bezier curve by its standard Splines and Computer-Aided Geometric Design invariants. +38. `splinesAndComputerAidedGeometricDesignTestEquivalenceBezierCurve(left, right)` - Test whether two Bezier curve values are equivalent in Splines and Computer-Aided Geometric Design. +39. `splinesAndComputerAidedGeometricDesignGenerateExampleBezierCurve(size=3)` - Generate a small documented example of a Bezier curve. +40. `splinesAndComputerAidedGeometricDesignDocumentBezierCurve(value)` - Return a structured explanation of a Bezier curve and related assumptions. +41. `splinesAndComputerAidedGeometricDesignValidateSplineBasis(value)` - Validate the spline basis representation and domain rules for Splines and Computer-Aided Geometric Design. +42. `splinesAndComputerAidedGeometricDesignConstructSplineBasis(*args)` - Construct a spline basis from explicit inputs for Splines and Computer-Aided Geometric Design. +43. `splinesAndComputerAidedGeometricDesignNormalizeSplineBasis(value)` - Normalize a spline basis into the standard Splines and Computer-Aided Geometric Design representation. +44. `splinesAndComputerAidedGeometricDesignCanonicalizeSplineBasis(value)` - Canonicalize a spline basis so equivalent inputs share one form. +45. `splinesAndComputerAidedGeometricDesignParseSplineBasis(text)` - Parse a text or structured value into a spline basis. +46. `splinesAndComputerAidedGeometricDesignFormatSplineBasis(value)` - Format a spline basis for deterministic user-facing output. +47. `splinesAndComputerAidedGeometricDesignCompareSplineBasis(left, right)` - Compare two spline basis values under the conventions of Splines and Computer-Aided Geometric Design. +48. `splinesAndComputerAidedGeometricDesignCombineSplineBasis(left, right)` - Combine two spline basis values with the natural operation for Splines and Computer-Aided Geometric Design. +49. `splinesAndComputerAidedGeometricDesignDecomposeSplineBasis(value)` - Decompose a spline basis into simpler or canonical components. +50. `splinesAndComputerAidedGeometricDesignEvaluateSplineBasis(value, point=None)` - Evaluate a spline basis at a point, sample, or finite model. +51. `splinesAndComputerAidedGeometricDesignComputeSplineBasis(value)` - Compute the central numerical or symbolic data of a spline basis. +52. `splinesAndComputerAidedGeometricDesignEstimateSplineBasis(value, samples=None)` - Estimate a spline basis property from finite samples or approximations. +53. `splinesAndComputerAidedGeometricDesignApproximateSplineBasis(value, tolerance=1e-9)` - Approximate a spline basis with explicit tolerance controls. +54. `splinesAndComputerAidedGeometricDesignTransformSplineBasis(value, mapping)` - Transform a spline basis through a map, operator, or representation change. +55. `splinesAndComputerAidedGeometricDesignSimplifySplineBasis(value)` - Simplify a spline basis without changing its mathematical meaning. +56. `splinesAndComputerAidedGeometricDesignEnumerateSplineBasis(value, limit=None)` - Enumerate finite members, cases, or derived objects for a spline basis. +57. `splinesAndComputerAidedGeometricDesignClassifySplineBasis(value)` - Classify a spline basis by its standard Splines and Computer-Aided Geometric Design invariants. +58. `splinesAndComputerAidedGeometricDesignTestEquivalenceSplineBasis(left, right)` - Test whether two spline basis values are equivalent in Splines and Computer-Aided Geometric Design. +59. `splinesAndComputerAidedGeometricDesignGenerateExampleSplineBasis(size=3)` - Generate a small documented example of a spline basis. +60. `splinesAndComputerAidedGeometricDesignDocumentSplineBasis(value)` - Return a structured explanation of a spline basis and related assumptions. +61. `splinesAndComputerAidedGeometricDesignValidateKnotVector(value)` - Validate the knot vector representation and domain rules for Splines and Computer-Aided Geometric Design. +62. `splinesAndComputerAidedGeometricDesignConstructKnotVector(*args)` - Construct a knot vector from explicit inputs for Splines and Computer-Aided Geometric Design. +63. `splinesAndComputerAidedGeometricDesignNormalizeKnotVector(value)` - Normalize a knot vector into the standard Splines and Computer-Aided Geometric Design representation. +64. `splinesAndComputerAidedGeometricDesignCanonicalizeKnotVector(value)` - Canonicalize a knot vector so equivalent inputs share one form. +65. `splinesAndComputerAidedGeometricDesignParseKnotVector(text)` - Parse a text or structured value into a knot vector. +66. `splinesAndComputerAidedGeometricDesignFormatKnotVector(value)` - Format a knot vector for deterministic user-facing output. +67. `splinesAndComputerAidedGeometricDesignCompareKnotVector(left, right)` - Compare two knot vector values under the conventions of Splines and Computer-Aided Geometric Design. +68. `splinesAndComputerAidedGeometricDesignCombineKnotVector(left, right)` - Combine two knot vector values with the natural operation for Splines and Computer-Aided Geometric Design. +69. `splinesAndComputerAidedGeometricDesignDecomposeKnotVector(value)` - Decompose a knot vector into simpler or canonical components. +70. `splinesAndComputerAidedGeometricDesignEvaluateKnotVector(value, point=None)` - Evaluate a knot vector at a point, sample, or finite model. +71. `splinesAndComputerAidedGeometricDesignComputeKnotVector(value)` - Compute the central numerical or symbolic data of a knot vector. +72. `splinesAndComputerAidedGeometricDesignEstimateKnotVector(value, samples=None)` - Estimate a knot vector property from finite samples or approximations. +73. `splinesAndComputerAidedGeometricDesignApproximateKnotVector(value, tolerance=1e-9)` - Approximate a knot vector with explicit tolerance controls. +74. `splinesAndComputerAidedGeometricDesignTransformKnotVector(value, mapping)` - Transform a knot vector through a map, operator, or representation change. +75. `splinesAndComputerAidedGeometricDesignSimplifyKnotVector(value)` - Simplify a knot vector without changing its mathematical meaning. +76. `splinesAndComputerAidedGeometricDesignEnumerateKnotVector(value, limit=None)` - Enumerate finite members, cases, or derived objects for a knot vector. +77. `splinesAndComputerAidedGeometricDesignClassifyKnotVector(value)` - Classify a knot vector by its standard Splines and Computer-Aided Geometric Design invariants. +78. `splinesAndComputerAidedGeometricDesignTestEquivalenceKnotVector(left, right)` - Test whether two knot vector values are equivalent in Splines and Computer-Aided Geometric Design. +79. `splinesAndComputerAidedGeometricDesignGenerateExampleKnotVector(size=3)` - Generate a small documented example of a knot vector. +80. `splinesAndComputerAidedGeometricDesignDocumentKnotVector(value)` - Return a structured explanation of a knot vector and related assumptions. +81. `splinesAndComputerAidedGeometricDesignValidateSubdivisionCurve(value)` - Validate the subdivision curve representation and domain rules for Splines and Computer-Aided Geometric Design. +82. `splinesAndComputerAidedGeometricDesignConstructSubdivisionCurve(*args)` - Construct a subdivision curve from explicit inputs for Splines and Computer-Aided Geometric Design. +83. `splinesAndComputerAidedGeometricDesignNormalizeSubdivisionCurve(value)` - Normalize a subdivision curve into the standard Splines and Computer-Aided Geometric Design representation. +84. `splinesAndComputerAidedGeometricDesignCanonicalizeSubdivisionCurve(value)` - Canonicalize a subdivision curve so equivalent inputs share one form. +85. `splinesAndComputerAidedGeometricDesignParseSubdivisionCurve(text)` - Parse a text or structured value into a subdivision curve. +86. `splinesAndComputerAidedGeometricDesignFormatSubdivisionCurve(value)` - Format a subdivision curve for deterministic user-facing output. +87. `splinesAndComputerAidedGeometricDesignCompareSubdivisionCurve(left, right)` - Compare two subdivision curve values under the conventions of Splines and Computer-Aided Geometric Design. +88. `splinesAndComputerAidedGeometricDesignCombineSubdivisionCurve(left, right)` - Combine two subdivision curve values with the natural operation for Splines and Computer-Aided Geometric Design. +89. `splinesAndComputerAidedGeometricDesignDecomposeSubdivisionCurve(value)` - Decompose a subdivision curve into simpler or canonical components. +90. `splinesAndComputerAidedGeometricDesignEvaluateSubdivisionCurve(value, point=None)` - Evaluate a subdivision curve at a point, sample, or finite model. +91. `splinesAndComputerAidedGeometricDesignComputeSubdivisionCurve(value)` - Compute the central numerical or symbolic data of a subdivision curve. +92. `splinesAndComputerAidedGeometricDesignEstimateSubdivisionCurve(value, samples=None)` - Estimate a subdivision curve property from finite samples or approximations. +93. `splinesAndComputerAidedGeometricDesignApproximateSubdivisionCurve(value, tolerance=1e-9)` - Approximate a subdivision curve with explicit tolerance controls. +94. `splinesAndComputerAidedGeometricDesignTransformSubdivisionCurve(value, mapping)` - Transform a subdivision curve through a map, operator, or representation change. +95. `splinesAndComputerAidedGeometricDesignSimplifySubdivisionCurve(value)` - Simplify a subdivision curve without changing its mathematical meaning. +96. `splinesAndComputerAidedGeometricDesignEnumerateSubdivisionCurve(value, limit=None)` - Enumerate finite members, cases, or derived objects for a subdivision curve. +97. `splinesAndComputerAidedGeometricDesignClassifySubdivisionCurve(value)` - Classify a subdivision curve by its standard Splines and Computer-Aided Geometric Design invariants. +98. `splinesAndComputerAidedGeometricDesignTestEquivalenceSubdivisionCurve(left, right)` - Test whether two subdivision curve values are equivalent in Splines and Computer-Aided Geometric Design. +99. `splinesAndComputerAidedGeometricDesignGenerateExampleSubdivisionCurve(size=3)` - Generate a small documented example of a subdivision curve. +100. `splinesAndComputerAidedGeometricDesignDocumentSubdivisionCurve(value)` - Return a structured explanation of a subdivision curve and related assumptions. + +### Matroid Theory + +Core object families: + +- ground set +- independent set +- basis +- circuit +- rank function + +Candidate functions: + +1. `matroidTheoryValidateGroundSet(value)` - Validate the ground set representation and domain rules for Matroid Theory. +2. `matroidTheoryConstructGroundSet(*args)` - Construct a ground set from explicit inputs for Matroid Theory. +3. `matroidTheoryNormalizeGroundSet(value)` - Normalize a ground set into the standard Matroid Theory representation. +4. `matroidTheoryCanonicalizeGroundSet(value)` - Canonicalize a ground set so equivalent inputs share one form. +5. `matroidTheoryParseGroundSet(text)` - Parse a text or structured value into a ground set. +6. `matroidTheoryFormatGroundSet(value)` - Format a ground set for deterministic user-facing output. +7. `matroidTheoryCompareGroundSet(left, right)` - Compare two ground set values under the conventions of Matroid Theory. +8. `matroidTheoryCombineGroundSet(left, right)` - Combine two ground set values with the natural operation for Matroid Theory. +9. `matroidTheoryDecomposeGroundSet(value)` - Decompose a ground set into simpler or canonical components. +10. `matroidTheoryEvaluateGroundSet(value, point=None)` - Evaluate a ground set at a point, sample, or finite model. +11. `matroidTheoryComputeGroundSet(value)` - Compute the central numerical or symbolic data of a ground set. +12. `matroidTheoryEstimateGroundSet(value, samples=None)` - Estimate a ground set property from finite samples or approximations. +13. `matroidTheoryApproximateGroundSet(value, tolerance=1e-9)` - Approximate a ground set with explicit tolerance controls. +14. `matroidTheoryTransformGroundSet(value, mapping)` - Transform a ground set through a map, operator, or representation change. +15. `matroidTheorySimplifyGroundSet(value)` - Simplify a ground set without changing its mathematical meaning. +16. `matroidTheoryEnumerateGroundSet(value, limit=None)` - Enumerate finite members, cases, or derived objects for a ground set. +17. `matroidTheoryClassifyGroundSet(value)` - Classify a ground set by its standard Matroid Theory invariants. +18. `matroidTheoryTestEquivalenceGroundSet(left, right)` - Test whether two ground set values are equivalent in Matroid Theory. +19. `matroidTheoryGenerateExampleGroundSet(size=3)` - Generate a small documented example of a ground set. +20. `matroidTheoryDocumentGroundSet(value)` - Return a structured explanation of a ground set and related assumptions. +21. `matroidTheoryValidateIndependentSet(value)` - Validate the independent set representation and domain rules for Matroid Theory. +22. `matroidTheoryConstructIndependentSet(*args)` - Construct a independent set from explicit inputs for Matroid Theory. +23. `matroidTheoryNormalizeIndependentSet(value)` - Normalize a independent set into the standard Matroid Theory representation. +24. `matroidTheoryCanonicalizeIndependentSet(value)` - Canonicalize a independent set so equivalent inputs share one form. +25. `matroidTheoryParseIndependentSet(text)` - Parse a text or structured value into a independent set. +26. `matroidTheoryFormatIndependentSet(value)` - Format a independent set for deterministic user-facing output. +27. `matroidTheoryCompareIndependentSet(left, right)` - Compare two independent set values under the conventions of Matroid Theory. +28. `matroidTheoryCombineIndependentSet(left, right)` - Combine two independent set values with the natural operation for Matroid Theory. +29. `matroidTheoryDecomposeIndependentSet(value)` - Decompose a independent set into simpler or canonical components. +30. `matroidTheoryEvaluateIndependentSet(value, point=None)` - Evaluate a independent set at a point, sample, or finite model. +31. `matroidTheoryComputeIndependentSet(value)` - Compute the central numerical or symbolic data of a independent set. +32. `matroidTheoryEstimateIndependentSet(value, samples=None)` - Estimate a independent set property from finite samples or approximations. +33. `matroidTheoryApproximateIndependentSet(value, tolerance=1e-9)` - Approximate a independent set with explicit tolerance controls. +34. `matroidTheoryTransformIndependentSet(value, mapping)` - Transform a independent set through a map, operator, or representation change. +35. `matroidTheorySimplifyIndependentSet(value)` - Simplify a independent set without changing its mathematical meaning. +36. `matroidTheoryEnumerateIndependentSet(value, limit=None)` - Enumerate finite members, cases, or derived objects for a independent set. +37. `matroidTheoryClassifyIndependentSet(value)` - Classify a independent set by its standard Matroid Theory invariants. +38. `matroidTheoryTestEquivalenceIndependentSet(left, right)` - Test whether two independent set values are equivalent in Matroid Theory. +39. `matroidTheoryGenerateExampleIndependentSet(size=3)` - Generate a small documented example of a independent set. +40. `matroidTheoryDocumentIndependentSet(value)` - Return a structured explanation of a independent set and related assumptions. +41. `matroidTheoryValidateBasis(value)` - Validate the basis representation and domain rules for Matroid Theory. +42. `matroidTheoryConstructBasis(*args)` - Construct a basis from explicit inputs for Matroid Theory. +43. `matroidTheoryNormalizeBasis(value)` - Normalize a basis into the standard Matroid Theory representation. +44. `matroidTheoryCanonicalizeBasis(value)` - Canonicalize a basis so equivalent inputs share one form. +45. `matroidTheoryParseBasis(text)` - Parse a text or structured value into a basis. +46. `matroidTheoryFormatBasis(value)` - Format a basis for deterministic user-facing output. +47. `matroidTheoryCompareBasis(left, right)` - Compare two basis values under the conventions of Matroid Theory. +48. `matroidTheoryCombineBasis(left, right)` - Combine two basis values with the natural operation for Matroid Theory. +49. `matroidTheoryDecomposeBasis(value)` - Decompose a basis into simpler or canonical components. +50. `matroidTheoryEvaluateBasis(value, point=None)` - Evaluate a basis at a point, sample, or finite model. +51. `matroidTheoryComputeBasis(value)` - Compute the central numerical or symbolic data of a basis. +52. `matroidTheoryEstimateBasis(value, samples=None)` - Estimate a basis property from finite samples or approximations. +53. `matroidTheoryApproximateBasis(value, tolerance=1e-9)` - Approximate a basis with explicit tolerance controls. +54. `matroidTheoryTransformBasis(value, mapping)` - Transform a basis through a map, operator, or representation change. +55. `matroidTheorySimplifyBasis(value)` - Simplify a basis without changing its mathematical meaning. +56. `matroidTheoryEnumerateBasis(value, limit=None)` - Enumerate finite members, cases, or derived objects for a basis. +57. `matroidTheoryClassifyBasis(value)` - Classify a basis by its standard Matroid Theory invariants. +58. `matroidTheoryTestEquivalenceBasis(left, right)` - Test whether two basis values are equivalent in Matroid Theory. +59. `matroidTheoryGenerateExampleBasis(size=3)` - Generate a small documented example of a basis. +60. `matroidTheoryDocumentBasis(value)` - Return a structured explanation of a basis and related assumptions. +61. `matroidTheoryValidateCircuit(value)` - Validate the circuit representation and domain rules for Matroid Theory. +62. `matroidTheoryConstructCircuit(*args)` - Construct a circuit from explicit inputs for Matroid Theory. +63. `matroidTheoryNormalizeCircuit(value)` - Normalize a circuit into the standard Matroid Theory representation. +64. `matroidTheoryCanonicalizeCircuit(value)` - Canonicalize a circuit so equivalent inputs share one form. +65. `matroidTheoryParseCircuit(text)` - Parse a text or structured value into a circuit. +66. `matroidTheoryFormatCircuit(value)` - Format a circuit for deterministic user-facing output. +67. `matroidTheoryCompareCircuit(left, right)` - Compare two circuit values under the conventions of Matroid Theory. +68. `matroidTheoryCombineCircuit(left, right)` - Combine two circuit values with the natural operation for Matroid Theory. +69. `matroidTheoryDecomposeCircuit(value)` - Decompose a circuit into simpler or canonical components. +70. `matroidTheoryEvaluateCircuit(value, point=None)` - Evaluate a circuit at a point, sample, or finite model. +71. `matroidTheoryComputeCircuit(value)` - Compute the central numerical or symbolic data of a circuit. +72. `matroidTheoryEstimateCircuit(value, samples=None)` - Estimate a circuit property from finite samples or approximations. +73. `matroidTheoryApproximateCircuit(value, tolerance=1e-9)` - Approximate a circuit with explicit tolerance controls. +74. `matroidTheoryTransformCircuit(value, mapping)` - Transform a circuit through a map, operator, or representation change. +75. `matroidTheorySimplifyCircuit(value)` - Simplify a circuit without changing its mathematical meaning. +76. `matroidTheoryEnumerateCircuit(value, limit=None)` - Enumerate finite members, cases, or derived objects for a circuit. +77. `matroidTheoryClassifyCircuit(value)` - Classify a circuit by its standard Matroid Theory invariants. +78. `matroidTheoryTestEquivalenceCircuit(left, right)` - Test whether two circuit values are equivalent in Matroid Theory. +79. `matroidTheoryGenerateExampleCircuit(size=3)` - Generate a small documented example of a circuit. +80. `matroidTheoryDocumentCircuit(value)` - Return a structured explanation of a circuit and related assumptions. +81. `matroidTheoryValidateRankFunction(value)` - Validate the rank function representation and domain rules for Matroid Theory. +82. `matroidTheoryConstructRankFunction(*args)` - Construct a rank function from explicit inputs for Matroid Theory. +83. `matroidTheoryNormalizeRankFunction(value)` - Normalize a rank function into the standard Matroid Theory representation. +84. `matroidTheoryCanonicalizeRankFunction(value)` - Canonicalize a rank function so equivalent inputs share one form. +85. `matroidTheoryParseRankFunction(text)` - Parse a text or structured value into a rank function. +86. `matroidTheoryFormatRankFunction(value)` - Format a rank function for deterministic user-facing output. +87. `matroidTheoryCompareRankFunction(left, right)` - Compare two rank function values under the conventions of Matroid Theory. +88. `matroidTheoryCombineRankFunction(left, right)` - Combine two rank function values with the natural operation for Matroid Theory. +89. `matroidTheoryDecomposeRankFunction(value)` - Decompose a rank function into simpler or canonical components. +90. `matroidTheoryEvaluateRankFunction(value, point=None)` - Evaluate a rank function at a point, sample, or finite model. +91. `matroidTheoryComputeRankFunction(value)` - Compute the central numerical or symbolic data of a rank function. +92. `matroidTheoryEstimateRankFunction(value, samples=None)` - Estimate a rank function property from finite samples or approximations. +93. `matroidTheoryApproximateRankFunction(value, tolerance=1e-9)` - Approximate a rank function with explicit tolerance controls. +94. `matroidTheoryTransformRankFunction(value, mapping)` - Transform a rank function through a map, operator, or representation change. +95. `matroidTheorySimplifyRankFunction(value)` - Simplify a rank function without changing its mathematical meaning. +96. `matroidTheoryEnumerateRankFunction(value, limit=None)` - Enumerate finite members, cases, or derived objects for a rank function. +97. `matroidTheoryClassifyRankFunction(value)` - Classify a rank function by its standard Matroid Theory invariants. +98. `matroidTheoryTestEquivalenceRankFunction(left, right)` - Test whether two rank function values are equivalent in Matroid Theory. +99. `matroidTheoryGenerateExampleRankFunction(size=3)` - Generate a small documented example of a rank function. +100. `matroidTheoryDocumentRankFunction(value)` - Return a structured explanation of a rank function and related assumptions. diff --git a/test_gap_functions.py b/test_gap_functions.py new file mode 100644 index 0000000..fe97d03 --- /dev/null +++ b/test_gap_functions.py @@ -0,0 +1,100 @@ +import unittest + +from mathfunctionize import mathfunctionize, upcoming + + +class TestStatisticsGapFunctions(unittest.TestCase): + def test_variance_and_sample_statistics(self): + values = [2, 4, 4, 4, 5, 5, 7, 9] + + self.assertEqual(mathfunctionize.variance(values), 4) + self.assertEqual(mathfunctionize.standardDeviation(values), 2) + self.assertAlmostEqual(mathfunctionize.sampleVariance(values), 32 / 7) + self.assertAlmostEqual(mathfunctionize.sampleStandardDeviation(values), (32 / 7) ** 0.5) + + def test_quartiles_percentile_and_correlation(self): + values = [7, 1, 3, 5, 9] + + self.assertEqual(mathfunctionize.quartiles(values), [2.0, 5, 8.0]) + self.assertEqual(mathfunctionize.interquartileRange(values), 6.0) + self.assertEqual(mathfunctionize.percentile([0, 10], 25), 2.5) + self.assertEqual(mathfunctionize.zScore(14, 10, 2), 2) + self.assertEqual(mathfunctionize.covariance([1, 2, 3], [2, 4, 6]), 4 / 3) + self.assertAlmostEqual(mathfunctionize.correlation([1, 2, 3], [2, 4, 6]), 1) + + +class TestProbabilityGapFunctions(unittest.TestCase): + def test_distribution_helpers(self): + self.assertEqual(mathfunctionize.bernoulliPMF(1, 0.25), 0.25) + self.assertAlmostEqual(mathfunctionize.binomialPMF(2, 4, 0.5), 0.375) + self.assertAlmostEqual(mathfunctionize.binomialCDF(1, 3, 0.5), 0.5) + self.assertAlmostEqual(mathfunctionize.poissonPMF(2, 3), 0.22404180765538775) + self.assertAlmostEqual(mathfunctionize.exponentialCDF(1, 2), 1 - (mathfunctionize.e ** -2)) + self.assertAlmostEqual(mathfunctionize.gammaPDF(2, 3, 2), 0.29305022221974686) + + def test_probability_summary_helpers(self): + self.assertEqual(mathfunctionize.expectedValue([1, 2, 3], [0.2, 0.3, 0.5]), 2.3) + self.assertEqual(mathfunctionize.conditionalProbability(0.2, 0.4), 0.5) + self.assertTrue(mathfunctionize.independent(0.5, 0.5, 0.25)) + + +class TestComplexGapFunctions(unittest.TestCase): + def test_complex_arithmetic_and_polar_forms(self): + self.assertEqual(mathfunctionize.parseComplex("3-4i"), [3.0, -4.0]) + self.assertEqual(mathfunctionize.formatComplex(3, -4), "3-4i") + self.assertEqual(mathfunctionize.complex_addition("3+4i", "2-1i"), "5+3i") + self.assertEqual(mathfunctionize.complex_subtraction("3+4i", "2-1i"), "1+5i") + self.assertEqual(mathfunctionize.complex_multiplication("3+4i", "2-1i"), "10+5i") + self.assertEqual(mathfunctionize.complex_division("3+4i", "1-2i"), "-1+2i") + self.assertEqual(mathfunctionize.complex_modulus("3+4i"), 5) + self.assertEqual(mathfunctionize.rectangularToPolar("1+0i")[0], 1) + self.assertEqual(mathfunctionize.polarToRectangular(1, 0), "1+0i") + + +class TestNumberTheoryGapFunctions(unittest.TestCase): + def test_number_theory_basics(self): + self.assertEqual(mathfunctionize.gcd(54, 24), 6) + self.assertEqual(mathfunctionize.lcm(6, 8), 24) + self.assertEqual(mathfunctionize.extendedGcd(240, 46), [2, -9, 47]) + self.assertEqual(mathfunctionize.modularExponent(2, 10, 1000), 24) + self.assertEqual(mathfunctionize.modInverse(3, 11), 4) + self.assertEqual(mathfunctionize.primeFactors(84), [2, 2, 3, 7]) + self.assertEqual(mathfunctionize.sieve(10), [2, 3, 5, 7]) + self.assertEqual(mathfunctionize.eulerTotient(9), 6) + self.assertTrue(mathfunctionize.isCoprime(14, 15)) + self.assertEqual(mathfunctionize.divisors(12), [1, 2, 3, 4, 6, 12]) + self.assertTrue(mathfunctionize.isPerfectNumber(28)) + + +class TestLinearAlgebraGapFunctions(unittest.TestCase): + def test_matrix_and_vector_helpers(self): + matrix = [[4, 7], [2, 6]] + + self.assertEqual(mathfunctionize.identityMatrix(3), [[1, 0, 0], [0, 1, 0], [0, 0, 1]]) + self.assertEqual(mathfunctionize.trace(matrix), 10) + self.assertEqual(mathfunctionize.matrixMinor(matrix, 0, 0), [[6]]) + self.assertEqual(mathfunctionize.cofactorMatrix(matrix), [[6, -2], [-7, 4]]) + self.assertEqual(mathfunctionize.inverseMatrix(matrix), [[0.6, -0.7], [-0.2, 0.4]]) + self.assertEqual(mathfunctionize.rank([[1, 2], [2, 4]]), 1) + self.assertEqual(mathfunctionize.dotProduct([1, 2, 3], [4, 5, 6]), 32) + self.assertEqual(mathfunctionize.crossProduct([1, 0, 0], [0, 1, 0]), [0, 0, 1]) + self.assertEqual(mathfunctionize.vectorNorm([3, 4]), 5) + + +class TestGapFunctionsReplacePlaceholders(unittest.TestCase): + def test_implemented_gap_functions_do_not_raise_upcoming_placeholder(self): + implemented_names = [ + "gcd", + "quartiles", + "complex_multiplication", + "identityMatrix", + "binomialPMF", + ] + + for name in implemented_names: + self.assertTrue(upcoming.is_upcoming_function(name)) + self.assertNotIn("planned mathfunctionize API", getattr(mathfunctionize, name).__doc__ or "") + + +if __name__ == "__main__": + unittest.main() diff --git a/test_upcoming.py b/test_upcoming.py new file mode 100644 index 0000000..0d7b06b --- /dev/null +++ b/test_upcoming.py @@ -0,0 +1,49 @@ +import unittest + +from mathfunctionize import mathfunctionize, upcoming + + +class TestUpcomingRoadmapCode(unittest.TestCase): + def test_professional_catalog_counts_are_in_code(self): + catalog_entries = [ + entry + for entry in upcoming.UPCOMING_FUNCTION_ENTRIES + if entry.source == "professional_function_catalog.md" + ] + catalog_topics = {} + for entry in catalog_entries: + catalog_topics.setdefault(entry.topic, set()).add(entry.name) + + self.assertEqual(len(catalog_topics), 86) + self.assertEqual(len(catalog_entries), 8600) + self.assertTrue(all(len(names) == 100 for names in catalog_topics.values())) + + def test_upcoming_md_function_mentions_are_in_code(self): + self.assertTrue(upcoming.is_upcoming_function("sinh")) + self.assertTrue(hasattr(mathfunctionize, "sinh")) + with self.assertRaises(upcoming.UpcomingFunctionNotImplemented): + mathfunctionize.sinh(1) + + def test_implemented_upcoming_function_runs_real_code(self): + self.assertTrue(upcoming.is_upcoming_function("gcd")) + self.assertEqual(mathfunctionize.gcd(12, 8), 4) + + def test_professional_catalog_function_is_callable_placeholder(self): + name = "measureTheoryValidateSigmaAlgebra" + self.assertTrue(upcoming.is_upcoming_function(name)) + self.assertIn(name, upcoming.list_upcoming_functions("Measure Theory")) + self.assertTrue(hasattr(mathfunctionize, name)) + + with self.assertRaises(upcoming.UpcomingFunctionNotImplemented): + getattr(mathfunctionize, name)([]) + + def test_existing_functions_are_not_overwritten(self): + self.assertEqual(mathfunctionize.addition([1, 2, 3]), 6) + self.assertNotIsInstance( + mathfunctionize.addition, + upcoming.UpcomingFunctionNotImplemented, + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/upcoming.md b/upcoming.md index b2a59e8..1d64e5c 100644 --- a/upcoming.md +++ b/upcoming.md @@ -1,10 +1,2528 @@ -# List of upcoming functions to be added +# mathfunctionize research and implementation roadmap --- +This roadmap expands the original list of upcoming functions into a practical +research plan for growing `mathfunctionize`. The goal is to deepen the topics +already present in the library before adding too many new domains, while still +preserving the long-term direction toward advanced fields of mathematics. + +For a professional-scale backlog with at least 100 candidate functions for every +roadmap topic, see [professional_function_catalog.md](professional_function_catalog.md). + +## Roadmap principles + +- Keep the library pure Python and dependency-free unless a future change makes + a dependency clearly necessary. +- Prefer small, understandable functions that match the current public API. +- Add tests alongside each new function group, especially for numeric edge cases. +- Fix correctness issues in existing functions before building more behavior on + top of them. +- Document expected input formats clearly, especially for complex numbers, + matrices, sets, and callable functions. + +## Priority tiers + +### Tier 1: deepen existing shipped areas + +These topics already exist in the README and should be made more complete first. + +1. Statistics: fix `variance`, ship quartiles and interquartile range, add + sample statistics. +2. Number theory: expand beyond `isPrime`. +3. Complex numbers: support multiplication, division, modulus, argument, and + polar form. +4. Probability: test the existing functions and review `gammaPDF`. +5. Linear algebra: add matrix inverse, rank, trace, and systems of equations. + +### Tier 2: make the original future topics concrete + +These were listed in the original `upcoming.md` but need detailed function +plans. + +1. Real analysis +2. Type theory +3. Homotopy theory +4. Knot theory + +### Tier 3: add new research areas + +These domains fit the current mission of an advanced math function library. + +1. Abstract algebra +2. Graph theory and discrete math +3. Numerical analysis +4. Ordinary differential equations +5. Multivariable and vector calculus +6. Combinatorics +7. Geometry +8. Mathematical logic +9. Optimization +10. Information theory +11. Category theory +12. Game theory +13. Fourier analysis +14. Dynamical systems + +--- + +# Existing topic expansion plan + +## Constants + +Current coverage: + +- `pi` +- `e` + +Missing depth: + +- More named constants that are common across algebra, analysis, geometry, and + number theory. +- Helper functions for comparing floating point values. + +Candidate additions: + +- `tau`: `2 * pi` +- `phi`: golden ratio +- `sqrt2`: square root of 2 +- `ln2`: natural logarithm of 2 approximation +- `eulerMascheroni`: Euler-Mascheroni constant approximation +- `approxEqual(a, b, tolerance=1e-9)`: compare numerical results safely + +Test notes: + +- Verify approximate constants with tolerance-based assertions. +- Keep constant names stable and document precision. + +## Arithmetic + +Current coverage: + +- `addition`, `subtraction`, `multiplication`, `division` +- `power`, `modulo`, `flatDivision` + +Missing depth: + +- Identity behavior for empty arrays is not defined. +- Division by zero behavior is not documented. +- Common helpers such as sign, reciprocal, and absolute differences are absent. + +Candidate additions: + +- `summation(arr)`: alias or clearer equivalent for `addition` +- `product(arr)`: alias or clearer equivalent for `multiplication` +- `reciprocal(x)`: return `1 / x` +- `sign(x)`: return `-1`, `0`, or `1` +- `averageRateOfChange(f, a, b)`: useful bridge into calculus +- `clamp(x, lower, upper)`: bound a value to an interval + +Test notes: + +- Add zero-division tests. +- Add negative number and decimal tests. +- Decide whether aliases should be documented as first-class functions. + +## Algebra + +Current coverage: + +- `gamma`, `factorial`, `absolute` +- `squareRoot`, `cubeRoot`, `nthRoot` +- `round` + +Missing depth: + +- `gamma` handles only a narrow recursive subset. +- Roots do not define behavior for negative inputs and even roots. +- There are no logarithm, exponential, polynomial helper, or equation-solving + utilities here. + +Candidate additions: + +- `log(x, base=e)`: logarithm with configurable base +- `ln(x)`: natural logarithm +- `exp(x)`: exponential function +- `quadraticFormula(a, b, c)`: solve quadratic equations +- `linearEquation(a, b)`: solve `ax + b = 0` +- `isPerfectSquare(n)`: useful in algebra and number theory +- `simplifyRadical(n)`: return outside and inside radical factors +- `fallingFactorial(x, n)` and `risingFactorial(x, n)` + +Test notes: + +- Test integer, fractional, and invalid inputs. +- Compare logarithm and exponential approximations with known values. + +## Counting + +Current coverage: + +- `combinations` +- `permutations` +- `circularPermutations` +- `derangements` + +Missing depth: + +- Counting lacks combinations with repetition and partition-style functions. +- No direct support for binomial coefficients as a named function. + +Candidate additions: + +- `binomialCoefficient(n, k)` +- `multisetCombinations(n, k)`: combinations with repetition +- `stirlingSecondKind(n, k)` +- `bellNumber(n)` +- `integerPartitions(n)` +- `inclusionExclusion(sizes, intersections)`: simplified helper +- `catalanNumber(n)` + +Test notes: + +- Add boundary tests for `n = 0`, `k = 0`, and `k > n`. +- Verify identities such as symmetry of binomial coefficients. + +## Probability + +Current coverage: + +- `bayes_theorem` +- `uniformPDF`, `uniformCDF` +- `normalPDF`, `normalCDF` +- `gammaPDF` + +Missing depth: + +- Distribution functions are not tested. +- `gammaPDF` should be reviewed for formula correctness. +- Discrete distributions are absent. +- Expected value and variance helpers for distributions are absent. + +Candidate additions: + +- `bernoulliPMF(x, p)` +- `binomialPMF(k, n, p)` and `binomialCDF(k, n, p)` +- `poissonPMF(k, lam)` and `poissonCDF(k, lam)` +- `exponentialPDF(x, lam)` and `exponentialCDF(x, lam)` +- `gammaCDF(x, a, b)` using a numerical approximation +- `expectedValue(values, probabilities)` +- `conditionalProbability(pAB, pB)` +- `independent(pA, pB, pAB, tolerance=1e-9)` + +Test notes: + +- Add probability mass sums for discrete distributions. +- Test CDF monotonicity. +- Validate parameter errors, such as negative standard deviation or invalid + probabilities. + +## Complex Numbers + +Current coverage: + +- `complex_addition` +- `complex_subtraction` + +Missing depth: + +- Complex numbers are represented as strings but parsing is repeated inside each + function. +- Multiplication and division are absent. +- Polar form is absent. + +Candidate additions: + +- `parseComplex(z)`: convert strings like `"3+4i"` into real and imaginary + parts. +- `formatComplex(real, imaginary)`: standardize string output. +- `complex_multiplication(a, b)` +- `complex_division(a, b)` +- `complex_modulus(z)` +- `complex_argument(z)` +- `complex_conjugate(z)`: alias or shared implementation with `conjugate` +- `rectangularToPolar(z)` +- `polarToRectangular(r, theta)` +- `complex_power(z, n)` + +Test notes: + +- Test `a+bi`, `a-bi`, pure real, and pure imaginary inputs. +- Test division by zero. +- Keep output formatting consistent. + +## Trigonometry + +Current coverage: + +- `sin` / `sine`, `cos` / `cosine`, `tan` / `tangent` +- `csc` / `cosecant`, `sec` / `secant`, `cot` / `cotangent` +- Inverse trigonometric functions +- Degree/radian conversion + +Missing depth: + +- No dedicated trigonometry tests. +- Hyperbolic functions are absent. +- Angle normalization behavior should be documented. + +Candidate additions: + +- `sinh(x)`, `cosh(x)`, `tanh(x)` +- `arsinh(x)`, `arcosh(x)`, `artanh(x)` +- `normalizeRadians(x)` +- `normalizeDegrees(x)` +- `lawOfSines(a=None, A=None, b=None, B=None)` +- `lawOfCosines(a=None, b=None, c=None, C=None)` +- `degreesMinutesSeconds(degree)` + +Test notes: + +- Test key angles: `0`, `pi / 6`, `pi / 4`, `pi / 2`, `pi`. +- Test reciprocal identities where defined. +- Test inverse function domain errors. + +## Quantitative Analysis + +Current coverage: + +- `localMinimum`, `localMaximum` +- `globalMinimum`, `globalMaximum` + +Missing depth: + +- Current functions operate on arrays only. +- There are no optimization helpers for callable functions. +- Plateaus and repeated extrema need clear behavior. + +Candidate additions: + +- `argMin(arr)` and `argMax(arr)` +- `rangeOfData(arr)` +- `criticalPoints(f, a, b, step=0.01)` +- `monotonicIntervals(arr)` +- `isIncreasing(arr)` and `isDecreasing(arr)` +- `movingAverage(arr, window)` + +Test notes: + +- Add plateau cases such as `[1, 2, 2, 1]`. +- Add repeated global extrema tests. + +## Statistics + +Current coverage: + +- `mean`, `median`, `standardDevation` +- `mode`, `variance` + +Missing depth: + +- `variance` currently returns inside the loop and should be fixed. +- `standardDevation` has a spelling issue in the public API. +- `quartiles` and `interquartileRange` exist in comments but are not shipped. +- No sample variance or sample standard deviation. + +Candidate additions: + +- `standardDeviation(arr)`: correctly spelled alias +- `sampleVariance(arr)` +- `sampleStandardDeviation(arr)` +- `quartiles(arr)` +- `interquartileRange(arr)` +- `percentile(arr, p)` +- `zScore(x, mean, stdDev)` +- `covariance(xValues, yValues)` +- `correlation(xValues, yValues)` +- `linearRegression(xValues, yValues)` + +Test notes: + +- Add tests for population versus sample formulas. +- Add empty-list and single-value behavior. +- Preserve `standardDevation` for backward compatibility if adding the corrected + spelling. + +## Naive Set Theory + +Current coverage: + +- Basic set operations such as union, intersection, difference, complement, + power set, subset checks, cardinality, and Cartesian product. + +Missing depth: + +- Set representation is list-based, so order and duplicates need clear rules. +- Relations and functions between sets are absent. +- Partitions and equivalence relations are absent. + +Candidate additions: + +- `setDifference(set1, set2)`: clearer alias for `difference` +- `cartesianPower(set, n)` +- `relationDomain(relation)` and `relationRange(relation)` +- `isRelation(relation, set1, set2)` +- `isFunctionRelation(relation, domain, codomain)` +- `isInjective(mapping)`, `isSurjective(mapping, codomain)`, `isBijective(mapping, codomain)` +- `partition(set, blocks)` +- `isEquivalenceRelation(relation, set)` + +Test notes: + +- Use list-based pairs consistently. +- Test duplicate inputs and output order. + +## ZFC Axiomatic Set Theory + +Current coverage: + +- Extensionality, empty set, pairing, union, separation, replacement, infinity, + regularity, and choice. + +Missing depth: + +- These functions demonstrate axioms but do not model formal set-theoretic + foundations deeply. +- Ordinal and cardinal helpers would make this section more educational. + +Candidate additions: + +- `successorOrdinal(n)` +- `vonNeumannOrdinal(n)` +- `ordinalLessThan(a, b)` +- `finiteCardinalEquivalent(set1, set2)` +- `powerSetAxiom(set)` +- `orderedPair(a, b)`: Kuratowski-style ordered pair +- `cartesianProductAxiom(set1, set2)` +- `transitiveSet(set)` + +Test notes: + +- Keep representations simple and document limitations. +- Test small ordinals only because nested lists grow quickly. + +## Linear Algebra + +Current coverage: + +- Matrix addition, subtraction, multiplication +- Determinant +- Transpose + +Missing depth: + +- No matrix inverse, rank, identity matrix, trace, vector operations, or linear + system solving. +- Determinant uses cofactor expansion, which is simple but slow for large + matrices. + +Candidate additions: + +- `identityMatrix(n)` +- `trace(matrix)` +- `matrixMinor(matrix, row, col)` +- `cofactorMatrix(matrix)` +- `inverseMatrix(matrix)` +- `rank(matrix)` +- `rowEchelon(matrix)` +- `reducedRowEchelon(matrix)` +- `solveLinearSystem(A, b)` +- `dotProduct(v, w)`, `crossProduct(v, w)`, `vectorNorm(v)` +- `eigenvalues2x2(matrix)` + +Test notes: + +- Test dimension mismatch errors. +- Test singular matrices. +- Compare `A * inverse(A)` with identity for small matrices. + +## Metric Spaces + +Current coverage: + +- `dist` +- `isMetricSpace` + +Missing depth: + +- Only three named metrics are supported. +- Open balls, closed balls, boundedness, and convergence are absent. +- Metric-space topology could connect this section to real analysis and + topology. + +Candidate additions: + +- `openBall(center, radius, points, metric="euclidean")` +- `closedBall(center, radius, points, metric="euclidean")` +- `isBounded(points, metric="euclidean")` +- `diameter(points, metric="euclidean")` +- `nearestNeighbor(point, points, metric="euclidean")` +- `sequenceConverges(sequence, target, tolerance=1e-9)` +- `discreteMetric(x, y)` +- `minkowskiDistance(x, y, p)` + +Test notes: + +- Test invalid metrics and dimension mismatches. +- Test metric axiom failures with intentionally bad distance functions. + +## Calculus + +Current coverage: + +- `limit`, `derivative`, `concavity`, `integral`, `continuity` + +Missing depth: + +- Numerical methods use fixed tolerances and step sizes. +- One-sided limits and higher derivatives are not public. +- There is no symbolic calculus; the section should document that it is + numerical. + +Candidate additions: + +- `leftLimit(f, a)` and `rightLimit(f, a)` +- `nthDerivative(f, x, n)` +- `secondDerivative(f, x)` +- `partialDerivative(f, point, variableIndex)` +- `gradient(f, point)` +- `riemannSum(f, a, b, n, method="midpoint")` +- `trapezoidalIntegral(f, a, b, n=1000)` +- `newtonMethod(f, derivativeFunction, initialGuess)` +- `criticalPointType(f, x)` + +Test notes: + +- Use functions with known derivatives and integrals. +- Add discontinuity tests. +- Add tolerance-based numeric assertions. + +## Complex Analysis + +Current coverage: + +- `conjugate` +- `rootsOfUnity` + +Missing depth: + +- Complex arithmetic needs to be stronger before complex analysis can deepen. +- No complex derivative, analytic checks, contour tools, or transformations. + +Candidate additions: + +- `complexDerivative(f, z, h=1e-5)` +- `cauchyRiemann(u, v, x, y, tolerance=1e-5)` +- `isAnalytic(u, v, x, y, tolerance=1e-5)` +- `mobiusTransform(z, a, b, c, d)` +- `complexExponential(z)` +- `complexLog(z)` +- `contourIntegral(f, pathPoints)` +- `residueSimplePole(numerator, denominator, pole)` + +Test notes: + +- Build on shared complex parsing and formatting helpers. +- Start with simple functions such as `f(z) = z^2`. + +## Number Theory + +Current coverage: + +- `isPrime` + +Missing depth: + +- This is one of the thinnest existing sections. +- Divisibility, factorization, modular arithmetic, and arithmetic functions are + absent. + +Candidate additions: + +- `gcd(a, b)` and `lcm(a, b)` +- `extendedGcd(a, b)` +- `modularExponent(base, exponent, modulus)` +- `modInverse(a, modulus)` +- `primeFactors(n)` +- `sieve(limit)` +- `eulerTotient(n)` +- `isCoprime(a, b)` +- `chineseRemainder(remainders, moduli)` +- `divisors(n)` +- `isPerfectNumber(n)` +- `mobiusFunction(n)` + +Test notes: + +- Test negative inputs and zero behavior. +- Verify number-theory identities, such as `gcd(a, b) * lcm(a, b) == abs(a*b)` + for nonzero integers. + +## Topology + +Current coverage: + +- `smooth` + +Missing depth: + +- `smooth` is closer to numerical calculus than point-set topology. +- Open sets are represented in naive set theory, but topology-specific helpers + are missing. + +Candidate additions: + +- `isTopology(collection, universalSet)` +- `interior(set, topology)` +- `closure(set, topology, universalSet)` +- `boundary(set, topology, universalSet)` +- `isClosedSet(set, topology, universalSet)` +- `isContinuousMap(f, domainTopology, codomainTopology)` +- `isHomeomorphism(f, inverse, domainTopology, codomainTopology)` +- `connectedComponents(points, adjacency)` +- `isConnected(points, adjacency)` +- `isCompactFinite(set, topology)` + +Test notes: + +- Start with finite topological spaces. +- Document that these are finite/discrete models, not full general topology. + +## Polynomials + +Current coverage: + +- `polyEval` +- `divide` +- `zeros` +- `factor` + +Missing depth: + +- Arithmetic between polynomials is absent. +- Derivatives and integrals of polynomial coefficient lists are absent. +- Root finding is limited. + +Candidate additions: + +- `polyAdd(p, q)` and `polySubtract(p, q)` +- `polyMultiply(p, q)` +- `polyDerivative(coefficients)` +- `polyIntegral(coefficients, constant=0)` +- `polyDegree(coefficients)` +- `polyLeadingCoefficient(coefficients)` +- `polyNormalize(coefficients)` +- `syntheticDivision(coefficients, root)` +- `rationalRootCandidates(coefficients)` +- `polyGcd(p, q)` + +Test notes: + +- Test leading zero handling. +- Test division identity: `dividend = divisor * quotient + remainder`. + +--- + +# Original future topics + ## Real Analysis +Purpose: + +- Build a formal analysis layer that complements the current numerical calculus + functions. + +Candidate additions: + +- `sequenceLimit(sequence, tolerance=1e-9)` +- `isConvergentSequence(sequence, tolerance=1e-9)` +- `isCauchySequence(sequence, tolerance=1e-9)` +- `seriesPartialSums(terms, n)` +- `isConvergentSeries(terms, tolerance=1e-9)` +- `ratioTest(terms, n)` +- `rootTest(terms, n)` +- `epsilonDeltaLimit(f, a, L, epsilonValues)` +- `uniformContinuity(f, domainPoints, tolerance=1e-9)` +- `supremum(values)` and `infimum(values)` +- `boundedAbove(values)` and `boundedBelow(values)` + +Implementation notes: + +- Keep the first version finite and numerical. +- Clearly document that functions approximate analysis concepts on sampled data. + ## Knot Theory +Purpose: + +- Add an approachable finite representation for knots and links. + +Candidate additions: + +- `knotCrossingNumber(diagram)` +- `writhe(diagram)` +- `mirrorKnot(diagram)` +- `reverseKnot(diagram)` +- `isAlternating(diagram)` +- `linkingNumber(linkDiagram)` +- `reidemeisterMoveOne(diagram, index)` +- `reidemeisterMoveTwo(diagram, index)` +- `reidemeisterMoveThree(diagram, index)` +- `alexanderPolynomialSimple(diagram)` + +Implementation notes: + +- Start with a simple diagram encoding before adding invariants. +- Document every representation choice with examples. + ## Type Theory +Purpose: + +- Provide educational helpers for typed expressions and small lambda-calculus + examples. + +Candidate additions: + +- `variable(name, typeName)` +- `functionType(inputType, outputType)` +- `isType(expression)` +- `lambdaExpression(variable, body)` +- `freeVariables(expression)` +- `substitute(expression, variable, replacement)` +- `betaReduce(expression)` +- `churchNumeral(n)` +- `inferSimpleType(expression, context)` +- `typeCheck(expression, expectedType, context)` + +Implementation notes: + +- Begin with simply typed lambda calculus. +- Avoid dependent types until the expression representation is stable. + ## Homotopy Theory + +Purpose: + +- Add finite and computational models that connect topology, graph theory, and + algebraic structures. + +Candidate additions: + +- `path(points)` +- `composePaths(path1, path2)` +- `reversePath(path)` +- `pathHomotopic(path1, path2, adjacency)` +- `fundamentalGroupFinite(space, basePoint)` +- `homotopyEquivalent(space1, space2)` +- `contractible(space)` +- `coveringMap(domain, codomain, mapping)` +- `simplicialComplex(faces)` +- `eulerCharacteristic(complex)` + +Implementation notes: + +- Start with graph-like spaces and finite simplicial complexes. +- Add examples because these concepts are abstract without representation docs. + +--- + +# Tier 3 new research areas + +## Abstract Algebra + +Why it fits: + +- It naturally follows set theory, counting, and number theory. + +Candidate additions: + +- `isGroup(elements, operation)` +- `isAbelianGroup(elements, operation)` +- `identityElement(elements, operation)` +- `inverseElement(element, elements, operation)` +- `elementOrder(element, elements, operation)` +- `isSubgroup(subset, group, operation)` +- `cyclicGroup(n)` +- `permutationCompose(p, q)` +- `permutationInverse(p)` +- `isRing(elements, additionOperation, multiplicationOperation)` +- `isField(elements, additionOperation, multiplicationOperation)` + +## Graph Theory and Discrete Math + +Why it fits: + +- It pairs with counting, set theory, topology, and optimization. + +Candidate additions: + +- `vertices(graph)` and `edges(graph)` +- `degree(graph, vertex)` +- `adjacencyMatrix(graph)` +- `isConnectedGraph(graph)` +- `breadthFirstSearch(graph, start)` +- `depthFirstSearch(graph, start)` +- `shortestPath(graph, start, end)` +- `hasCycle(graph)` +- `isTree(graph)` +- `minimumSpanningTree(graph)` +- `graphColoringGreedy(graph)` + +## Numerical Analysis + +Why it fits: + +- The current calculus and trigonometry functions are already numerical. + +Candidate additions: + +- `bisectionMethod(f, a, b, tolerance=1e-9)` +- `secantMethod(f, x0, x1, tolerance=1e-9)` +- `fixedPointIteration(g, x0, tolerance=1e-9)` +- `newtonRaphson(f, df, x0, tolerance=1e-9)` +- `lagrangeInterpolation(points, x)` +- `linearInterpolation(points, x)` +- `simpsonRule(f, a, b, n)` +- `trapezoidalRule(f, a, b, n)` +- `eulerMethod(f, x0, y0, h, steps)` +- `rungeKutta4(f, x0, y0, h, steps)` + +## Ordinary Differential Equations + +Why it fits: + +- ODE solvers extend calculus and numerical analysis. + +Candidate additions: + +- `eulerODE(f, x0, y0, h, steps)` +- `improvedEulerODE(f, x0, y0, h, steps)` +- `rungeKuttaODE(f, x0, y0, h, steps)` +- `slopeField(f, xValues, yValues)` +- `isEquilibriumPoint(f, y)` +- `linearFirstOrderSolution(p, q, x0, y0)` +- `separableStep(f, x, y, h)` + +## Multivariable and Vector Calculus + +Why it fits: + +- It bridges calculus, linear algebra, and physics-style applications. + +Candidate additions: + +- `partialDerivative(f, point, variableIndex)` +- `gradient(f, point)` +- `directionalDerivative(f, point, direction)` +- `jacobian(functions, point)` +- `hessian(f, point)` +- `divergence(vectorField, point)` +- `curl(vectorField, point)` +- `lineIntegral(vectorField, pathPoints)` + +## Combinatorics + +Why it fits: + +- Counting already exists; this makes the area more complete. + +Candidate additions: + +- `pascalRow(n)` +- `stirlingFirstKind(n, k)` +- `stirlingSecondKind(n, k)` +- `bellNumber(n)` +- `catalanNumber(n)` +- `integerPartitions(n)` +- `compositions(n)` +- `generatingFunctionCoefficients(sequence, n)` + +## Geometry + +Why it fits: + +- Geometry provides concrete use cases for trigonometry, algebra, and metric + spaces. + +Candidate additions: + +- `distance2D(p1, p2)` +- `midpoint(p1, p2)` +- `slope(p1, p2)` +- `triangleArea(a, b, c)` +- `polygonArea(points)` +- `circleArea(radius)` +- `circleCircumference(radius)` +- `lineIntersection(line1, line2)` +- `isCollinear(points)` +- `angleBetweenVectors(v, w)` + +## Mathematical Logic + +Why it fits: + +- Logic complements type theory, set theory, and proof-style functions. + +Candidate additions: + +- `truthTable(expression, variables)` +- `logicalAnd(a, b)`, `logicalOr(a, b)`, `logicalNot(a)` +- `implies(a, b)` and `iff(a, b)` +- `isTautology(expression, variables)` +- `isContradiction(expression, variables)` +- `isSatisfiable(expression, variables)` +- `deMorgansLawCheck(a, b)` +- `modusPonens(p, impliesPQ)` + +## Optimization + +Why it fits: + +- It extends quantitative analysis and calculus. + +Candidate additions: + +- `gradientDescent(f, gradientFunction, start, learningRate, steps)` +- `goldenSectionSearch(f, a, b, tolerance=1e-9)` +- `coordinateDescent(f, start, step, iterations)` +- `convexOnSamples(values)` +- `projectToInterval(x, lower, upper)` +- `argMinFunction(f, candidates)` +- `argMaxFunction(f, candidates)` + +## Information Theory + +Why it fits: + +- It connects probability, statistics, and discrete math. + +Candidate additions: + +- `entropy(probabilities)` +- `crossEntropy(p, q)` +- `klDivergence(p, q)` +- `mutualInformation(jointDistribution)` +- `informationContent(probability)` +- `giniImpurity(probabilities)` + +## Category Theory + +Why it fits: + +- It is a long-term bridge between abstract algebra, type theory, and topology. + +Candidate additions: + +- `isCategory(objects, morphisms, compose, identity)` +- `isFunctor(sourceCategory, targetCategory, objectMap, morphismMap)` +- `naturalTransformation(functorF, functorG, components)` +- `oppositeCategory(category)` +- `productCategory(categoryA, categoryB)` + +## Game Theory + +Why it fits: + +- It adds applied mathematical decision-making and pairs well with optimization. + +Candidate additions: + +- `payoff(matrix, rowStrategy, columnStrategy)` +- `dominantStrategy(payoffMatrix, player)` +- `nashEquilibria2x2(playerA, playerB)` +- `zeroSumValue(matrix)` +- `minimax(matrix)` +- `mixedStrategyExpectedPayoff(matrix, rowProbabilities, columnProbabilities)` + +## Fourier Analysis + +Why it fits: + +- It extends trigonometry, complex numbers, and numerical analysis. + +Candidate additions: + +- `discreteFourierTransform(values)` +- `inverseDiscreteFourierTransform(values)` +- `fourierSeriesCoefficient(f, n, a, b)` +- `sineSeriesCoefficient(f, n, a, b)` +- `cosineSeriesCoefficient(f, n, a, b)` +- `convolution(sequenceA, sequenceB)` + +## Dynamical Systems + +Why it fits: + +- It connects calculus, ODEs, numerical analysis, and topology. + +Candidate additions: + +- `iterateFunction(f, x0, steps)` +- `fixedPoints(f, candidates, tolerance=1e-9)` +- `logisticMap(r, x0, steps)` +- `orbit(f, x0, steps)` +- `isPeriodicOrbit(values, period, tolerance=1e-9)` +- `cobwebData(f, x0, steps)` +- `lyapunovExponentLogistic(r, x0, steps)` + +--- + +# Professional-level expansion requirements + +The sections above name useful next functions. A professional roadmap should +also define the engineering and mathematical standards that each area must meet +before it is considered mature. + +## Cross-cutting library standards + +Every area should eventually include: + +- Clear input contracts: valid domains, shapes, types, and edge-case behavior. +- Deterministic output formats: especially for matrices, graphs, sets, complex + numbers, symbolic expressions, and probability distributions. +- Tolerance controls for numerical functions, with documented defaults. +- Exact alternatives where practical, such as rational arithmetic for small + combinatorics, integer number theory, and finite algebra. +- Helpful exceptions for invalid mathematical input instead of silent failures. +- Examples in the README for the most common use cases. +- Unit tests for normal cases, boundary cases, invalid inputs, and identities. +- Property-style tests where identities are central, such as group axioms, + metric axioms, distribution normalization, and matrix inverse identities. +- Internal helper functions for parsing and validation so public functions do + not repeat fragile logic. +- Versioned deprecation notes when misspelled or weak APIs are replaced. + +## Existing-area maturity targets + +### Numerical foundations + +The numerical parts of arithmetic, algebra, trigonometry, calculus, statistics, +probability, linear algebra, and optimization should share these capabilities: + +- `isFiniteNumber(x)`: reject `nan`, infinities, and unsupported values. +- `validateTolerance(tolerance)`: enforce positive numeric tolerances. +- `relativeError(actual, expected)` and `absoluteError(actual, expected)`. +- `approximatelyEqual(a, b, absTol=1e-9, relTol=1e-9)`. +- Centralized finite-difference helpers for derivatives. +- Centralized summation helpers for numerical integration and series. +- Consistent behavior for empty arrays, singleton arrays, and zero-length + intervals. + +### Data-structure foundations + +The structural areas of set theory, topology, graph theory, algebra, type +theory, category theory, and homotopy theory should share these capabilities: + +- Canonical representations for ordered pairs, relations, graphs, paths, + functions, morphisms, and finite spaces. +- Validators such as `isMatrix`, `isSquareMatrix`, `isGraph`, `isRelation`, + `isTopology`, and `isOperationClosed`. +- Conversion helpers between equivalent representations, such as edge lists, + adjacency dictionaries, and adjacency matrices. +- Small finite models first, with explicit notes when a function is a finite + approximation of a general mathematical definition. + +### Documentation foundations + +Each mature topic should include: + +- One paragraph explaining the mathematical object being represented. +- A compact table of functions. +- At least one basic example and one edge-case example. +- A "Limitations" note for numerical approximations or finite models. +- A "Related topics" note so users can move between areas naturally. + +--- + +# Fifty additional professional research areas + +The following areas extend the roadmap beyond the current README topics and the +initial Tier 3 list. Each section includes scope, useful objects, candidate +APIs, and implementation or testing notes. + +## 1. Measure Theory + +Purpose: + +- Provide finite and numerical models for measurable spaces, measures, and + integration, creating a rigorous bridge between real analysis and probability. + +Core objects: + +- Sigma-algebras on finite sets +- Measures and probability measures +- Measurable functions +- Simple functions + +Candidate additions: + +- `isSigmaAlgebra(collection, universalSet)` +- `generatedSigmaAlgebra(subsets, universalSet)` +- `isMeasure(measure, sigmaAlgebra)` +- `measureOfSet(measure, subset)` +- `isMeasurableFunction(f, domainSigma, codomainSigma)` +- `simpleFunctionIntegral(values, measures)` +- `outerMeasure(set, coverings, measure)` +- `probabilitySpace(universalSet, sigmaAlgebra, measure)` + +Test notes: + +- Verify closure under complement and countable union in finite models. +- Test measure axioms: non-negativity, empty set measure, and finite additivity + for disjoint sets. + +## 2. Functional Analysis + +Purpose: + +- Represent normed spaces, Banach-space-style checks on finite samples, and + linear functionals. + +Core objects: + +- Normed vector spaces +- Linear functionals +- Bounded operators +- Inner product spaces + +Candidate additions: + +- `isNorm(norm, vectors)` +- `lpNorm(vector, p)` +- `supNorm(values)` +- `innerProduct(v, w)` +- `isInnerProduct(inner, vectors)` +- `operatorNorm(matrix, p=2)` +- `isLinearFunctional(functional, vectors)` +- `isContraction(operator, vectors, norm)` + +Test notes: + +- Test norm axioms and Cauchy-Schwarz on known finite vectors. +- Document that completeness checks are finite approximations. + +## 3. Operator Theory + +Purpose: + +- Study transformations between vector spaces, especially matrix-backed linear + operators. + +Core objects: + +- Linear operators +- Adjoint operators +- Projections +- Spectral radius + +Candidate additions: + +- `applyOperator(matrix, vector)` +- `operatorCompose(A, B)` +- `adjointOperator(matrix)` +- `isSelfAdjoint(matrix)` +- `isProjection(matrix)` +- `spectralRadius(matrix)` +- `commutator(A, B)` +- `isNormalOperator(matrix)` + +Test notes: + +- Use small matrices with known eigenvalues. +- Test identities such as `P * P == P` for projections. + +## 4. Harmonic Analysis + +Purpose: + +- Expand Fourier analysis into broader transform, convolution, and frequency + decomposition tools. + +Core objects: + +- Signals +- Kernels +- Fourier coefficients +- Convolution operators + +Candidate additions: + +- `normalizeSignal(values)` +- `circularConvolution(a, b)` +- `correlationSignal(a, b)` +- `fourierMagnitude(values)` +- `fourierPhase(values)` +- `lowPassFilter(values, cutoff)` +- `highPassFilter(values, cutoff)` +- `dirichletKernel(n, x)` + +Test notes: + +- Test convolution length and identity kernels. +- Verify Parseval-style identities on small finite sequences where practical. + +## 5. Partial Differential Equations + +Purpose: + +- Add finite-difference approximations for basic PDE models. + +Core objects: + +- Grids +- Boundary conditions +- Difference stencils +- Heat, wave, and Laplace equations + +Candidate additions: + +- `finiteDifferenceGrid(xPoints, tPoints)` +- `laplacian2D(grid, i, j, h)` +- `heatEquationStep(grid, alpha, dt, dx)` +- `waveEquationStep(previous, current, c, dt, dx)` +- `dirichletBoundary(grid, value)` +- `neumannBoundary(grid, derivative)` +- `solveLaplace2D(boundaryGrid, iterations)` +- `stabilityHeatEquation(alpha, dt, dx)` + +Test notes: + +- Test grid shape validation. +- Add conservation or monotonicity checks for simple cases. + +## 6. Stochastic Processes + +Purpose: + +- Model random processes over discrete time and finite state spaces. + +Core objects: + +- Random walks +- Markov chains +- Transition matrices +- Stationary distributions + +Candidate additions: + +- `randomWalkPath(start, steps, increments)` +- `isTransitionMatrix(matrix)` +- `markovStep(distribution, transitionMatrix)` +- `markovChainDistribution(initial, transitionMatrix, steps)` +- `stationaryDistribution(transitionMatrix)` +- `absorbingStates(transitionMatrix)` +- `hittingProbability(transitionMatrix, start, target)` +- `expectedReturnTime(transitionMatrix, state)` + +Test notes: + +- Verify transition rows sum to one. +- Test known two-state chains and absorbing chains. + +## 7. Stochastic Calculus + +Purpose: + +- Provide educational discrete approximations of stochastic calculus concepts. + +Core objects: + +- Brownian paths +- Quadratic variation +- Ito sums +- Stochastic differential equation steps + +Candidate additions: + +- `brownianPath(increments, start=0)` +- `quadraticVariation(path)` +- `itoIntegralApprox(integrandValues, brownianIncrements)` +- `stratonovichIntegralApprox(integrandValues, brownianIncrements)` +- `geometricBrownianMotionPath(mu, sigma, increments, start)` +- `eulerMaruyamaStep(x, drift, diffusion, dt, dW)` +- `blackScholesCallPrice(S, K, r, sigma, T)` +- `blackScholesPutPrice(S, K, r, sigma, T)` + +Test notes: + +- Keep randomness injectable through provided increments. +- Test deterministic increment paths for reproducibility. + +## 8. Time Series Analysis + +Purpose: + +- Add sequence analysis tools for data indexed by time. + +Core objects: + +- Lagged series +- Autocorrelation +- Moving averages +- Trend and seasonality + +Candidate additions: + +- `lag(values, k)` +- `differenceSeries(values, order=1)` +- `autocovariance(values, lag)` +- `autocorrelation(values, lag)` +- `movingAverage(values, window)` +- `exponentialSmoothing(values, alpha)` +- `detectTrend(values)` +- `seasonalIndices(values, period)` + +Test notes: + +- Validate window and lag sizes. +- Test constant, linear, and periodic sequences. + +## 9. Bayesian Statistics + +Purpose: + +- Extend probability into prior-posterior updates and conjugate models. + +Core objects: + +- Priors +- Likelihoods +- Posteriors +- Credible intervals + +Candidate additions: + +- `bayesianUpdateDiscrete(prior, likelihood)` +- `normalizeProbabilities(weights)` +- `betaPosterior(alpha, beta, successes, failures)` +- `betaMean(alpha, beta)` +- `betaVariance(alpha, beta)` +- `credibleIntervalDiscrete(distribution, confidence)` +- `maximumAPosteriori(distribution)` +- `posteriorPredictiveDiscrete(posterior, likelihoods)` + +Test notes: + +- Verify posterior probabilities sum to one. +- Test conjugate beta-binomial examples with known means. + +## 10. Statistical Inference + +Purpose: + +- Add confidence intervals, hypothesis tests, and estimators. + +Core objects: + +- Estimators +- Confidence intervals +- Test statistics +- P-values + +Candidate additions: + +- `confidenceIntervalMean(values, confidence=0.95)` +- `zTestMean(sampleMean, populationMean, stdDev, n)` +- `tStatisticMean(values, hypothesizedMean)` +- `chiSquareStatistic(observed, expected)` +- `proportionConfidenceInterval(successes, trials, confidence=0.95)` +- `meanSquaredError(estimates, actual)` +- `bias(estimates, actual)` +- `bootstrapMeans(values, resamples)` + +Test notes: + +- Test against hand-computed small examples. +- Document approximation assumptions. + +## 11. Experimental Design + +Purpose: + +- Provide helpers for controlled experiments and simple statistical planning. + +Core objects: + +- Treatments +- Blocks +- Random assignments +- Factorial designs + +Candidate additions: + +- `completeRandomAssignment(subjects, treatments)` +- `blockedRandomAssignment(blocks, treatments)` +- `factorialDesign(factors)` +- `latinSquare(n)` +- `treatmentMeans(data, treatmentLabels)` +- `anovaOneWay(groups)` +- `effectSizeDifference(meanA, meanB, pooledStdDev)` +- `minimumDetectableEffect(stdDev, n, alpha, power)` + +Test notes: + +- Make randomized functions accept deterministic seeds or orderings. +- Test balanced-design counts. + +## 12. Computational Geometry + +Purpose: + +- Add algorithmic geometry on points, segments, polygons, and hulls. + +Core objects: + +- Points +- Line segments +- Polygons +- Convex hulls + +Candidate additions: + +- `orientation(p, q, r)` +- `segmentsIntersect(a, b, c, d)` +- `pointInPolygon(point, polygon)` +- `convexHull(points)` +- `closestPair(points)` +- `boundingBox(points)` +- `polygonCentroid(points)` +- `triangulateConvexPolygon(points)` + +Test notes: + +- Test collinear and duplicate points. +- Validate clockwise and counterclockwise polygon order. + +## 13. Differential Geometry + +Purpose: + +- Represent curves and surfaces with numerical geometric invariants. + +Core objects: + +- Parametric curves +- Parametric surfaces +- Curvature +- Torsion + +Candidate additions: + +- `curveDerivative(curve, t)` +- `arcLength(curve, a, b)` +- `curvature2D(curve, t)` +- `curvature3D(curve, t)` +- `torsion(curve, t)` +- `surfaceNormal(surface, u, v)` +- `firstFundamentalForm(surface, u, v)` +- `geodesicStep(surface, point, direction, step)` + +Test notes: + +- Use circles and lines as baseline cases. +- Add tolerance-based tests for numerical derivatives. + +## 14. Riemannian Geometry + +Purpose: + +- Add metric tensors and finite-dimensional geometric computations. + +Core objects: + +- Metric tensors +- Christoffel symbols +- Geodesics +- Curvature tensors + +Candidate additions: + +- `metricTensorEuclidean(n)` +- `innerProductMetric(metric, v, w)` +- `christoffelSymbols(metricFunctions, point)` +- `geodesicEquationStep(metricFunctions, state, step)` +- `sectionalCurvature(metricFunctions, point, plane)` +- `scalarCurvature(metricFunctions, point)` +- `raiseIndex(metricInverse, covector)` +- `lowerIndex(metric, vector)` + +Test notes: + +- Start with Euclidean and sphere-like examples. +- Clearly label advanced functions as numerical approximations. + +## 15. Algebraic Geometry + +Purpose: + +- Study polynomial solution sets and ideal-like computations in a lightweight + way. + +Core objects: + +- Affine varieties +- Polynomial systems +- Ideals +- Groebner-style reductions + +Candidate additions: + +- `evaluatePolynomialMultivariate(terms, point)` +- `zeroSet(polynomials, candidatePoints)` +- `isPolynomialInIdeal(polynomial, generators, candidates)` +- `monomialOrder(monomials, order="lex")` +- `leadingTerm(polynomial, order="lex")` +- `sPolynomial(f, g)` +- `buchbergerStep(generators)` +- `affineVarietyDimensionEstimate(points)` + +Test notes: + +- Begin with finite candidate sets. +- Test small bivariate polynomial systems. + +## 16. Arithmetic Geometry + +Purpose: + +- Connect number theory and algebraic geometry through curves over finite + fields and rational points. + +Core objects: + +- Finite-field points +- Elliptic curves +- Rational points +- Modular reductions + +Candidate additions: + +- `pointsOnCurveModP(polynomial, p)` +- `ellipticCurveDiscriminant(a, b)` +- `isPointOnEllipticCurve(point, a, b, modulus=None)` +- `ellipticCurveAdd(P, Q, a, modulus=None)` +- `ellipticCurveScalarMultiply(P, n, a, modulus=None)` +- `countPointsEllipticCurveModP(a, b, p)` +- `hasGoodReduction(a, b, p)` +- `rationalPointHeight(point)` + +Test notes: + +- Test point addition identity and inverse cases. +- Validate finite-field arithmetic through existing number theory helpers. + +## 17. Algebraic Topology + +Purpose: + +- Add computable invariants for finite topological and simplicial structures. + +Core objects: + +- Simplicial complexes +- Chains +- Boundary maps +- Homology groups + +Candidate additions: + +- `facesOfComplex(complex)` +- `boundaryOfSimplex(simplex)` +- `boundaryMatrix(complex, dimension)` +- `chainGroupRank(complex, dimension)` +- `bettiNumber(complex, dimension)` +- `eulerCharacteristicFromBetti(bettiNumbers)` +- `simplicialHomologyRanks(complex)` +- `isCycle(chain, boundaryMatrix)` + +Test notes: + +- Test intervals, triangles, circles, and filled triangles. +- Keep early outputs as ranks before modeling full abelian groups. + +## 18. Geometric Topology + +Purpose: + +- Study manifolds and embeddings using finite/combinatorial models. + +Core objects: + +- Triangulations +- Surfaces +- Manifold checks +- Handles and genus + +Candidate additions: + +- `isTriangulatedSurface(complex)` +- `vertexLink(complex, vertex)` +- `isCombinatorialManifold(complex)` +- `surfaceEulerCharacteristic(vertices, edges, faces)` +- `orientableSurfaceGenus(vertices, edges, faces)` +- `connectedSumInvariant(surfaceA, surfaceB)` +- `boundaryComponents(complex)` +- `isOrientableSurface(complex)` + +Test notes: + +- Test sphere, torus-style examples, and disks once representations exist. +- Document combinatorial assumptions. + +## 19. Differential Topology + +Purpose: + +- Connect calculus and topology through smooth maps and local structure. + +Core objects: + +- Smooth maps +- Jacobians +- Regular values +- Transversality-style finite checks + +Candidate additions: + +- `jacobianRank(f, point)` +- `isImmersion(f, point)` +- `isSubmersion(f, point)` +- `isRegularValue(f, value, candidatePreimages)` +- `criticalValues(f, domainPoints)` +- `degreeMapCircle(mapSamples)` +- `localDiffeomorphism(f, point)` +- `sardSampleCheck(f, domainPoints)` + +Test notes: + +- Use low-dimensional numerical examples. +- Be explicit that global theorems are sampled approximations. + +## 20. Lie Theory + +Purpose: + +- Add matrix Lie groups and Lie algebras for advanced algebra and geometry. + +Core objects: + +- Matrix groups +- Lie algebras +- Brackets +- Exponential maps + +Candidate additions: + +- `matrixCommutator(A, B)` +- `isSkewSymmetric(matrix)` +- `lieBracket(A, B)` +- `matrixExponential(matrix, terms=20)` +- `specialOrthogonal2(theta)` +- `isLieAlgebra(elements, bracket)` +- `adjointRepresentation(element, algebra)` +- `bakerCampbellHausdorff(A, B, terms=3)` + +Test notes: + +- Test bracket bilinearity and antisymmetry on matrices. +- Start with 2x2 examples. + +## 21. Representation Theory + +Purpose: + +- Study algebraic structures through linear transformations. + +Core objects: + +- Group actions +- Characters +- Representations +- Irreducibility checks + +Candidate additions: + +- `groupAction(group, setValues, action)` +- `orbitOfElement(group, element, action)` +- `stabilizer(group, element, action)` +- `representationMatrices(group, mapping)` +- `characterOfRepresentation(matrices)` +- `regularRepresentation(group)` +- `isInvariantSubspace(subspace, matrices)` +- `burnsideLemma(group, setValues, action)` + +Test notes: + +- Test small cyclic groups and permutation actions. +- Verify orbit-stabilizer identity for finite groups. + +## 22. Galois Theory + +Purpose: + +- Connect field extensions, polynomial roots, and symmetry. + +Core objects: + +- Polynomial fields +- Splitting fields in simple cases +- Automorphisms +- Galois groups + +Candidate additions: + +- `rationalRootTest(coefficients)` +- `isIrreduciblePolynomial(coefficients, field="Q")` +- `polynomialDiscriminantQuadratic(a, b, c)` +- `polynomialDiscriminantCubic(a, b, c, d)` +- `quadraticGaloisGroup(a, b, c)` +- `fieldExtensionDegree(minimalPolynomial)` +- `conjugateRootsQuadratic(a, b, c)` +- `isSeparablePolynomial(coefficients, characteristic=0)` + +Test notes: + +- Start with quadratic and cubic cases. +- Reuse polynomial and number theory utilities. + +## 23. Commutative Algebra + +Purpose: + +- Support rings, ideals, modules, and algebraic computations that feed algebraic + geometry. + +Core objects: + +- Rings +- Ideals +- Modules +- Quotient rings + +Candidate additions: + +- `idealGeneratedBy(generators, ringElements, operations)` +- `isIdeal(subset, ringElements, add, multiply)` +- `idealSum(I, J)` +- `idealProduct(I, J, multiply)` +- `radicalIdealApprox(ideal, candidates, powerLimit)` +- `quotientRingClasses(ringElements, ideal)` +- `isMaximalIdeal(ideal, ringElements, operations)` +- `isPrimeIdeal(ideal, ringElements, operations)` + +Test notes: + +- Use finite rings such as integers modulo n. +- Test ideal closure properties. + +## 24. Homological Algebra + +Purpose: + +- Add chain complexes and exactness checks, supporting topology and algebra. + +Core objects: + +- Chain complexes +- Boundary maps +- Kernels +- Images +- Exact sequences + +Candidate additions: + +- `isChainComplex(boundaryMatrices)` +- `kernelDimension(matrix)` +- `imageDimension(matrix)` +- `homologyDimension(boundaryN, boundaryNext)` +- `isExactAt(mapA, mapB)` +- `chainMap(complexA, complexB, maps)` +- `mappingCone(chainMap)` +- `longExactSequenceRanks(data)` + +Test notes: + +- Use matrix ranks over small fields or rationals. +- Verify `d_n * d_(n+1) == 0`. + +## 25. Noncommutative Algebra + +Purpose: + +- Represent algebraic structures where multiplication order matters. + +Core objects: + +- Noncommutative rings +- Algebras +- Commutators +- Centers + +Candidate additions: + +- `isAssociativeOperation(elements, operation)` +- `isCommutativeOperation(elements, operation)` +- `centerOfAlgebra(elements, multiply)` +- `commutatorElement(a, b, multiply, subtract)` +- `leftIdealGeneratedBy(generators, elements, add, multiply)` +- `rightIdealGeneratedBy(generators, elements, add, multiply)` +- `matrixAlgebraBasis(n)` +- `quaternionMultiply(q1, q2)` + +Test notes: + +- Use matrices and quaternions as concrete examples. +- Test associativity separately from commutativity. + +## 26. Universal Algebra + +Purpose: + +- Generalize algebraic structures by operations and identities. + +Core objects: + +- Signatures +- Algebras +- Homomorphisms +- Congruences + +Candidate additions: + +- `signature(operations)` +- `isAlgebraForSignature(elements, operations, signature)` +- `satisfiesIdentity(elements, operations, lhs, rhs)` +- `isHomomorphism(domain, codomain, mapping, operations)` +- `subalgebraGeneratedBy(generators, elements, operations)` +- `congruenceRelation(elements, relation, operations)` +- `quotientAlgebra(elements, congruence, operations)` +- `productAlgebra(algebraA, algebraB)` + +Test notes: + +- Start with semigroups, monoids, and lattices. +- Test preservation of operations under homomorphisms. + +## 27. Lattice Theory + +Purpose: + +- Study ordered structures with meets and joins. + +Core objects: + +- Posets +- Lattices +- Meets +- Joins +- Bounds + +Candidate additions: + +- `meet(a, b, orderRelation, elements)` +- `join(a, b, orderRelation, elements)` +- `isLattice(elements, orderRelation)` +- `isDistributiveLattice(elements, meetOperation, joinOperation)` +- `isCompleteLattice(elements, orderRelation)` +- `leastElement(elements, orderRelation)` +- `greatestElement(elements, orderRelation)` +- `hasseDiagram(elements, orderRelation)` + +Test notes: + +- Test subset lattices and divisor lattices. +- Verify absorption and distributive laws. + +## 28. Order Theory + +Purpose: + +- Provide general tools for partial orders, total orders, and fixed points. + +Core objects: + +- Preorders +- Partial orders +- Total orders +- Chains and antichains + +Candidate additions: + +- `isReflexiveRelation(relation, elements)` +- `isAntisymmetricRelation(relation, elements)` +- `isTransitiveRelation(relation, elements)` +- `isPartialOrder(relation, elements)` +- `isTotalOrder(relation, elements)` +- `minimalElements(elements, orderRelation)` +- `maximalElements(elements, orderRelation)` +- `topologicalSort(poset)` + +Test notes: + +- Test relation properties independently. +- Reuse graph helpers for topological sorting. + +## 29. Model Theory + +Purpose: + +- Evaluate structures against first-order-style signatures and formulas. + +Core objects: + +- Languages +- Structures +- Assignments +- Formulas + +Candidate additions: + +- `structure(domain, functions, relations, constants)` +- `evaluateTerm(term, structure, assignment)` +- `satisfiesAtomicFormula(formula, structure, assignment)` +- `satisfiesFormula(formula, structure, assignment)` +- `elementaryEquivalentFinite(structureA, structureB, formulas)` +- `theoryModels(theory, candidateStructures)` +- `isIsomorphicStructure(structureA, structureB, mapping)` +- `automorphismsFiniteStructure(structure)` + +Test notes: + +- Keep formula representation simple and documented. +- Test with finite graphs and finite orders. + +## 30. Proof Theory + +Purpose: + +- Add proof checking and derivation helpers for logical systems. + +Core objects: + +- Propositions +- Inference rules +- Proof trees +- Sequents + +Candidate additions: + +- `sequent(assumptions, conclusion)` +- `applyModusPonens(rule, premises)` +- `isValidInference(rule, premises, conclusion)` +- `proofTree(conclusion, premises)` +- `checkProof(steps, rules)` +- `normalFormProof(proof)` +- `deductionTheoremTransform(proof)` +- `cutEliminationStep(proof)` + +Test notes: + +- Begin with propositional logic. +- Test invalid proof steps explicitly. + +## 31. Descriptive Set Theory + +Purpose: + +- Provide finite analogues and educational helpers for definable sets and + hierarchies. + +Core objects: + +- Borel-like generated collections +- Trees +- Cantor-space finite prefixes +- Equivalence relations + +Candidate additions: + +- `cylinderSet(prefix, alphabet)` +- `cantorPrefixTree(depth)` +- `borelGeneratedFinite(generators, universalSet)` +- `isBorelFinite(setValue, generatedCollection)` +- `treeBodyPrefixes(tree, depth)` +- `equivalenceClasses(relation, elements)` +- `smoothEquivalenceRelationFinite(relation, elements)` +- `reductionBetweenRelations(relationA, relationB, mapping)` + +Test notes: + +- Clearly state finite approximation limits. +- Test generated collections from small bases. + +## 32. Computability Theory + +Purpose: + +- Model algorithms, decidability, and computable functions in an educational + form. + +Core objects: + +- Turing-machine-like states +- Partial functions +- Deciders +- Enumerators + +Candidate additions: + +- `simulateDFA(automaton, inputString)` +- `simulateTuringMachine(machine, tape, maxSteps)` +- `haltsWithin(machine, tape, maxSteps)` +- `isTotalOnSamples(function, samples)` +- `enumerateLanguage(generator, steps)` +- `characteristicFunction(setValues, universalSet)` +- `composePartialFunctions(f, g)` +- `primitiveRecursiveAdd(a, b)` + +Test notes: + +- Use explicit step limits to avoid nontermination. +- Test simple accept/reject machines. + +## 33. Automata and Formal Languages + +Purpose: + +- Add tools for regular languages, grammars, and parsing. + +Core objects: + +- DFAs +- NFAs +- Regular expressions +- Context-free grammars + +Candidate additions: + +- `dfaAccepts(dfa, inputString)` +- `nfaAccepts(nfa, inputString)` +- `nfaToDfa(nfa)` +- `minimizeDfa(dfa)` +- `regularLanguageUnion(dfaA, dfaB)` +- `regularLanguageIntersection(dfaA, dfaB)` +- `cykParse(grammar, inputString)` +- `grammarDerives(grammar, inputString, maxDepth)` + +Test notes: + +- Test automata with empty strings and dead states. +- Validate transition completeness. + +## 34. Coding Theory + +Purpose: + +- Support error-detecting and error-correcting codes. + +Core objects: + +- Codewords +- Hamming distance +- Linear codes +- Generator and parity-check matrices + +Candidate additions: + +- `hammingDistance(a, b)` +- `minimumDistance(codewords)` +- `encodeLinearCode(message, generatorMatrix, modulus=2)` +- `syndrome(received, parityCheckMatrix, modulus=2)` +- `detectError(received, parityCheckMatrix)` +- `correctSingleBitError(received, parityCheckMatrix)` +- `hammingCode74Encode(message)` +- `hammingCode74Decode(codeword)` + +Test notes: + +- Test all one-bit errors for small Hamming codes. +- Verify matrix dimensions over finite fields. + +## 35. Cryptography + +Purpose: + +- Provide educational number-theoretic cryptography primitives. + +Core objects: + +- Modular arithmetic +- Keys +- Ciphers +- Hash-style toy functions + +Candidate additions: + +- `caesarCipher(text, shift)` +- `affineCipherEncrypt(text, a, b)` +- `affineCipherDecrypt(text, a, b)` +- `rsaKeyCheck(p, q, e)` +- `rsaEncryptNumber(message, e, n)` +- `rsaDecryptNumber(ciphertext, d, n)` +- `diffieHellmanPublic(g, private, p)` +- `diffieHellmanShared(public, private, p)` + +Test notes: + +- Mark these as educational, not production-security utilities. +- Test small textbook examples only. + +## 36. Finite Fields + +Purpose: + +- Support arithmetic over fields with finitely many elements. + +Core objects: + +- Prime fields +- Polynomial quotient fields +- Field elements +- Multiplicative groups + +Candidate additions: + +- `fieldAdd(a, b, p)` +- `fieldSubtract(a, b, p)` +- `fieldMultiply(a, b, p)` +- `fieldInverse(a, p)` +- `fieldDivide(a, b, p)` +- `fieldPower(a, n, p)` +- `isPrimitiveRoot(g, p)` +- `multiplicativeOrderMod(a, p)` + +Test notes: + +- Test field axioms for small primes. +- Reuse modular inverse from number theory. + +## 37. Analytic Number Theory + +Purpose: + +- Add functions that study integers through analytic approximations. + +Core objects: + +- Prime-counting functions +- Arithmetic sums +- Zeta-like approximations +- Chebyshev functions + +Candidate additions: + +- `primeCountingFunction(n)` +- `logIntegralApprox(x)` +- `riemannZetaPartial(s, terms)` +- `mobiusSummatory(n)` +- `mertensFunction(n)` +- `chebyshevTheta(n)` +- `chebyshevPsi(n)` +- `divisorSummatory(n)` + +Test notes: + +- Compare small values to exact hand-computed results. +- Document approximation limits for large analytic functions. + +## 38. Algebraic Number Theory + +Purpose: + +- Study algebraic integers, norms, traces, and quadratic fields. + +Core objects: + +- Number fields +- Rings of integers in simple cases +- Norms and traces +- Ideals in quadratic rings + +Candidate additions: + +- `quadraticFieldElement(a, b, d)` +- `quadraticFieldAdd(x, y, d)` +- `quadraticFieldMultiply(x, y, d)` +- `quadraticFieldConjugate(x, d)` +- `quadraticFieldNorm(x, d)` +- `quadraticFieldTrace(x, d)` +- `isAlgebraicIntegerQuadratic(x, d)` +- `classNumberEstimateQuadratic(d)` + +Test notes: + +- Start with square-free `d`. +- Test norm multiplicativity. + +## 39. Diophantine Approximation + +Purpose: + +- Approximate real numbers by rationals and analyze integer solutions. + +Core objects: + +- Continued fractions +- Rational approximations +- Pell equations +- Approximation errors + +Candidate additions: + +- `continuedFraction(x, terms)` +- `continuedFractionConvergents(coefficients)` +- `bestRationalApproximation(x, maxDenominator)` +- `approximationError(x, numerator, denominator)` +- `solvePell(D, limit)` +- `fareySequence(n)` +- `mediant(fracA, fracB)` +- `isDiophantineSolution(equation, values)` + +Test notes: + +- Test sqrt(2) convergents. +- Validate exact integer equations. + +## 40. Ergodic Theory + +Purpose: + +- Study long-term averages of transformations on finite or sampled spaces. + +Core objects: + +- Measure-preserving maps +- Orbits +- Time averages +- Invariant sets + +Candidate additions: + +- `timeAverage(f, transform, x0, steps)` +- `spaceAverage(values, measure)` +- `isMeasurePreserving(transform, space, measure)` +- `invariantSet(transform, subset)` +- `ergodicSampleCheck(transform, space, measure)` +- `poincareReturnTimes(transform, x0, targetSet, steps)` +- `birkhoffAverage(values)` +- `mixingSampleCheck(transform, sets, steps)` + +Test notes: + +- Use finite rotations and permutations. +- Keep claims as sample-based checks. + +## 41. Chaos Theory + +Purpose: + +- Deepen dynamical systems with sensitivity, bifurcations, and chaotic maps. + +Core objects: + +- Iterated maps +- Orbits +- Lyapunov exponents +- Bifurcation samples + +Candidate additions: + +- `sensitivityToInitialConditions(f, x0, delta, steps)` +- `bifurcationDataLogistic(rValues, x0, burnIn, samples)` +- `lyapunovExponentMap(f, derivative, x0, steps)` +- `tentMap(mu, x)` +- `henonMap(a, b, point)` +- `lorenzStep(point, sigma, rho, beta, dt)` +- `poincareSection(points, coordinateIndex, value)` +- `chaosGame(vertices, ratios, choices, start)` + +Test notes: + +- Use deterministic choice lists for chaos-game examples. +- Test known fixed and periodic regimes. + +## 42. Control Theory + +Purpose: + +- Add linear-system and feedback-control computations. + +Core objects: + +- State-space systems +- Transfer functions +- Controllability +- Observability + +Candidate additions: + +- `stateStep(A, B, x, u)` +- `simulateLinearSystem(A, B, x0, inputs)` +- `controllabilityMatrix(A, B)` +- `observabilityMatrix(A, C)` +- `isControllable(A, B)` +- `isObservable(A, C)` +- `feedbackGainStep(A, B, K)` +- `pidStep(error, previousError, integral, kp, ki, kd, dt)` + +Test notes: + +- Reuse matrix rank from linear algebra. +- Test small systems with known controllability. + +## 43. Convex Analysis + +Purpose: + +- Support convex sets, convex functions, and subgradient-style tools. + +Core objects: + +- Convex combinations +- Convex sets +- Convex functions +- Supporting hyperplanes + +Candidate additions: + +- `convexCombination(points, weights)` +- `isConvexSet(points, membershipFunction, samples)` +- `isConvexFunctionOnSamples(values)` +- `subgradientAbsoluteValue(x)` +- `supportFunction(points, direction)` +- `projectionOntoInterval(x, lower, upper)` +- `projectionOntoSimplex(vector)` +- `jensensInequalityCheck(f, points, weights)` + +Test notes: + +- Test weight normalization and nonnegative weights. +- Use simple intervals and quadratic functions. + +## 44. Calculus of Variations + +Purpose: + +- Study functionals and extremizing curves through numerical approximations. + +Core objects: + +- Functionals +- Paths +- Euler-Lagrange equations +- Variations + +Candidate additions: + +- `functionalPathIntegral(lagrangian, path, tValues)` +- `variationPath(path, perturbation, epsilon)` +- `firstVariation(functional, path, perturbation)` +- `eulerLagrangeResidual(lagrangian, path, tValues)` +- `shortestPathFunctional(path)` +- `energyFunctional(path)` +- `gradientDescentPath(functional, path, step, iterations)` +- `brachistochroneResidual(path)` + +Test notes: + +- Use straight-line paths for shortest-path examples. +- Make discretization explicit. + +## 45. Optimal Transport + +Purpose: + +- Compare distributions through transport costs. + +Core objects: + +- Discrete measures +- Cost matrices +- Couplings +- Wasserstein distance + +Candidate additions: + +- `isCoupling(coupling, source, target)` +- `transportCost(coupling, costMatrix)` +- `greedyTransport(source, target, costMatrix)` +- `wasserstein1D(sourceValues, targetValues, weightsA=None, weightsB=None)` +- `earthMoversDistance1D(source, target)` +- `normalizeMeasure(weights)` +- `costMatrix(pointsA, pointsB, metric="euclidean")` +- `barycenterDiscrete(distributions, weights)` + +Test notes: + +- Test mass conservation. +- Start with one-dimensional exact examples. + +## 46. Numerical Linear Algebra + +Purpose: + +- Add stable computational methods for matrices beyond symbolic-style formulas. + +Core objects: + +- Matrix decompositions +- Iterative solvers +- Conditioning +- Orthogonality + +Candidate additions: + +- `luDecomposition(matrix)` +- `qrDecomposition(matrix)` +- `choleskyDecomposition(matrix)` +- `powerIteration(matrix, iterations)` +- `conditionNumber(matrix)` +- `jacobiSolve(A, b, iterations)` +- `gaussSeidelSolve(A, b, iterations)` +- `gramSchmidt(vectors)` + +Test notes: + +- Test reconstruction identities such as `A == L * U`. +- Use tolerance-based comparisons. + +## 47. Approximation Theory + +Purpose: + +- Approximate functions with polynomials, splines, and basis expansions. + +Core objects: + +- Polynomial approximants +- Interpolation nodes +- Approximation error +- Orthogonal polynomials + +Candidate additions: + +- `leastSquaresPolynomial(points, degree)` +- `chebyshevNodes(a, b, n)` +- `chebyshevPolynomial(n, x)` +- `legendrePolynomial(n, x)` +- `approximationErrorSamples(f, g, points)` +- `minimaxApproximationStep(f, degree, points)` +- `bernsteinPolynomial(fValues, n, x)` +- `piecewiseLinearApproximation(points, x)` + +Test notes: + +- Test interpolation exactness at nodes. +- Compare low-degree known polynomials. + +## 48. Wavelet Theory + +Purpose: + +- Add multiresolution analysis for finite signals. + +Core objects: + +- Scaling functions +- Wavelets +- Filter banks +- Multilevel decompositions + +Candidate additions: + +- `haarTransform(values)` +- `inverseHaarTransform(coefficients)` +- `haarApproximation(values, level)` +- `waveletEnergy(coefficients)` +- `thresholdCoefficients(coefficients, threshold)` +- `multiLevelHaar(values, levels)` +- `reconstructMultiLevelHaar(data)` +- `detailCoefficients(values)` + +Test notes: + +- Test round-trip transform and inverse. +- Validate power-of-two length requirements. + +## 49. Splines and Computer-Aided Geometric Design + +Purpose: + +- Support piecewise polynomial curves and geometric modeling. + +Core objects: + +- Bezier curves +- B-splines +- Control points +- Knot vectors + +Candidate additions: + +- `bezierPoint(controlPoints, t)` +- `deCasteljau(controlPoints, t)` +- `bezierDerivative(controlPoints, t)` +- `bernsteinBasis(n, i, t)` +- `bsplineBasis(i, degree, knots, t)` +- `bsplinePoint(controlPoints, degree, knots, t)` +- `catmullRomPoint(points, t)` +- `curveSubdivision(controlPoints)` + +Test notes: + +- Test endpoint interpolation for Bezier curves. +- Validate knot vector lengths. + +## 50. Matroid Theory + +Purpose: + +- Generalize independence from linear algebra and graph theory. + +Core objects: + +- Ground sets +- Independent sets +- Circuits +- Bases +- Rank functions + +Candidate additions: + +- `isMatroid(groundSet, independentSets)` +- `matroidRank(subset, independentSets)` +- `matroidBases(groundSet, independentSets)` +- `matroidCircuits(groundSet, independentSets)` +- `isIndependentMatroid(subset, independentSets)` +- `dualMatroidBases(groundSet, bases)` +- `graphicMatroid(graph)` +- `greedyMatroidOptimization(groundSet, independentSets, weights)` + +Test notes: + +- Verify hereditary and exchange axioms. +- Test uniform and graphic matroids. + +--- + +# Suggested implementation order + +1. Fix statistics correctness and ship commented-out statistics helpers. +2. Add missing tests for trigonometry, probability, complex numbers, roots, + conversions, and variance. +3. Build shared complex parsing and formatting helpers, then expand complex + arithmetic. +4. Expand number theory with `gcd`, `lcm`, factorization, modular arithmetic, + and totient. +5. Add core linear algebra utilities such as identity matrices, trace, inverse, + rank, and solving linear systems. +6. Add graph theory basics to support future topology and homotopy examples. +7. Implement numerical analysis root-finding and interpolation helpers. +8. Start Real Analysis with finite/numerical sequence and series helpers. +9. Add Type Theory using a simple expression representation. +10. Add Homotopy Theory and Knot Theory after their representations are + documented with examples. +11. Add the cross-cutting validators and numerical tolerance helpers before + implementing large advanced areas. +12. Build finite algebra, finite topology, graph, matrix, and probability + foundations that can be reused by the 50 additional research areas.