Is null evaluated to 0 and undefined to NaN on arithmetic expressions? Is it safe or correct to assume this?

Yes, it is. An "arithmetic expression" would use the ToNumber operation:

 Argument Type | Result
 --------------+--------
 Undefined     | NaN
 Null          | +0
 …             |

It is used in the following "arithmetic" expressions:

• prefix/postfix increment and decrement
• the unary + and - operators
• the + operator if none of the two arguments is a string
• subtraction, multiplication, division and modulo operation
• relational operators if not both arguments are strings

It is not used by the equality operators, so null == 0 is false (and null !== 0 anyway)!

Another option is

ClearAll[x, a];
Solve[{a == 25, x^2 == a}, {x, a}]

It gave {} because it needed all variables to solve for (even though we know a=25, it just needed to see a in there.

The distinction between the empty set $\emptyset$ and the number $0$ is similar to that between NULL and ZERO. For example, the set of real solutions (or informally "the solution") to $x^2=-1$ is $\emptyset$, but the solution to $x^2=0$ is $0$.

Your real question seem to be:

Why:

null >= 0; // true

But:

null == 0; // false

What really happens is that the Greater-than-or-equal Operator (>=), performs type coercion (ToPrimitive), with a hint type of Number, actually all the relational operators have this behavior.

null is treated in a special way by the Equals Operator (==). In a brief, it only coerces to undefined:

null == null; // true
null == undefined; // true

Values false, '0', and [] are subject to numeric coercion to zero. Strings coerce to zero when, after trimming whitespace, the result is the empty string ("").

You can see the inner details of this process in the The Abstract Equality Comparison Algorithm and The Abstract Relational Comparison Algorithm.

In Summary:

• Relational Comparison: When ToPrimitive(null, hint: Number) is called, and both values are not type String, ToNumber is called on both. This is the same as adding a + in front, which for null coerces to 0.

This also explains how Date objects can be compared numerically.

As for null >= 0, as ToPrimitive(null, hint: Number) results null.

Null The result equals the input argument (no conversion).

For the "The Abstract Relational Comparison Algorithm" of EcmaScript 5.1, this occurs in step 3.

EcmaScript 2025, 7.2.12 IsLessThan ( x, y, LeftFirst ), step 4 the same effect. (see: https://tc39.es/ecma262/#sec-islessthan)

c. NOTE: Because px and py are primitive values, evaluation order is not important. d. Let nx be ? ToNumeric(px). e. Let ny be ? ToNumeric(py).

• Equality Comparison: only calls ToNumber on Strings, Numbers, and Booleans.

7.1.4 ToNumber ( argument ) The abstract operation ToNumber takes argument argument (an ECMAScript language value) and returns either a normal completion containing a Number or a throw completion. It converts argument to a value of type Number. It performs the following steps when called:

1. If argument is a Number, return argument.
2. If argument is either a Symbol or a BigInt, throw a TypeError exception.
3. If argument is undefined, return NaN.
4. If argument is either null or false, return +0𝔽.
5. If argument is true, return 1𝔽.
6. If argument is a String, return StringToNumber(argument).
7. Assert: argument is an Object.
8. Let primValue be ? ToPrimitive(argument, NUMBER).
9. Assert: primValue is not an Object.
10. Return ? ToNumber(primValue).