Document activation/aggregation behavior found by adversarial review

Add a scaling, clamping, and special-case reference table to
docs/activation.rst covering the 9 activation functions that deviate
from their canonical textbook forms. Previously the only prose in the
file was the introductory sentence "some of these functions are scaled
differently from the canonical versions" — with no indication of which
functions, what scaling factors, or what clamping ranges are used. The
new table documents:

- sigmoid, tanh, sin, softplus input scaling (5x, 2.5x, 5x, and 5x in
  with 0.2x out, respectively) and ±60 input clamping
- gauss ±3.4 input clamp and -5 exponent coefficient
- exp ±60 input clamp
- log 1e-7 input floor (so non-positive inputs return log(1e-7) rather
  than raise ValueError)
- inv ArithmeticError -> 0.0 fallback on division by zero or overflow
- lelu 0.005 leak coefficient explicitly noted as non-standard, with
  a reference to the conventional 0.01 used by PyTorch nn.LeakyReLU
- The 9 remaining activations (relu, elu, selu, identity, clamped,
  abs, hat, square, cube) listed as canonical with no scaling

Add empty-input behavior notes to all 7 aggregation function docs in
docs/module_summaries.rst. Previously these were documented as pure
math formulas (\max(x), \min(x), etc.) with no mention of what the
functions return for an empty input iterable. max, min, maxabs, median,
and mean all have explicit "if x else 0.0" guards in the source; sum
inherits Python's sum([]) = 0 behavior; product inherits reduce's 1.0
initializer. These are deliberate and address a real edge case
(orphaned nodes with no incoming connections), but the behavior was
invisible to anyone reading the docs.

Rewrite the validate_aggregation prose in docs/module_summaries.rst
from the inaccurate "takes at least one argument" to the accurate
"callable with exactly one positional argument", and document the
builtin early-return fallback that mirrors validate_activation's new
behavior. Expand the :raises: clause to enumerate the three conditions
under which InvalidAggregationFunction is raised.

Sphinx build passes: make clean html produces 18 warnings, all of
which are pre-existing in other files (academic_research.rst,
xor_example.rst, genome-interface.rst, installation.rst,
reproduction-interface.rst); none originate in activation.rst or
module_summaries.rst.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: CodeReclaimers

docs/activation.rst

@@ -11,6 +11,43 @@ more of the functions' "interesting" behavior in the region :math:`\left[-1, 1\r
 
 The implementation of these functions can be found in the :py:mod:`activations` module.
 
+The following table summarizes the scaling, clamping, and non-canonical
+behavior of the activation functions that differ from their textbook forms.
+Input ``z`` is clamped to the given range before any output transform is
+applied. Functions not listed below (``relu``, ``elu``, ``selu``, ``identity``,
+``clamped``, ``abs``, ``hat``, ``square``, ``cube``) apply their canonical
+transforms directly with no scaling or clamping.
+
++-------------+--------------------+----------------+------------------------------------------------+
+| Function    | Input clamp        | Scaling        | Transform                                      |
++=============+====================+================+================================================+
+| sigmoid     | ±60 after 5×z      | 5× input       | :math:`1 / (1 + e^{-5z})`                      |
++-------------+--------------------+----------------+------------------------------------------------+
+| tanh        | ±60 after 2.5×z    | 2.5× input     | :math:`\tanh(2.5\,z)`                          |
++-------------+--------------------+----------------+------------------------------------------------+
+| sin         | ±60 after 5×z      | 5× input       | :math:`\sin(5\,z)`                             |
++-------------+--------------------+----------------+------------------------------------------------+
+| gauss       | ±3.4               | −5 in exponent | :math:`e^{-5 z^2}`                             |
++-------------+--------------------+----------------+------------------------------------------------+
+| softplus    | ±60 after 5×z      | 5× in, 0.2× out| :math:`0.2 \log(1 + e^{5z})`                   |
++-------------+--------------------+----------------+------------------------------------------------+
+| exp         | ±60                | none           | :math:`e^{z}`                                  |
++-------------+--------------------+----------------+------------------------------------------------+
+| log         | floor at ``1e-7``  | none           | :math:`\log(\max(10^{-7}, z))` — non-positive  |
+|             |                    |                | inputs yield :math:`\log(10^{-7}) \approx      |
+|             |                    |                | -16.118` rather than ``ValueError``.           |
++-------------+--------------------+----------------+------------------------------------------------+
+| inv         | none               | none           | :math:`1/z`, returning ``0.0`` on              |
+|             |                    |                | ``ArithmeticError`` (e.g. division by zero     |
+|             |                    |                | or overflow).                                  |
++-------------+--------------------+----------------+------------------------------------------------+
+| lelu        | none               | none           | :math:`z` if :math:`z > 0`, otherwise          |
+|             |                    |                | :math:`0.005\,z`. **Note: non-standard leak    |
+|             |                    |                | coefficient** — the conventional leaky ReLU    |
+|             |                    |                | uses ``0.01`` (e.g. PyTorch's                  |
+|             |                    |                | ``nn.LeakyReLU`` default).                     |
++-------------+--------------------+----------------+------------------------------------------------+
+
 abs
 ---
 

docs/module_summaries.rst

@@ -76,57 +76,67 @@ Has the built-in :term:`aggregation functions <aggregation function>`, code for
   .. py:function:: product_aggregation(x)
 
     An adaptation of the multiplication function to take an :pygloss:`iterable`.
+    Returns ``1.0`` for an empty input (the multiplicative identity, from
+    ``reduce``'s initializer).
 
     :param x: The numbers to be multiplied together; takes any ``iterable``.
     :type x: list(:pytypes:`float <typesnumeric>`) or tuple(:pytypes:`float <typesnumeric>`) or set(:pytypes:`float <typesnumeric>`)
-    :return: :math:`\prod(x)`
+    :return: :math:`\prod(x)` for nonempty ``x``, otherwise ``1.0``.
     :rtype: :pytypes:`float <typesnumeric>`
 
   .. py:function:: sum_aggregation(x)
 
-    Probably the most commonly-used aggregation function.
+    Probably the most commonly-used aggregation function. Returns ``0`` for an
+    empty input (via Python's built-in ``sum``).
 
     :param x: The numbers to find the sum of; takes any :pygloss:`iterable`.
     :type x: list(:pytypes:`float <typesnumeric>`) or tuple(:pytypes:`float <typesnumeric>`) or set(:pytypes:`float <typesnumeric>`)
-    :return: :math:`\sum(x)`
+    :return: :math:`\sum(x)` for nonempty ``x``, otherwise ``0``.
     :rtype: :pytypes:`float <typesnumeric>`
 
   .. py:function:: max_aggregation(x)
 
-    Returns the maximum of the inputs.
+    Returns the maximum of the inputs, or ``0.0`` for an empty input (e.g.
+    an orphaned node with no incoming connections).
 
     :param x: The numbers to find the greatest of; takes any :pygloss:`iterable`.
     :type x: list(:pytypes:`float <typesnumeric>`) or tuple(:pytypes:`float <typesnumeric>`) or set(:pytypes:`float <typesnumeric>`)
-    :return: :math:`\max(x)`
+    :return: :math:`\max(x)` for nonempty ``x``, otherwise ``0.0``.
     :rtype: :pytypes:`float <typesnumeric>`
 
   .. py:function:: min_aggregation(x)
 
-    Returns the minimum of the inputs.
+    Returns the minimum of the inputs, or ``0.0`` for an empty input (e.g.
+    an orphaned node with no incoming connections).
 
     :param x: The numbers to find the least of; takes any :pygloss:`iterable`.
     :type x: list(:pytypes:`float <typesnumeric>`) or tuple(:pytypes:`float <typesnumeric>`) or set(:pytypes:`float <typesnumeric>`)
-    :return: :math:`\min(x)`
+    :return: :math:`\min(x)` for nonempty ``x``, otherwise ``0.0``.
     :rtype: :pytypes:`float <typesnumeric>`
 
   .. py:function:: maxabs_aggregation(x)
 
-    Returns the maximum by absolute value, which may be positive or negative. Envisioned as suitable for neural network pooling operations.
+    Returns the maximum by absolute value, which may be positive or negative.
+    Envisioned as suitable for neural network pooling operations. Returns
+    ``0.0`` for an empty input (e.g. an orphaned node with no incoming
+    connections).
 
     :param x: The numbers to find the absolute-value maximum of; takes any :pygloss:`iterable`.
     :type x: list(:pytypes:`float <typesnumeric>`) or tuple(:pytypes:`float <typesnumeric>`) or set(:pytypes:`float <typesnumeric>`)
-    :return: :math:`x_i, i = \text{argmax}\lvert\mathbf{x}\rvert`
+    :return: :math:`x_i, i = \text{argmax}\lvert\mathbf{x}\rvert` for nonempty ``x``, otherwise ``0.0``.
     :rtype: :pytypes:`float <typesnumeric>`
 
     .. versionadded:: 0.92
 
   .. py:function:: median_aggregation(x)
 
-    Returns the :py:func:`median <math_util.median2>` of the inputs.
+    Returns the :py:func:`median <math_util.median2>` of the inputs, or
+    ``0.0`` for an empty input (e.g. an orphaned node with no incoming
+    connections).
 
     :param x: The numbers to find the median of; takes any :pygloss:`iterable`.
     :type x: list(:pytypes:`float <typesnumeric>`) or tuple(:pytypes:`float <typesnumeric>`) or set(:pytypes:`float <typesnumeric>`)
-    :return: The median; if there are an even number of inputs, takes the mean of the middle two.
+    :return: The median for nonempty ``x`` (if there are an even number of inputs, takes the mean of the middle two); otherwise ``0.0``.
     :rtype: :pytypes:`float <typesnumeric>`
 
     .. versionadded:: 0.92
@@ -135,10 +145,11 @@ Has the built-in :term:`aggregation functions <aggregation function>`, code for
 
     Returns the arithmetic mean. Potentially maintains a more stable result than ``sum`` for changing numbers of :term:`enabled`
     :term:`connections <connection>`, which may be good or bad depending on the circumstances; having both available to the algorithm is advised.
+    Returns ``0.0`` for an empty input (e.g. an orphaned node with no incoming connections).
 
     :param x: The numbers to find the mean of; takes any :pygloss:`iterable`.
     :type x: list(:pytypes:`float <typesnumeric>`) or tuple(:pytypes:`float <typesnumeric>`) or set(:pytypes:`float <typesnumeric>`)
-    :return: The arithmetic mean.
+    :return: The arithmetic mean for nonempty ``x``, otherwise ``0.0``.
     :rtype: :pytypes:`float <typesnumeric>`
 
     .. versionadded:: 0.92
@@ -152,11 +163,15 @@ Has the built-in :term:`aggregation functions <aggregation function>`, code for
 
   .. py:function:: validate_aggregation(function)
 
-    Checks to make sure its parameter is a function that takes at least one argument.
+    Checks that ``function`` is callable with exactly one positional argument.
+    Returns early (accepting the callable) for CPython builtins whose
+    signatures cannot be inspected via ``inspect.signature``.
 
     :param function: Object to be checked.
     :type function: :datamodel:`object <objects-values-and-types>`
-    :raises InvalidAggregationFunction: If the object does not pass the tests.
+    :raises InvalidAggregationFunction: If the object is not callable, its
+        signature cannot be inspected (and it is not a builtin), or it cannot
+        be invoked with exactly one positional argument.
 
     .. versionadded:: 0.92