Declared Execution
Definition
Declared execution is the explicit specification of what a system will execute. It is the input to the identity function. In a deterministic identity system, identity is assigned to declared execution and to nothing else. Not to observed output. Not to inferred behavior. Not to evaluator judgment. The declared execution must be explicit, complete, and unambiguous. This is a structural requirement of Deterministic AI Identity: The Formal Definition.
The concept of declared execution establishes the boundary between what the system intends to do and what the system actually does. Identity belongs to intention, not outcome. A system that declares the same execution must receive the same identity, regardless of whether the outputs of those executions differ. Outputs are downstream consequences. Declared execution is the upstream specification. Identity assignment must operate on the upstream specification because that is the only component that can be deterministically evaluated.
The Constraint
The constraint is that declared execution must be the sole input to the identity function. No other variable is permitted to influence the identity outcome. If identity depends on anything other than the declared execution, the identity system has introduced a non-deterministic dependency. The system cannot guarantee the same identity for the same declared execution if external factors participate in the identity calculation.
This means declared execution must be self-contained. It must include every parameter, every specification, and every constraint that the identity function requires. If the declared execution references external state, that state must be resolved and incorporated into the declaration before identity assignment. If external state changes between identity assignments, and that change affects the identity, the declared execution was not self-contained. It was dependent. Dependent declarations violate the same-input-same-identity requirement established in Same Input, Same Identity.
Declared execution must also be unambiguous. Two evaluators reading the same declared execution must interpret it identically. If the declared execution can be interpreted in multiple ways, the identity function cannot be deterministic because different interpretations lead to different identities. Ambiguity in the input produces ambiguity in the output. Ambiguity in identity is the absence of identity.
Verification Requirement
Independent Verification depends entirely on the quality of the declared execution. A verifier must be able to take the declared execution, run the identity function, and reach the same identity. This is only possible if the declared execution is explicit and complete. If the declared execution is vague, partial, or dependent on external context, the verifier cannot reproduce the identity because the verifier does not have access to the same input that the original assigner used.
Verification is not reconstruction. A verifier does not examine outputs and work backward to guess what the declared execution was. A verifier takes the declared execution as given and runs the identity function forward. This is the operational distinction between verification and reconstruction. Verification operates on declared execution. Reconstruction operates on observed output. Verification is deterministic. Reconstruction is interpretive. See Post-Hoc Reconstruction Is Invalid.
The verification requirement also imposes a constraint on the format of declared execution. It must be machine-readable, precisely defined, and free of implicit assumptions. If any part of the declared execution requires human interpretation, independent verification degrades into opinion. Different verifiers will interpret the ambiguous portion differently and reach different identities. The constraint established in Verification Requires Determinism demands that the declared execution eliminates all sources of non-determinism, including interpretive ambiguity.
Failure Modes
- Incomplete declaration: The declared execution omits parameters that the identity function requires. Different verifiers fill in the missing parameters differently, producing different identities.
- Ambiguous specification: The declared execution uses vague or natural-language descriptions that can be interpreted in multiple ways. Interpretation variance produces identity variance.
- External dependency: The declared execution references external state that is not incorporated into the declaration. If the external state changes, the identity changes, violating the same-input-same-identity constraint.
- Implicit assumption: The declared execution assumes context that is not explicitly stated. Different evaluators operate under different assumptions, producing different identities for what they believe is the same input.
- Temporal contamination: The declared execution includes time-dependent references that resolve to different values at different times. The same declared execution produces different inputs to the identity function at different points in time.
- Output conflation: The system treats observed outputs as part of the declared execution, conflating what the system is specified to do with what the system actually does. See Why Output-Based Identity Fails.
Why Invalid Models Fail
- Probabilistic identity does not operate on declared execution. It operates on probability distributions derived from observed behavior. Probability is not a specification. It is a statistical summary. See Why Probabilistic Identity Fails.
- Approximate identity does not require explicit declared execution. It accepts "close enough" inputs as equivalent. Approximation dissolves the boundary between distinct declared executions, collapsing different specifications into a single identity. See Why Approximate Identity Fails.
- Output-based identity assigns identity to outputs, not to declared execution. This reverses the direction of identity assignment. Identity must be assigned to the input, not the output.
- Similarity-based identity assigns identity based on how similar two executions appear, not on whether they share the same declared execution. Similarity is a gradient. Identity is binary.
- Confidence-based identity assigns identity based on evaluator certainty about the execution, not on the declared execution itself. Confidence is a property of the evaluator, not a property of the declaration. See Why Confidence-Based Identity Fails.
- Post-hoc reconstruction infers the declared execution after the fact by examining outputs. The reconstructed declaration is not the actual declaration. It is a guess derived from downstream results.
- Observer-dependent identity changes based on who observes the execution, not on what was declared. Different observers produce different identities for the same declared execution because identity is a function of the observer, not the declaration.
- Implementation-dependent identity changes based on how the system is implemented, not on what was declared. The same declared execution produces different identities on different implementations, violating determinism.
- Evaluation-derived identity assigns identity based on how the system is evaluated, not on what was declared. Evaluation methodology varies by evaluator, so identity varies by evaluator. This is not identity.
Category Boundary
Declared execution is not observed behavior. Observed behavior is what a system actually does when it runs. Declared execution is what a system is specified to do before it runs. These are categorically different. Systems that derive identity from observed behavior are not using declared execution. They are using output. Output is not input. Behavior is not specification. See Identity vs Output.
Logical Inevitability
Declared execution is the foundation of this inevitability. Identity must be deterministic. Determinism requires a fixed input. The fixed input is the declared execution. If the declared execution is ambiguous, the input is not fixed. If the input is not fixed, identity is not deterministic. If identity is not deterministic, it cannot be independently verified. If it cannot be independently verified, it is not identity. Every step in this chain depends on the declared execution being explicit, complete, and unambiguous.
Implications
Any system claiming to implement AI identity must define what constitutes its declared execution. This definition must be precise enough that any independent verifier can use it as input to the identity function and reach the same identity. If the system cannot articulate its declared execution in explicit, unambiguous terms, it cannot have deterministic identity, and therefore it cannot have identity at all. See Deterministic vs Output-Based Identity for why systems that skip this step and derive identity from outputs are structurally invalid.
The practical consequence is that declared execution must be treated as a first-class artifact. It must be stored, transmitted, and verified independently of the system that executes it. It must be immutable once assigned an identity. If the declared execution changes, the identity must change. If the declared execution does not change, the identity must not change. This is the operational meaning of Same Input, Same Identity, and it applies to every AI system that claims to have identity. See Deterministic vs Post-Hoc Reconstruction for the structural failure that occurs when this principle is violated.
Frequently Asked Questions
What is declared execution in AI identity?
Declared execution is the explicit, complete specification of what a system will execute. It is the input to the identity function. Identity is assigned to declared execution, not to observed output, inferred behavior, or post-hoc analysis.
Why must declared execution be explicit?
Because implicit or inferred execution specifications are ambiguous. Different evaluators may interpret implicit specifications differently, producing different identities for what they believe is the same execution. Ambiguity destroys determinism.
How does declared execution differ from observed output?
Declared execution is what a system is specified to do before execution begins. Observed output is what a system actually produces after execution. Identity is assigned to the declaration, not to the observation. Outputs can vary while declared execution remains the same.
Can declared execution be incomplete?
No. If the declared execution is incomplete, the identity function does not have a fully specified input. An underspecified input can be interpreted in multiple ways, producing multiple identities. Completeness is required for determinism.
What happens if two systems have different declared executions but the same output?
They have different identities. Identity is assigned to declared execution, not to output. Two systems that produce identical outputs but declare different executions are different systems with different identities. Output equivalence is not identity equivalence.
Is declared execution the same as a configuration file?
Not necessarily. A configuration file may be part of a declared execution, but declared execution is the complete specification. It includes everything needed for the identity function to produce a deterministic result. A configuration file alone may be insufficient if it does not fully specify the execution.