余弦距离也叫距离，为什么会违反三角不等式？

"""Cosine dissimilarity, angular distance and chord distance.

Python 3.10+; standard library only. No embedding model or ANN benchmark.
"""
import json
import math
import platform
import random
from pathlib import Path


def unit(vector):
    if not vector or not all(math.isfinite(v) for v in vector):
        raise ValueError("vector must be nonempty and finite")
    scale = max(abs(v) for v in vector)
    if scale == 0:
        raise ValueError("zero vector has no direction")
    scaled = [v / scale for v in vector]
    norm = math.hypot(*scaled)
    return [v / norm for v in scaled]


def clip_cosine(value):
    if not math.isfinite(value) or value < -1.0 - 1e-12 or value > 1.0 + 1e-12:
        raise ValueError("cosine outside the roundoff tolerance")
    return max(-1.0, min(1.0, value))


def distances(a, b):
    if len(a) != len(b):
        raise ValueError("vector dimensions must match")
    u, v = unit(a), unit(b)
    cosine = clip_cosine(math.fsum(x * y for x, y in zip(u, v)))
    # The direct coordinate difference retains more detail for nearby directions.
    return 1.0 - cosine, math.acos(cosine), math.dist(u, v)


def direction(degrees):
    angle = math.radians(degrees)
    return [math.cos(angle), math.sin(angle)]


def angle_reference(degrees_a, degrees_b):
    """Independent angular reference using original generating angles, not dot products."""
    delta = math.radians(degrees_a - degrees_b)
    return abs(math.atan2(math.sin(delta), math.cos(delta)))


def main():
    checks = []

    def check(name, condition):
        if not condition:
            raise AssertionError(name)
        checks.append(name)

    a, b, c = [direction(d) for d in [0, 60, 120]]
    ab, bc, ac = distances(a, b), distances(b, c), distances(a, c)
    check("cosine triangle inequality counterexample", ac[0] > ab[0] + bc[0] + 0.1)
    check("angular triangle equality", math.isclose(ac[1], ab[1] + bc[1], abs_tol=1e-12))
    check("chord triangle inequality", ac[2] <= ab[2] + bc[2] + 1e-12)
    check("cosine distance 0 to 120", math.isclose(ac[0], 1.5, abs_tol=1e-12))
    check("chord distance 0 to 120", math.isclose(ac[2], math.sqrt(3), abs_tol=1e-12))

    rng = random.Random(20261018)
    max_angle_error = max_chord_error = 0.0
    for i in range(256):
        da, db = rng.uniform(-180, 180), rng.uniform(-180, 180)
        measured = distances(direction(da), direction(db))
        theta = angle_reference(da, db)
        chord_ref = 2.0 * math.sin(theta / 2.0)
        max_angle_error = max(max_angle_error, abs(measured[1] - theta))
        max_chord_error = max(max_chord_error, abs(measured[2] - chord_ref))
        check("angle reference " + str(i), math.isclose(measured[1], theta, rel_tol=0, abs_tol=1e-11))
        check("chord reference " + str(i), math.isclose(measured[2], chord_ref, rel_tol=0, abs_tol=1e-12))
        check("squared chord identity " + str(i), math.isclose(measured[2] ** 2, 2 * measured[0], abs_tol=1e-12))

    degrees = [12, 73, 38, 145, -20]
    values = {d: distances(direction(0), direction(d)) for d in degrees}
    rankings = [[d for d in sorted(degrees, key=lambda d: values[d][j])] for j in range(3)]
    check("same nearest-neighbor ordering", rankings[0] == rankings[1] == rankings[2])
    check("direction equivalence", distances([1, 0], [7, 0]) == (0.0, 0.0, 0.0))
    check("opposite directions are distinct", math.isclose(distances([1, 0], [-1, 0])[1], math.pi))
    check("large finite input can be normalized", math.isclose(math.hypot(*unit([1e308] * 4)), 1.0))
    check("small finite input can be normalized", unit([1e-300, 0]) == [1.0, 0.0])
    check("small upper overshoot is clipped", clip_cosine(1 + 2e-16) == 1.0)
    check("small lower overshoot is clipped", clip_cosine(-1 - 2e-16) == -1.0)

    # Query=120 degrees, pivot=0, candidate=60. A false metric assumption loses a valid result.
    radius = 0.75
    false_lower_bound = abs(ac[0] - ab[0])
    actual_distance = bc[0]
    false_prune = false_lower_bound > radius and actual_distance <= radius
    check("unsafe cosine pruning drops an in-radius point", false_prune)
    transformed_radii = [math.acos(1 - radius), math.sqrt(2 * radius)]
    metric_lower_bounds = [abs(ac[j] - ab[j]) for j in [1, 2]]
    check("angular lower bound keeps point", metric_lower_bounds[0] <= transformed_radii[0])
    check("chord lower bound keeps point", metric_lower_bounds[1] <= transformed_radii[1])

    invalid_vectors = [([], []), ([0, 0], [1, 0]), ([math.inf, 0], [1, 0]),
                       ([math.nan, 0], [1, 0]), ([1], [1, 0])]
    for i, (left, right) in enumerate(invalid_vectors):
        try:
            distances(left, right)
        except ValueError:
            check("reject invalid vector " + str(i), True)
        else:
            check("reject invalid vector " + str(i), False)
    for value in [1.01, -1.01, math.nan]:
        try:
            clip_cosine(value)
        except ValueError:
            check("reject invalid cosine " + str(value), True)
        else:
            check("reject invalid cosine " + str(value), False)

    near = distances([1, 0], [1, 1e-12])
    check("direct chord retains a tiny separation", near[2] > 0)
    report = {
        "python_version": platform.python_version(), "checks": len(checks), "passed": checks,
        "names": ["cosine_dissimilarity", "angular_radians", "chord"],
        "d_0_60": ab, "d_60_120": bc, "d_0_120": ac, "rankings_degrees": rankings,
        "reference_pairs": 256, "max_angular_reference_error": max_angle_error,
        "max_chord_reference_error": max_chord_error,
        "pruning": {"cosine_radius": radius, "assumed_lower_bound": false_lower_bound,
                    "actual_distance": actual_distance, "false_prune": false_prune,
                    "metric_lower_bounds": metric_lower_bounds, "transformed_radii": transformed_radii},
        "near_parallel_distances": near,
        "scope": "Synthetic directions only; no embedding model, index, or ANN performance benchmark."
    }
    Path("report.json").write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
    for j, name in enumerate(report["names"]):
        print(f"{name}: d(0,120)={ac[j]:.6f} via_60={ab[j] + bc[j]:.6f}")
    print("same_ranking=" + str(rankings[0]))
    print(f"unsafe_pruning: lower_bound={false_lower_bound:.6f} radius={radius:.6f} actual={actual_distance:.6f}")
    print(f"near_parallel: angular={near[1]:.3e} direct_chord={near[2]:.3e}")
    print(f"reference_pairs=256 checks={len(checks)} passed; report.json written")


if __name__ == "__main__":
    main()