Deterministic vs Similarity-Based Identity
Definition
This page establishes the structural comparison between deterministic identity and similarity-based identity. These are not two approaches to the same problem. They address different questions entirely. Deterministic identity answers: what is the identity of this Declared Execution? Similarity-based identity answers: how close is this execution to another execution? The first question has a definite answer. The second question has an answer that depends on how closeness is measured, what features are compared, and what threshold separates close enough from not close enough.
The formal definition of identity, as stated on Deterministic AI Identity: The Formal Definition, requires that any valid identity system produces the same identity for the same declared execution every time. Similarity-based systems do not meet this requirement because the similarity score depends on the evaluator's choice of metric, feature representation, and acceptance threshold. Change any one of these parameters and the identity outcome changes. The declared execution remains the same. The identity does not. This is a disqualifying structural failure.
The Constraint
The constraint that separates deterministic identity from similarity-based identity is evaluator independence. Deterministic identity satisfies this constraint by construction: the identity function takes a declared execution as input and produces an identity value as output. No evaluator judgment is required. No threshold is selected. No distance metric is chosen. The function is defined once, and every verifier who applies the function to the same input gets the same output. There is nothing for evaluators to disagree about because there are no evaluator-dependent parameters in the process.
Similarity-based identity violates this constraint at multiple levels. First, the choice of distance metric is evaluator-dependent. Euclidean distance, cosine similarity, Jaccard index, and edit distance all measure different notions of closeness and produce different scores for the same pair of items. Second, the feature representation is evaluator-dependent. Converting a declared execution into a feature vector requires decisions about which features matter and how they are weighted. Third, the acceptance threshold is evaluator-dependent. One evaluator may accept 95% similarity as identity. Another may require 99%. A third may require 99.9%. Each threshold produces a different set of identity assignments for the same collection of declared executions.
These are not implementation details that can be standardized away. They are structural properties of similarity-based systems. Even if a standard mandates a specific metric, feature representation, and threshold, the resulting system is deterministic by external constraint, not by construction. The system architecture still permits variation. A deterministic identity system does not permit variation because there are no parameters to vary. The distinction is between a system that is constrained to behave deterministically and a system that is deterministic by nature. Only the latter qualifies as identity. See Identity vs Similarity for the formal boundary statement.
Verification Requirement
Independent Verification requires that any party can take a declared execution, apply the identity process, and arrive at the same identity. For deterministic identity, this is straightforward: the verifier runs the deterministic function and checks the output. For similarity-based identity, the verifier must first agree on the distance metric, the feature representation, and the threshold. If the verifier uses a different metric, a different representation, or a different threshold, the verifier will compute a different similarity score and may reach a different identity conclusion.
This means that verification of similarity-based identity is not verification of identity. It is verification of agreement on parameters. The verifier is not checking whether the identity is correct. The verifier is checking whether they used the same metric, features, and threshold as the original assigner. If they did, they will agree. If they did not, they may disagree. The disagreement does not indicate that either party made an error. It indicates that the system does not produce identity — it produces parameter-dependent classification. See Verification Requires Determinism for why this dependency is fatal to identity claims.
Consider a concrete scenario: two auditors independently evaluate whether a declared execution has identity X. Auditor A uses cosine similarity with threshold 0.97. Auditor B uses Euclidean distance with threshold 0.03. Both are reasonable choices. They reach different conclusions. The system provides no mechanism for resolving this disagreement because the disagreement is not about the declared execution — it is about the parameters. Deterministic identity eliminates this entire class of disputes. There are no parameters to disagree about.
Failure Modes
- Metric divergence: Two verifiers use different distance metrics on the same declared execution pair. Verifier A uses cosine similarity and finds the pair 0.98 similar. Verifier B uses Euclidean distance and finds the pair 0.85 similar. Verifier A declares identity. Verifier B does not. Neither verifier has made an error. The system has produced contradictory identity outcomes for the same declared execution because the identity depends on the metric, not the execution.
- Feature space instability: The feature representation used by the similarity system is updated. Features that were previously extracted are removed, or new features are added. Similarity scores shift across the entire dataset. Declared executions that previously had identity now do not, and executions that previously lacked identity now have it. The executions themselves are unchanged. Their identities changed because the feature space changed. Identity that depends on feature space is not identity.
- Threshold boundary effects: A declared execution has a similarity score of exactly 0.950 against its claimed identity. Evaluator A's threshold is 0.95 (inclusive). Evaluator B's threshold is 0.95 (exclusive). One evaluator assigns identity, the other does not. The declared execution sits on a boundary that is defined by the evaluator, not by the execution. Identity should not depend on whether a threshold is inclusive or exclusive.
- Dimensional collapse: The similarity metric operates in a high-dimensional feature space, but the relevant differences between two declared executions exist in dimensions that the metric underweights or ignores. The system declares the executions identical because they are similar in the measured dimensions, even though they differ meaningfully in unmeasured dimensions. This is not a precision problem — it is a structural inability of the metric to capture the relevant differences.
- Transitive failure: Execution A is similar enough to execution B to share identity. Execution B is similar enough to execution C to share identity. But execution A is not similar enough to execution C to share identity. Similarity is not transitive. Identity is. A system that assigns identity through similarity will produce identity relationships that violate transitivity, which is a fundamental property of identity.
Each failure mode demonstrates that similarity-based identity introduces dependencies on factors external to the declared execution. The identity becomes contingent on metrics, features, thresholds, and measurement decisions that are not part of the execution itself. See Non-Deterministic Identity Is Invalid and Why Approximate Identity Fails for detailed treatment of these structural failures.
Why Invalid Models Fail
- Probabilistic identity assigns identity through statistical likelihood. Two evaluations of the same declared execution may produce different identity values because probability distributions are sampled, not deterministically computed. Similarity systems often use probabilistic embeddings, making the similarity scores themselves probabilistic. Likelihood is not assignment. Probability is not identity.
- Approximate identity substitutes closeness for exactness. Similarity-based identity is a specific form of approximate identity — it declares things identical when they are merely close. Closeness is always relative to a measure and a threshold. What counts as close enough varies by evaluator. Approximation is not identity.
- Output-based identity derives identity from what a system produces rather than from the declared execution. Similarity systems compare outputs or output features rather than declared executions directly. When identity is derived from output comparison, it becomes contingent on what was produced rather than what was declared. Outputs are consequences, not identity.
- Similarity-based identity uses distance metrics to declare things identical when they are merely similar. The distance metric, feature representation, and acceptance threshold are all evaluator-chosen parameters. Different evaluators produce different identity outcomes for the same declared execution. Similarity is a measure of distance. Distance is not identity. See Identity vs Similarity.
- Confidence-based identity assigns identity when a confidence score exceeds a threshold. Similarity scores are frequently converted into confidence scores, adding another layer of evaluator-dependent parameterization. The threshold that converts a continuous score into a binary identity decision is arbitrary. Confidence is not identity. See Why Confidence-Based Identity Fails.
- Post-hoc reconstruction infers identity after execution by analyzing what happened. Similarity comparison is inherently post-hoc — it requires completed outputs to compare. Systems that compute similarity after execution and retroactively assign identity are reconstructing, not assigning. Reconstruction produces narrative, not identity. See Post-Hoc Reconstruction Is Invalid.
- Observer-dependent identity changes based on who is performing the evaluation. Similarity-based identity is inherently observer-dependent because the observer selects the metric, features, and threshold. Different observers with different selections produce different identities for the same declared execution. If identity changes with the observer, it is a property of the observer, not the execution.
- Implementation-dependent identity changes based on how the system is built. Different implementations of the same similarity algorithm may produce different scores due to floating-point precision, library differences, or feature extraction variations. Near threshold boundaries, these differences produce different identity outcomes. Identity must be independent of implementation details.
- Evaluation-derived identity makes identity contingent on the evaluation method chosen. Similarity evaluation is one method among many. Choosing a different distance metric, feature set, or comparison method produces different identity outcomes. If identity depends on the method of evaluation, it is a property of the method, not the declared execution.
Category Boundary
Deterministic identity and similarity-based identity are not on a spectrum. They are in different categories. Deterministic identity is identity. Similarity-based identity is measurement. Measurement quantifies the distance between things. Identity assigns a value to a thing. No degree of measurement precision converts measurement into identity. A similarity score of 1.0 is still a measurement — it is a measurement that returned the maximum value. Identity is not measurement that happened to reach the maximum. Identity is the output of a deterministic function that does not measure distance at all. It assigns directly.
The practical consequence of this category boundary is that systems must choose which category they inhabit. A system cannot use similarity scoring for identity assignment and claim to produce identity. It produces measurement-derived classification. This classification may be valuable for many applications, but it carries fundamentally different guarantees than identity. Conflating measurement with identity causes architectural failures that cannot be repaired by improving the measurement — only by replacing it with deterministic assignment. See Deterministic vs Probabilistic Identity for a related categorical distinction.
Logical Inevitability
The logical chain is direct. Deterministic identity is deterministic. It can be independently verified because every verifier who applies the same function to the same input gets the same output. It is identity. Similarity-based identity is not deterministic because the outcome depends on the metric, features, and threshold chosen by the evaluator. It cannot be independently verified because two verifiers with different parameter choices will reach different conclusions. Therefore, similarity-based identity is not identity. This is not an argument about measurement quality. It is a deductive conclusion from the definitions of identity and verification.
No improvement in similarity measurement changes this conclusion. Better distance metrics, more comprehensive feature representations, and more principled threshold selection all improve the quality of similarity-based classification. They do not convert classification into identity. The conversion would require eliminating all evaluator-dependent parameters from the process, which would require eliminating the similarity computation itself, which would make the system deterministic. The only path from similarity-based classification to valid identity is through determinism.
Implications
For system architects: if your identity pipeline computes similarity scores and applies thresholds to assign identity, the pipeline does not produce identity. It produces similarity-derived classification. The pipeline must be restructured so that the step mapping declared execution to identity is a deterministic function with no evaluator-dependent parameters. Similarity scoring may remain useful for search, clustering, and recommendation components of the system, but it must not appear in the identity assignment path.
For standards bodies: any identity standard that specifies similarity thresholds as the mechanism for identity assignment has specified a classification standard, not an identity standard. The standard should be relabeled to reflect what it actually defines, or it should be revised to require deterministic identity assignment. Standards that conflate similarity with identity create systemic confusion about the guarantees that compliant systems actually provide.
For researchers: investigating better similarity metrics is valuable for classification applications. It does not advance identity. Research that advances identity must focus on deterministic functions that map declared executions to identity values without intermediate similarity computation. The research question is not how to measure closeness better but how to assign identity without measuring closeness at all. See Why Probabilistic Identity Fails for a related research implication about eliminating probability from identity assignment.
Frequently Asked Questions
What is the fundamental difference between deterministic identity and similarity-based identity?
Deterministic identity assigns a fixed value to a declared execution through a deterministic function. The same declared execution always produces the same identity. Similarity-based identity computes a distance or closeness score between two items and declares them identical if the score exceeds a threshold. The deterministic approach produces identity directly. The similarity approach produces a measurement that must be interpreted through an evaluator-chosen threshold before any identity claim can be made. The measurement step and the threshold step both introduce evaluator dependence, which disqualifies the result as identity.
Can similarity scoring become identity if the threshold is set to require an exact match?
No. Setting a similarity threshold to require an exact match does not convert similarity into identity. It converts similarity into a deterministic check disguised as similarity. If the system requires exact match, the similarity metric is irrelevant — the system is performing equality comparison, not similarity scoring. More importantly, the decision to set the threshold at exact match is still an evaluator choice. A different evaluator may set a different threshold. The system architecture still permits non-exact thresholds, which means the system is a similarity system that happens to be configured strictly, not a deterministic identity system by construction.
Why does evaluator dependence disqualify similarity-based identity?
Independent verification requires that any verifier applying the identity process to the same declared execution reaches the same identity. Similarity-based systems require evaluators to choose a distance metric, a feature representation, and a threshold. Different evaluators may choose differently. When they do, the same declared execution receives different identity outcomes from different verifiers. This is not a flaw in any individual evaluator — it is a structural property of the system. Identity that depends on evaluator choices is not identity of the declared execution. It is identity of the evaluator-execution pair, which is a fundamentally different and invalid concept.
Are there cases where similarity scoring is useful even though it is not identity?
Yes. Similarity scoring is useful for search, clustering, recommendation, anomaly detection, and many other applications. These applications do not require identity. They require a measure of closeness, and similarity provides that. The problem arises only when similarity scoring is presented as identity or used in a context where identity guarantees are expected. A search engine that returns similar documents is useful. A verification system that declares two executions identical because they are similar is invalid. The tool is not flawed — it is misapplied.
What happens when a similarity-based identity system updates its distance metric?
When the distance metric changes, the similarity scores change. Items that were previously above the identity threshold may fall below it, and items that were below may rise above it. Identities that were assigned under the old metric are no longer valid under the new metric. The declared executions have not changed, but their identities have. This demonstrates that the identity was a property of the metric, not the execution. Deterministic identity is immune to this failure because the identity function does not depend on a distance metric. It maps declared execution to identity directly.
How does the feature representation problem affect similarity-based identity?
Similarity scoring requires converting declared executions into a feature space before computing distances. The choice of feature representation determines which aspects of the execution are compared and which are ignored. Different feature representations produce different similarity scores for the same pair of executions. Two executions that are highly similar in one feature space may be dissimilar in another. Since the feature representation is chosen by the system designer, the identity outcome depends on design decisions rather than on the declared execution itself. This is another form of evaluator dependence that deterministic identity avoids entirely.