NOT

What it does

NOT(logical)

NOT returns the logical complement of the truthiness of its single argument.

The rule is two steps, and both are worth naming:

1. Truthiness. A Logical is itself. A Number is false when it is exactly 0 and true otherwise. Anything that is neither must first coerce to a number, and text that does not read as a number fails.
2. Complement. Return TRUE if step 1 produced false, FALSE if it produced true.

NOT is the only function in Excel's logical group with a fixed arity of exactly one. It is not a reducer, so none of the scan and skip machinery of AND, OR, and XOR applies to it: there is no "ignore text in a range" rule, because there is no range scan.

Arguments

NOT(logical)

• The argument is a value to test for truthiness, not specifically a logical value. Numbers are admissible and are tested against zero.

The commonly misunderstood point is that NOT is not a filter or a set complement. NOT(A1:A3) is not "everything except those cells"; it is a single-value test whose behaviour on a multi-cell reference is a shape question, addressed below.

Try it

Quirks

Result and edge cases

Returns a Logical, or an Error.

• Zero. NOT(0) is TRUE. This is the case people rely on for "is this blank-or-zero".
• Any nonzero number. FALSE, including negatives and very large magnitudes. There is no tolerance band around zero.
• Error input. Propagates.
• Arrays. NOT is a scalar-shaped function; how a multi-cell argument is handled is governed by the lifting rules in Coercion and lifting rather than by anything specific to NOT.

Errors

How to implement

Notes for implementers

1. Do not share the reducer's item classifier. AND's classifier maps blank and skipped text to "contributes nothing"; NOT has no such bucket and must fail instead. Reusing one function for both is the natural refactor and it silently changes NOT's blank behaviour.
2. The zero test must be an exact IEEE comparison against 0.0. Negative zero compares equal to zero and therefore yields TRUE — worth a vector when a suite exists.
3. NOT has no non-finite path: its result is always a logical or an error, so the publication policy is the default one (NonFinite::Allow in the classification axes) and there is no #NUM! route.

Rust code

CatalogueEntry {
    id: NOT,
    spelling: "NOT",
    notation: Notation::Call,
    arity: CallableArityShape::exact(1),
    parameters: &[Parameter::value("logical")],
    demand: ArgumentDemand::Eager,
    kernel: Kernel::Eager(not),
}

/// NOT: its argument read as a logical (as IF reads its condition), reversed; the argument's
/// error is the result. An array argument, over which NOT lifts, and a callable are refused as not
/// modelled.
fn not(
    arguments: &[CalcValue],
    services: &mut EvalServices<'_>,
) -> Result<CalcValue, FunctionFault> {
    let site = Site::new(NOT, services);
    Site::finish(
        site.scalar_operands(arguments)
            .and_then(|()| not_callable(&site, 0, &arguments[0]))
            .and_then(|()| {
                let logical = site.argument(0, coerce::logical(&arguments[0]))?;
                Ok(CalcValue::logical(!logical))
            }),
    )
}

No implementation has been published with a Handbook test suite for this function.

Version differences

The recorded environments below distinguish a reading from a same-input comparison. Counts describe captured inputs in each environment; overlapping captures and comparisons are not totals of unique worksheet calls.

The record contains no same-input comparison between these environments. Reading different inputs on different builds does not establish either a version change or cross-build agreement.

Recorded environments and comparison details.

Alternatives

Relationships

• AND, OR, XOR are the variadic members of the same group; NOT is the unary one, and the asymmetry in blank handling between them is real, not an editorial simplification.
• De Morgan's laws relate NOT to AND and OR for the well-classified cases. They do not extend to the family's #VALUE!-on-empty-scan behaviour, which has no algebraic counterpart: NOT(AND(range)) and OR(NOT-of-each) can differ when the range contains no truth values.
• <> (FUNC.OP_NOT_EQUAL) is a comparison, not a complement, and is what readers usually want when they write NOT(a = b).
• IFERROR and ISERROR are what readers want when they write NOT(ISERROR(...)); the double-negation idiom NOT(ISERROR(x)) is exactly ISNUMBER-style inspection and is often better written with the positive test.

Named variants

No named variants are recorded yet.