   /// Consult the documentation for those methods for a detailed
   /// description of how the comparison is performed, and how to
   /// choose tolerances for your particular situation.
+  ///
+  /// Mathematical Properties:
+  /// -
+  /// - `isApproximatelyEqual(to:relativeTolerance:)` is _reflexive_ for
+  ///   non-exceptional values (such as NaN).
+  ///
+  /// - `isApproximatelyEqual(to:relativeTolerance:)` is _symmetric_.
+  ///
+  /// - `isApproximatelyEqual(to:relativeTolerance:)` is __not__ _transitive_.
+  ///   Because of this, approximately equality is __not an equivalence relation__,
+  ///   even when restricted to non-exceptional values.
+  ///
+  /// - For any point `a`, the set of values that compare approximately equal to `a` is _convex_.
+  ///   (Under the assumption that the `.magnitude` property implements a valid norm.)
+  ///
+  /// - `isApproximatelyEqual(to:relativeTolerance:)` is _scale invariant_,
+  ///   so long as no underflow or overflow occurs, and no exceptional value is produced
+  ///   by the scaling.
+  ///
+  /// - Parameters:
+  ///   - other: The value to which `self` is compared.
+  ///
   @inlinable @inline(__always)
   public func isApproximatelyEqual(
     to other: Self

  /// |a - b| ≤ rtol * max(|a|,|b|)
  /// ```
  ///
  /// Note that if `absoluteTolerance` is _omitted_,
  /// `relativeTolerance * .leastNormalMagnitude` is used, _not zero_.
  @inlinable
  public func isApproximatelyEqual(
    to other: Self,

  /// ```
  /// |a - b| ≤ max(atol, rtol * max(|a|,|b|))
  /// ```
  /// This is equivalent to saying that the comparison satisfies _either_ the absolute tolerance,
  /// _or_ the relative tolerance; it need not satisfy both:
  /// ```
  /// |a - b| ≤ atol OR |a - b| ≤ rtol * max(|a|,|b|)
  /// ```
  ///
  /// If `relativeTolerance` is omitted or is zero, a pure absolute tolerance is used:
  /// ```
  /// |a - b| ≤ atol
  /// ```
