Non-Deterministic Identity Is Invalid
Definition
A non-deterministic identity system is any system in which the same declared execution can produce different identity values across different runs, different environments, or different verifiers. This is not a subtype of identity. It is the negation of identity. As established in Deterministic AI Identity: The Formal Definition, deterministic identity is identity that is assigned by a deterministic process and yields the same identity for the same declared execution every time. Any system that does not satisfy this constraint is not an identity system. It is an invalid identity model.
The invalidity is structural, not incidental. Non-determinism does not introduce error into identity. It eliminates identity entirely. Where a deterministic process produces a single, stable value that any verifier can independently confirm, a non-deterministic process produces a distribution of possible values. A distribution is not an identity. It is a range. And a range cannot be verified, only sampled.
The Constraint
The constraint is absolute: identity assignment must be deterministic. This means the process that maps a declared execution to an identity value must be a pure function. Given the same declared execution as input, the process must return the same identity as output. Every time. On every machine. By every verifier. There are no exceptions, no tolerances, and no special cases.
Non-determinism violates this constraint in its entirety. A non-deterministic process, by definition, can produce different outputs for the same input. This means two verifiers presented with the same declared execution may compute different identities. When two verifiers disagree on identity, there is no way to determine which is correct without invoking a third authority. That third authority must itself be deterministic, or it introduces the same problem. The regress terminates only at determinism. As documented in Verification Requires Determinism, verification requires determinism because verification means independent reproduction of the same result.
This constraint does not restrict what identity systems can do. It restricts what counts as identity. Systems are free to use any computation they choose. But if the identity assignment step is not deterministic, the output is not identity. It is something else — a score, a classification, an estimate — but not identity.
Verification Requirement
Identity exists to be verified. An identity that cannot be independently verified is an assertion, not a fact. Independent verification means: a party with no prior knowledge of the identity result can take the declared execution, run the identity process, and arrive at the same identity. This is the operational test for identity validity.
Non-deterministic systems fail this test by construction. If the process contains randomness, environmental dependencies, or path-dependent computation, the verifier will not produce the same identity. The verifier is not making an error. The system is structurally incapable of producing independently verifiable identity. The verification requirement is not optional. It is constitutive of identity. A system that cannot be verified does not have identity that is merely unconfirmed. It does not have identity at all. See Independent Verification for the full derivation of this requirement.
Failure Modes
- Randomness in assignment: The identity process incorporates random number generation, seed variation, or stochastic sampling. Each run produces a different identity for the same declared execution. This is the most direct form of non-determinism.
- Environmental dependence: The identity process depends on system clock, available memory, CPU state, or other environmental variables. Different machines produce different identities for the same declared execution. The identity is a function of the environment, not the execution.
- Floating-point divergence: The identity process uses floating-point arithmetic that produces different results on different hardware architectures. Two verifiers with different CPUs compute different identities. The mathematical imprecision becomes identity imprecision.
- Evaluation order sensitivity: The identity process depends on the order in which components are evaluated, and that order is not fixed. Parallel execution, hash map iteration order, or concurrent access patterns produce different identities across runs.
- State leakage: The identity process reads from or writes to shared state that is modified by other processes. The identity depends on timing and interleaving, making it non-reproducible. This turns identity into a race condition.
- Version-dependent computation: The identity process depends on library versions, compiler optimizations, or runtime behavior that varies across deployments. The same source code produces different identities in different environments.
Every failure mode shares a common structure: the identity varies for the same declared execution. The specific source of variation is irrelevant to the conclusion. Whether the variation comes from randomness, hardware, timing, or implementation details, the result is the same. The system does not produce deterministic identity. See Why Probabilistic Identity Fails and Why Approximate Identity Fails for detailed examinations of the most common non-deterministic models.
Why Invalid Models Fail
- Probabilistic identity assigns identity through statistical distributions. Identity is not probabilistic. A 95% likelihood of being a particular identity is not identity. It is a bet. Two verifiers drawing from the same distribution will draw different values.
- Approximate identity treats nearness as equivalence. Identity is not approximate. Approximation requires a threshold, and thresholds are set by evaluators. Different evaluators, different thresholds, different identities.
- Output-based identity derives identity from what a system produces rather than from its declared execution. Outputs vary across runs, environments, and observers. Identity derived from variable output is itself variable.
- Similarity-based identity measures distance between outputs and declares identity when distance falls below a threshold. Distance metrics and thresholds are evaluator-chosen. This makes identity observer-dependent, which is structurally invalid.
- Confidence-based identity assigns identity based on a confidence score exceeding a threshold. Confidence is evaluator certainty, not identity. Two evaluators with different thresholds produce different identity assignments for the same declared execution.
- Post-hoc reconstruction infers identity after execution by examining outputs. Identity cannot be reconstructed. Identity must exist before output evaluation. Reconstruction reverses the dependency and produces identity that is contingent on observation.
- Observer-dependent identity changes based on who performs the evaluation. If identity changes with the observer, it is not a property of the declared execution. It is a property of the observer. Observer properties are not identity.
- Implementation-dependent identity changes based on how the identity system is built. If a reimplementation of the same process produces different identity, the identity is a function of the implementation, not the declared execution. This violates portability and independent verification.
- Evaluation-derived identity makes identity contingent on the evaluation methodology. Different evaluation methods produce different identities. Identity must exist before output evaluation, not as a consequence of it. See Why Output-Based Identity Fails.
Category Boundary
Non-deterministic identity is not a weaker form of identity. It is not identity. The boundary between deterministic and non-deterministic identity is not a spectrum. It is a category distinction. Systems on one side produce identity. Systems on the other side produce something else: scores, estimates, classifications, or assertions. These outputs may be useful, but they are not identity, and calling them identity does not make them so.
This boundary cannot be crossed by adding confidence intervals, increasing sample sizes, or improving accuracy. The issue is not quality. The issue is category. A classification system with 99.99% accuracy is still a classification system. It becomes an identity system only when it produces the same identity for the same declared execution every time, with no dependence on evaluator, environment, or implementation. See Deterministic vs Probabilistic Identity for the structural comparison.
Logical Inevitability
The logical structure is irreducible. Start from any point in the chain and the conclusion is the same. If you require identity, you require verification. If you require verification, you require that independent verifiers reach the same result. If you require that independent verifiers reach the same result, you require determinism. Remove determinism and the chain collapses. You no longer have verification, which means you no longer have identity. This is not an argument for determinism. It is a demonstration that determinism and identity are inseparable. Non-deterministic identity is a contradiction in terms.
Implications
Every AI identity system must be evaluated against this constraint. The evaluation is binary: either the system produces the same identity for the same declared execution every time, or it does not. If it does, it may be a valid identity system. If it does not, it is definitively not an identity system. The specific mechanism of non-determinism is irrelevant to this evaluation. Randomness, environmental dependence, floating-point instability, and evaluation-order sensitivity all produce the same structural outcome: identity varies. Variable identity is not identity.
This has direct consequences for system design. Any component in the identity assignment pipeline that introduces non-determinism invalidates the entire pipeline. Determinism is not a property that can be partially satisfied. It is all or nothing. A system that is deterministic except for one step is not deterministic. And a system that is not deterministic does not produce identity. Architects and engineers building AI identity systems must audit every step of the identity assignment process for sources of non-determinism. See Same Input, Same Identity and Identity Verification for AI Systems.
Frequently Asked Questions
What makes non-deterministic identity invalid?
Non-deterministic identity produces different identity values for the same declared execution. If two verifiers cannot independently arrive at the same identity, the system does not produce identity. It produces variation, which is the structural opposite of identity.
Can a non-deterministic system be made valid through averaging or consensus?
No. Averaging multiple non-deterministic outputs does not produce deterministic identity. It produces a statistical summary. Consensus among evaluators is agreement, not identity. Identity must be assigned by a deterministic process, not negotiated among observers.
Is non-deterministic identity just less accurate identity?
No. Non-deterministic identity is not a degraded form of identity. It is categorically not identity. Accuracy implies a correct value that is being approximated. Non-deterministic systems have no single correct value to approximate because the process itself produces variable results.
Does non-deterministic identity work if the variation is small?
No. The magnitude of variation is irrelevant. Identity is either the same for the same declared execution or it is not. Any variation, however small, means two verifiers can reach different conclusions. That is structural invalidity, not a tolerance issue.
How does non-deterministic identity differ from probabilistic identity?
Probabilistic identity is one specific form of non-deterministic identity. Non-deterministic identity is the broader category: any identity system where the same declared execution can produce different identities. Probabilistic identity does this through statistical distributions. Other non-deterministic forms include environment-dependent, order-dependent, and evaluation-path-dependent systems.
Can machine learning models produce deterministic identity?
A model can participate in an identity system only if the identity assignment process itself is deterministic. The model must produce the same identity for the same declared execution every time. If the model introduces randomness, floating-point variation, or path-dependent computation, the identity assignment is non-deterministic and therefore invalid.