> ## Documentation Index > Fetch the complete documentation index at: https://docs.manthan.systems/llms.txt > Use this file to discover all available pages before exploring further. # Authority Verification Proofs > The cryptographic evidence produced by Parmana to prove how authority was verified before execution # Authority Verification Proofs Parmana produces verifiable evidence that authority was checked before execution. These artifacts allow organizations to independently verify: * What policy applied * What facts were evaluated * What decision was produced * Whether a human override occurred * What action executed * Whether execution matched authorization ```text theme={null} Verified Signals ↓ Evaluation ↓ Attestation ↓ Override (optional) ↓ Execution ↓ Execution Integrity Proof ↓ Verification ``` Together these artifacts form the Authority Verification Trail. *** ## Why Proofs Exist Traditional systems often require trust. ```text theme={null} System Says: "Action Was Approved" ``` Auditors must trust the system. Parmana replaces trust with evidence. ```text theme={null} Evidence ↓ Verification ``` Every important authority decision produces a verifiable artifact. *** ## Core Principle Authority should be verifiable. ```text theme={null} Authority ↓ Evidence ↓ Verification ``` Without evidence: ```text theme={null} Trust ``` With evidence: ```text theme={null} Verification ``` *** # Authority Verification Trail Parmana's proof model consists of four primary artifacts. ```text theme={null} Attestation Override Record Execution Integrity Proof Verification Record ``` Each artifact answers a different question. *** # 1. Attestation The attestation is the authorization proof. It answers: > Did policy authorize this action? *** ## Generation ```text theme={null} Verified Signals ↓ Policy Evaluation ↓ Attestation ``` *** ## Example ```json theme={null} { "executionId": "claim-001", "policyId": "claims-approval", "policyVersion": "1.0.0", "decision": { "action": "approve", "requires_override": false }, "signature": "..." } ``` *** ## What It Proves ```text theme={null} Policy Evaluated Decision Produced Evidence Fingerprinted Attestation Signed ``` *** ## Question Answered ```text theme={null} Was this action authorized? ``` *** # 2. Override Record The override record is the human authority proof. It answers: > Did an authorized human approve an exception? *** ## Generation ```text theme={null} Policy Decision ↓ Pending Override ↓ Human Review ↓ Override Record ``` *** ## Example ```json theme={null} { "executionId": "claim-001", "approvedBy": "manager", "approverRole": "manager", "reason": "manual review completed", "signature": "..." } ``` *** ## What It Proves ```text theme={null} Human Reviewed Decision Human Accepted Responsibility Override Was Recorded Override Was Signed ``` *** ## Question Answered ```text theme={null} Who exercised authority? ``` *** # 3. Execution Integrity Proof The Execution Integrity Proof is the execution proof. It answers: > Did the authorized action actually execute? *** ## Generation ```text theme={null} Attestation ↓ Execution ↓ Confirmation ↓ Integrity Proof ``` *** ## Example ```json theme={null} { "match": true, "verified": true, "execution_state": "completed", "signature": "..." } ``` *** ## What It Proves ```text theme={null} Authorized Action Known Executed Action Known Comparison Performed Result Signed ``` *** ## Question Answered ```text theme={null} Did execution match authorization? ``` *** # 4. Verification Record The verification record is the trust proof. It answers: > Can the evidence itself be trusted? *** ## Generation ```text theme={null} Attestation ↓ Verification ↓ Verification Record ``` *** ## Example ```json theme={null} { "valid": true, "signatureVerified": true, "runtimeVerified": true, "schemaCompatible": true, "bundleVerified": true } ``` *** ## What It Proves ```text theme={null} Signature Valid Runtime Trusted Bundle Verified Release Verified Trust Chain Verified ``` *** ## Question Answered ```text theme={null} Can this evidence be trusted? ``` *** # Evidence Hierarchy ```text theme={null} Verification Record ↑ Execution Integrity Proof ↑ Override Record ↑ Attestation ``` Each proof builds on the previous layer. *** # Provenance Every proof contains provenance information. Example: ```json theme={null} { "provenance": { "provenanceVersion": "PARMANA_PROVENANCE_V1", "bundleHash": "...", "manifestHash": "...", "trustRootVersion": "1.0.0", "signerKeyId": "parmanasystems-root-2026" } } ``` This links authority decisions to: ```text theme={null} Runtime Release Bundle Trust Root ``` *** # Independent Verification Proofs are portable. They can be verified by: ```text theme={null} Auditors Compliance Teams Customers Regulators Security Teams Third-Party Verifiers ``` without trusting the original runtime. *** # Banking Example Customer requests a transfer. ```text theme={null} Customer ↓ AI Assistant ``` The bank verifies facts. ```text theme={null} Verified Signals ``` Parmana evaluates policy. ```text theme={null} Attestation ``` A manager approves an exception. ```text theme={null} Override Record ``` The bank executes the transfer. ```text theme={null} Execution Integrity Proof ``` An auditor validates the evidence. ```text theme={null} Verification Record ``` Result: ```text theme={null} Complete Authority Verification Trail ``` *** # Audit Questions Authority Verification Proofs allow auditors to answer: ```text theme={null} Which Policy Applied? Which Facts Were Evaluated? What Decision Was Produced? Who Approved The Override? What Action Executed? Did Execution Match Authorization? Can The Evidence Be Verified? ``` without relying on trust. *** # Complete Authority Trail ```text theme={null} Task ↓ Policy ↓ Schema ↓ Verified Signals ↓ Evaluation ↓ Attestation ↓ Override Record ↓ Execution ↓ Execution Integrity Proof ↓ Verification Record ``` This creates end-to-end evidence showing how authority was exercised before execution. *** # Core Insight Parmana does not simply make decisions. Parmana produces evidence. ```text theme={null} Authority ↓ Attestation ↓ Override Record ↓ Execution Integrity Proof ↓ Verification Record ``` Together these artifacts create a verifiable record that autonomous systems followed human-defined authority before they acted.