Persisto Ergo Didici Protocol diagram showing temporal verification process from unverified AI-dependent performance through T+90 testing to PED-verified capability with transfer and cascade verification tiers

Persisto Ergo Didici Protocol v1.1

The Temporal Verification Standard for Learning in the Post-Behavioral Era

Protocol Status: Specification Final Version: 1.1.0 Last Updated: July 2026 License: CC BY-SA 4.0 (Open Protocol) Canonical URL: PersistoErgoDidici.org/protocol

Canonical Definition

Learning is verified if and only if an independently administered capability test in a novel context is passed after minimum temporal separation with all external scaffolds removed.

Verification Extensions:

Cascade Proof (Tier-2): Capability propagates through independent beneficiaries with multiplicative branching (non-linear growth)
Temporal Strength (Tier-3): Capability is maintained or increases across the separation period (decay-resistance)

The Problem: When Behavior Stopped Indicating Learning

(Non-normative rationale – informative)

For centuries, behavioral demonstration reliably indicated learning. When someone could solve problems, explain concepts, or apply knowledge — learning had occurred. The correlation between behavior and capability was sufficiently strong to build civilization’s entire educational verification system upon it.

The Fabrication Threshold changed this structurally.

When AI systems achieved behavioral equivalence with humans across problem-solving, explanation generation, creative synthesis, and code production, behavioral observation at T+0 ceased to reliably distinguish learning from AI-assisted performance. Every signal that genuine formation historically produced became producible without the formation.

Result: Behavioral assessment at the moment of completion no longer distinguishes genuine capability from performance borrowed from assistance.

The Credential Crisis:

Degrees prove course completion, not capability retention
Certificates verify participation, not independent function
Interview performance may reflect real-time assistance
Work samples may demonstrate collaboration rather than autonomous capability

Temporal separation increases the cost of sustaining dependency and reduces the predictive value of immediate performance. It is the one dimension fabrication cannot compress.

Tempus Probat Veritatem. Time proves truth. This is the principle beneath the protocol.

I. Protocol Overview

Abstract

Learning verification currently operates through behavioral testing at moment of assessment (T+0). This methodology provides insufficient evidence when AI assistance during assessment cannot be reliably excluded.

Ontological Supersession: For learning verification after the Fabrication Threshold, T+0 behavioral assessment is insufficient under universal synthesis conditions. Persisto Ergo Didici establishes temporal persistence as the verification primitive, superseding behavioral observation as the epistemic foundation for learning verification.

Persisto Ergo Didici provides temporal verification infrastructure: testing whether capability persists after minimum separation from assistance, in novel contexts, without access to original materials or support systems.

Temporal separation reveals dependency patterns invisible at T+0. AI-dependent performance degrades predictably when tested independently after time passage. Genuine internalization demonstrates persistence.

This transforms learning verification from measuring immediate performance to measuring independent persistence.

Problem Statement

The Verification Insufficiency:

Current educational systems verify learning through:

Examinations (performance at T+0)
Assignments (completion with unknown assistance level)
Projects (output quality regardless of independence)
Credentials (participation, not persistence)

These methods do not distinguish:

Genuine capability (persists independently)
Tool-dependent performance (degrades without access)
Memorization (degrades rapidly)
Scaffolded understanding (collapses without structural support)

The Temporal Gap:

Learning implies capability outlasting the learning context. Traditional metrics assess T+0 state. Persisto provides infrastructure for assessing T+90, T+180, T+365 states.

The Infrastructure Gap:

No standardized verification protocol exists for:

Temporal persistence testing
Novel context capability assessment
Scaffold removal verification
Independence measurement

Persisto Ergo Didici provides this missing infrastructure.

Why Existing Approaches Cannot Solve This

(Non-normative rationale – informative)

T+0 Testing is Information-Theoretically Insufficient:

Any T+0 behavioral observation is non-identifying under conditions where assistance cannot be excluded. The measurement provides no information about persistence.

AI Detection:

Perfect synthesis is definitionally undetectable. Detection tools engage in arms race with evasion. As synthesis quality approaches 100% behavioral fidelity, detection approaches 0% reliability.

Honor Systems:

Incentive misalignment. Systematic pressures reward claimed capabilities over possessed capabilities. Honor-based verification cannot scale.

Surveillance:

Process monitoring rather than outcome verification. Resource intensive, privacy invasive, circumventable. Does not test what persists after monitoring ends.

Optimization Capture:

Any verification system that can be gamed through optimization will be. When the gap between genuine formation and its performance becomes invisible at assessment time, rational actors optimize for signals rather than substance. This is not dishonesty — it is structural incentive. Persisto addresses optimization capture structurally: temporal separation, independence verification, novel context, and transfer validation cannot simultaneously be satisfied through signal optimization without the underlying formation being present.

Architectural Conclusion:

Only temporal separation provides falsifiable verification. Immediate testing optimizes for T+0 performance. Delayed testing optimizes for T+X persistence. These are incompatible optimization targets.

Solution Architecture

Persisto Ergo Didici provides three-tier verification framework:

Tier-1: Learning Verification (Core)

Requirements:

Temporal Separation: Minimum T+90 between training and test
Scaffold Removal: No access to externalization scaffolds; instrumentation tools only if explicitly enumerated by domain/profile
Novel Context: Different problem class than training set
Independent Administration: No optimization for specific test

Output: Binary (Pass/Fail) + Capability Score (0-100)

Tier-2: Transfer Verification (Optional)

Requirements:

Tier-1 passed
Beneficiary can teach concept to others
Teaching occurs without original source assistance
Branching factor > 1 (at least some beneficiaries enable multiple others)

Output: Transfer Verified (Yes/No) + Branching Factor (numerical)

Tier-3: Cascade Proof (Optional)

Requirements:

Tier-2 passed
Minimum 3 generations of independent transfer
Multiplicative branching pattern (branching factor > 2 across multiple generations)
Capability remains stable or improves across separation checkpoints (positive or non-negative retention gradient)

Output: Cascade Multiplier (numerical) + Retention Gradient

Key Innovations

Temporal Separation as Verification Primitive:

Time increases cost of maintaining dependency while genuine internalization remains stable. This asymmetry enables falsifiable testing. It is the one dimension fabrication cannot compress — AI can generate expert performance instantly, but it cannot cause a human mind to retain internalized capability months later when the tool is unavailable.

Substrate Independence:

Protocol measures outcomes (does capability persist?) not processes (how was it learned?). Compatible with biological cognition, AI augmentation, and future technologies. Institutions can stop policing how people learn and focus exclusively on whether learning occurred.

Open Protocol:

Specification anyone implements. No entity controls temporal verification standards. Universities, employers, individuals — all use same falsifiable framework.

Integration Ready:

Designed for interoperability with the eight canonical standards: Genuine Formation, The Edge, Persisto Ergo Didici, Cascade Proof, MeaningLayer, Contribution Graph, Portable Identity, and Cogito Ergo Contribuo.

II. Technical Specification

Formal Definitions

Learning (Protocol Context)

Learning is verified when:

An individual passes an independently administered capability assessment in a novel context after temporal separation with all external scaffolds removed.

Operationalization:

IF capability_test(T+90, novel_context, no_scaffolds) >= threshold
THEN learning_verified = TRUE
ELSE learning_verified = FALSE

The Two Critical Variables:

Δ Assistance = 0

All external assistance must be completely removed during testing. The measurement tests the biological system’s freestanding capacity, not its augmented performance.

Δ Difficulty = 0

Test complexity must precisely match the original acquisition context. If difficulty changes, the system measures skill change rather than pure persistence.

Both variables must be held constant simultaneously. Relaxing either collapses the verification back to performance theater.

Persistence Ratio (Normative):

P(t) = C(t) / C_ind(0)

Where:

P(t) is the persistence ratio used for domain-agnostic comparison across time
C_ind(0) is baseline score measured under the same scaffold constraints as the verification profile

Independence-Calibrated Baseline: For profiles using P(t), the baseline assessment MUST include an independence-calibrated score C_ind(0) measured under the same scaffold rules as the T+X assessment. This ensures P(t) reflects genuine persistence rather than artificial degradation from scaffold removal.

All temporal comparisons MUST use P(t) rather than raw scores to normalize for baseline differences.

Temporal Separation

Minimum time period between training completion and capability test during which:

No access to training materials
No access to assistance systems
No structured review or reinforcement
No optimization for upcoming test

Standard Profiles:

Baseline: T+90 days
Strong: T+180 days
Ultimate: T+365 days

Scaffold

Any external support structure enabling performance. Scaffolds are classified into two categories:

Externalization Scaffolds (MUST be removed for all profiles):

Support that carries cognitive content:

AI reasoning systems (LLMs, expert systems)
Solution repositories
Human tutoring or guidance during assessment
Pre-solved examples or templates
Answer keys or worked solutions

Instrumentation Tools (MAY be permitted if explicitly enumerated):

Tools that execute but do not generate understanding:

Compilers, interpreters (programming domains)
Calculators (mathematics domains)
Reference documentation (API docs, syntax guides)
Dictionary, spell-checker (writing domains)
Measurement instruments (scientific domains)

Profile Requirements:

PED-CORE: All Externalization Scaffolds MUST be removed. Instrumentation Tools MUST be explicitly enumerated per domain if permitted.
PED-ASSURANCE: Same as CORE, with verification of tool restriction enforcement.
PED-LONGITUDINAL: Same as CORE, with consistent tool access across all temporal checkpoints.

Rationale: This distinction enables practical adoption in technical domains while preserving the core principle that understanding — not execution — must persist.

Novel Context

Test conditions where problems are sampled from a different problem class than training examples:

Requirements:

Problems MUST differ from training examples (not recognition-based)
Domain application MUST vary from instruction context
Problem class MUST differ from training set (novel constraints, different context manifold)
No recognition cues present
Solution MUST require applying understanding, not recalling procedure

Problem Class: A set of problems sharing structural characteristics. Testing within the same problem class as training enables pattern memorization rather than understanding verification.

Example:

Training: Sorting algorithms on integer arrays
Same class (insufficient): Sorting strings (same constraint type)
Different class (sufficient): Graph traversal problems (different constraint structure)

Falsifiability: Novel context is violated if learner could solve test problems through pattern recognition of training examples rather than understanding application.

Independent Administration

Test administration ensuring no optimization bias:

MUST Requirements:

Test administrator MUST NOT be the same entity that provided training (for high-stakes verification)
Test MUST be ”unoptimized”: no pre-known item types, no reused prompts from training
Test problems MUST be selected from a pool unknown to learner during training
Organizational Separation: Independent administration requires organizational separation sufficient to eliminate test optimization incentives

Falsifiability: Independent administration is violated if trainer and tester are the same entity without third-party verification, or if test items were disclosed before assessment.

Protocol Primitives

Primitive	Input	Test Method	Minimum Separation	Allowed Tools	Output	Falsifiability
Temporal Persistence	Domain + Baseline Score	Independent capability test in novel context	T+90 days	None (or explicitly defined minimal set)	Binary Pass/Fail + Score (0-100)	Does capability function without scaffolds?
Scaffold Independence	Test environment	Controlled assessment with verified absence of support structures	None (verified at test time)	Explicitly enumerated only	Compliance: Yes/No	Were scaffolds actually absent?
Novel Context	Problem set	Problems requiring application not recognition	T+90 days	Same as Temporal Persistence	Performance measurement	Can understanding transfer to new situations?
Transfer Capability (Tier-2)	Tier-1 Pass	Beneficiary taught independently	T+180 days	Teaching materials allowed	Transfer: Yes/No + Branching Factor	Can learner enable others?
Cascade Multiplication (Tier-3)	Tier-2 Pass	Network analysis of multi-generation propagation	T+365 days	None	Cascade Multiplier + Retention Gradient	Does capability multiply with branching factor > 2 sustained across ≥3 generations?

Verification Protocol

Phase 1: Baseline Assessment (T+0)

Initial capability measurement establishing baseline scores.

Status: Non-verifying (may include assistance) Purpose: Establishes reference point for comparison

Baseline Scores:

C₀: Raw baseline score (may include assistance)
C_ind(0): Independence-calibrated baseline measured under same scaffold constraints as verification profile

Pre-Commitment (MUST for High-Assurance and Ultimate profiles):

At T+0, a cryptographic commitment to the test specification MUST be created covering domain boundary, difficulty band, scoring function, and problem class. The commitment MUST be cryptographically signed and revealed only at T+X when test is administered.

Purpose: Prevents test manipulation, collusive credentialing, and optimization for known test characteristics during separation period.

Phase 2: Temporal Separation (T+90 minimum)

Required separation period.

Constraints:

MUST NOT access training materials
MUST NOT use assistance systems (unless explicitly allowed by profile)
MUST NOT receive structured reinforcement
MUST NOT optimize for known test format

Phase 3: Independent Assessment (T+90)

Novel problems in same domain, different context.

Requirements:

MUST be independently administered
MUST use novel problem set (not training examples)
MUST occur in controlled environment (for high-assurance profiles)
MUST NOT provide scaffolding or recognition cues

Scoring:

capability_score = (problems_solved_correctly / total_problems) × 100
threshold = 70 (default, profile-dependent)

IF capability_score >= threshold
    learning_verified = TRUE
ELSE
    learning_verified = FALSE

Phase 4: Temporal Strength Analysis (Optional)

Compare C(T+90) to C_ind(0):

IF C(T+90) >= C_ind(0)
    temporal_strength = "Positive" (capability maintained or improved)
ELSE IF C(T+90) >= 0.7 × C_ind(0)
    temporal_strength = "Acceptable" (capability degraded within tolerance)
ELSE
    temporal_strength = "Degraded" (significant capability loss)

Capability maintenance (stable performance) is considered positive evidence of genuine learning — skills do not need to improve over time to be verified.

Compliance Profiles

Profile: Standard (Default)

Separation: T+90 days
Environment: Attestation-based (honor system with consequences)
Threshold: 70%
Scaffolds: Externalization scaffolds: none; instrumentation: only if explicitly enumerated
Use case: General education, low-stakes verification

Profile: High-Assurance

Separation: T+180 days
Environment: Controlled (proctored, environment verified)
Threshold: 80%
Scaffolds: Explicitly enumerated minimal set only
Use case: Professional certification, high-stakes employment

Profile: Ultimate

Separation: T+365 days
Environment: Controlled with cryptographic attestation
Threshold: 85%
Scaffolds: None
Use case: Critical domains (medical, safety-critical, AI evaluation)

Conformance Classes

Implementations MUST declare conformance to one or more of these classes:

PED-CORE — Tier-1 verification, cryptographic signing, minimum security constraints, binary Pass/Fail output with capability score.

PED-ASSURANCE — PED-CORE plus proctored environment, identity verification, audit trail, and problem set rotation.

PED-LONGITUDINAL — PED-CORE plus T+365 minimum separation, multiple temporal checkpoints, and persistence trajectory tracking.

Anti-Capture Principle: Any implementation that cannot enforce independence constraints MUST label itself ”Low-Assurance” and MAY NOT claim PED-CORE compatibility.

III. Architecture & Implementation

What Persisto Ergo Didici IS

Verification protocol for temporal capability testing
Measurement standard for learning persistence
Attestation framework for cryptographic proof
Open specification anyone implements
Temporal layer within the eight canonical verification standards

What Persisto Ergo Didici IS NOT

NOT pedagogy (does not prescribe how to teach)
NOT grading system (measures persistence, not performance ranking)
NOT platform (does not require accounts or centralized control)
NOT motivation framework (does not address why people learn)
NOT surveillance system (does not monitor learning process)
NOT credential replacement (complements credentials with verification)

The Binary Choice

(Non-normative rationale – informative)

After temporal verification infrastructure exists, only two positions remain:

Position One: Temporal Verification

Learning claims verified through cryptographic attestation, temporal persistence testing, and impact verification. Capability becomes demonstrable across time.

Position Two: Credential-Based Verification

Learning claims verified through institutional credentials, completion metrics, and self-reported capabilities. Verification depends on institutional trust rather than individual proof.

The Fabrication Threshold has not eliminated credential-based verification. It has made the gap between the two positions visible — because one position can distinguish genuine formation from its performance, and the other cannot.

Integration Patterns

Input/Output Specification

Input to Persisto:

learner_id (Portable Identity reference)
domain (what was learned)
baseline_score_raw (C₀ from T+0, may include assistance)
baseline_score_independent (C_ind(0) measured under profile scaffold constraints)
test_profile (Standard/High-Assurance/Ultimate)
training_completion_date (T=0 timestamp)

Output from Persisto:

verification_status (PASS/FAIL)
capability_score (0-100)
temporal_strength (Positive/Acceptable/Degraded)
test_date (T+X timestamp)
cryptographic_signature (Portable Identity signed)
profile_used (which compliance profile)

University Integration

Training Phase:
├── Course delivery (any pedagogy)
├── T+0 baseline assessment → C₀ (may include tools/assistance)
├── T+0 independence assessment → C_ind(0) (under profile constraints)
├── Issue pending credential
│
T+90 Separation:
├── No contact with materials/instructors
│
T+90 Verification:
├── Novel problem set
├── Controlled environment (per profile)
├── Score → Pass/Fail (compared to C_ind(0) via P(t))
│
Credential Finalization:
└── IF Pass → Credential activated with temporal attestation
    ELSE → Credential remains pending, retest available

Employer Integration

Hiring Phase:
├── Candidate claims capability
├── T+0 baseline test (optional, may include assistance)
├── Conditional hire OR
├── Request existing temporal verification
│
T+90 Verification (if no prior proof):
├── Novel tasks in actual work context
├── No AI assistance (or explicitly defined tools only)
├── Independent assessment
│
Employment Decision:
└── IF Pass → Permanent hire with verified capability proof
    ELSE → Extended probation or separation

Individual Self-Verification

Self-Study Phase:
├── Learn with any resources (AI, books, videos)
├── T+0 self-assessment → C₀
│
T+90 Separation:
├── No reference to materials
│
T+90 Self-Test:
├── Use standardized problem sets (published)
├── Environment: Honor system with cryptographic attestation
├── Submit results + Portable Identity signature
│
Credential:
└── Portable proof of persistent capability
    (Accepted by employers/platforms recognizing Persisto)

Integration with the Eight Canonical Standards

Persisto Ergo Didici is the temporal verification standard within a chain of eight independent standards. Each addresses a distinct dimension of what genuine human formation requires and how it can be established.

GenuineFormation.org — BUILDS the cognitive architecture. Defines what formation is and what encounters produce it. Persisto verifies that what Genuine Formation built has persisted.

TheEdge.is — REVEALS where the difference between genuine formation and its performance becomes undeniable. Persisto provides the temporal equivalent — the point where time reveals the same difference.

PersistoErgoDidici.org — ESTABLISHES temporal persistence. The standard this protocol specifies.

CascadeProof.org — VERIFIES causal transmission. Establishes that what Persisto verified as genuine was also transmitted to others in ways that persisted and propagated independently.

MeaningLayer.org — SPECIFIES what kind of capability was verified. Provides semantic precision so that Persisto attestations remain interpretable across every institutional context they cross.

ContributionGraph.org — MAPS the complete causal history of what the verified formation produced in the world.

PortableIdentity.global — CARRIES verified attestations across institutional boundaries. Ensures that what Persisto established does not reset at every transition.

CogitoErgoContribuo.org — CONTRIBUTES the final proof: verified causal evidence that a specific human being with genuine formation genuinely contributed to the world in ways that persist, propagate, and compound.

→ Seven Standards. One Proof. — The complete verification architecture

IV. Security Considerations

Threat Model

Persisto verification is vulnerable to several attack vectors. Protocol implementations MUST address these threats through compliance profiles.

Attack Vector 1: Covert Material Access

Threat: Learner accesses training materials during separation period

Mitigation:

Standard Profile: Attestation with consequences (honor violation)
High-Assurance: Cryptographic commitment at T=0, re-verification of novel problem sets
Ultimate: Controlled environment with verified absence

Attack Vector 2: Hidden Assistance During Test

Threat: Real-time AI assistance, human tutoring, or collaboration during assessment

Mitigation:

Standard Profile: Attestation-based
High-Assurance: Proctored environment, network isolated
Ultimate: Faraday environment, device-free, biometric verification

Attack Vector 3: Test Bank Memorization

Threat: Learner obtains and memorizes test problems in advance

Mitigation:

MUST use randomized problem generation
MUST NOT reuse test items across administrations
SHOULD use procedural generation when possible

Attack Vector 4: Scaffolded Prompts

Threat: Test questions provide excessive structure enabling recognition over understanding

Mitigation:

MUST use open-ended problems requiring application
MUST NOT include solution templates
MUST NOT provide step-by-step decomposition

Attack Vector 5: Domain Shift Manipulation

Threat: Test made trivially easy through narrowed scope

Mitigation:

Test domain MUST match training domain scope
MUST NOT narrow to memorizable subset
Compliance profiles MUST define domain boundaries

Attack Vector 6: Proxy Test Completion

Threat: Someone other than learner completes assessment

Mitigation:

Standard Profile: Attestation + identity verification
High-Assurance: Biometric verification
Ultimate: Continuous identity verification throughout test

Attack Vector 7: Optimization Capture

Threat: Verification system is gamed through systematic optimization of signals rather than genuine formation

Mitigation:

The four requirements simultaneously — Temporal Separation, Independence Verification, Comparable Difficulty, Transfer Validation — cannot be satisfied through signal optimization without genuine formation being present. Each requirement independently defeats a different optimization strategy. Together they are structurally immune to optimization capture because temporal separation cannot be compressed, independence cannot be substituted, novel context cannot be memorized, and transfer cannot be faked without understanding.

V. Use Cases & Failure Modes

Primary Use Cases

Use Case 1: Post-AI Education Credentialing

Context: Students complete courses with AI assistance. Traditional credentials prove completion, not capability.

Persisto Application: Course ends → T+0 baseline → T+90 separation (no access to materials/AI) → T+90 novel assessment → Pass/Fail → Credential issued only if Pass.

Benefit: Employers trust credentials represent persistent capability, not AI-assisted completion.

Use Case 2: Employment Capability Verification

Context: Résumés and interviews can be AI-optimized. Claimed skills may not persist independently.

Persisto Application: Interview → Conditional offer → T+90 on-job assessment (novel tasks, defined tool access) → Pass → Permanent hire.

Benefit: Organizations hire genuinely capable employees, not AI-dependent performers.

Use Case 3: Individual Skill Portability

Context: Practitioners change institutional contexts. New institution needs capability proof beyond résumé.

Persisto Application: Practitioner maintains Portable Identity → Previous institution issued Persisto attestations (T+90 verified) → New institution accepts cryptographically signed proof → No redundant testing.

Benefit: Capability proof portable across institutional boundaries. What was verified does not reset at every transition.

Use Case 4: AI Safety Evaluator Verification

Context: The people evaluating AI systems must themselves carry genuine formation for that task. The Evaluator Problem — the structural inability to establish whether AI evaluators possess the genuine formation required — is the domain where Persisto has its most consequential application.

Persisto Application: AI safety evaluators verified through T+180 or T+365 profiles in genuinely novel AI evaluation contexts, with independent administration and transfer validation.

Benefit: The institutions certifying AI systems as safe can demonstrate that their evaluators carry genuine formation — not credential signals that the Fabrication Threshold has compromised.

Failure Modes Without Persisto

(Non-normative rationale – informative)

Credential Inflation Without Substance: When completion can be AI-assisted perfectly, credentials certifying completion prove nothing about whether capability was built. Every institution that hires based on credentials is making an inference the Fabrication Threshold has broken.

Invisible Capability Dependence: Practitioners who complete requirements through AI assistance without building persistent capability carry no visible indicator of what was not built. The gap becomes apparent precisely when independence is required — at which point rebuilding is structurally constrained by accumulated responsibilities.

Institutional Knowledge Discontinuity: When experienced practitioners retire and those who follow completed requirements through assisted performance, institutional knowledge cannot genuinely transfer. The receivers can perform tasks with assistance. They cannot understand why tasks matter or adapt when contexts change.

The Evaluator Cascade: When the practitioners responsible for verifying others’ formation have not themselves been verified, the absence propagates through every evaluation they conduct. Unverified evaluators produce unverified credentials at scale. The gap compounds across every generation that passes through the unverified system.

VI. Governance & Evolution

Protocol Governance

Persisto Ergo Didici is an open protocol maintained through transparent community process ensuring no entity captures learning verification standards.

Governance Principles:

Open Specification: Anyone may implement without permission
Transparent Evolution: All changes proposed publicly, discussed openly
Consensus Adoption: Changes require community agreement
Non-Capturable: No corporation or institution owns protocol evolution
Interoperability: All implementations must maintain compatibility

Version Control

Major versions (X.0.0): Breaking changes requiring implementation updates
Minor versions (1.X.0): Backward-compatible enhancements
Patch versions (1.0.X): Clarifications and corrections

Current Version: 1.1.0

Changes from 1.0.0:

Updated ecosystem references to eight canonical standards
Added Optimization Capture as named attack vector (Section IV)
Added formal expression of Δ Assistance = 0 and Δ Difficulty = 0
Added AI Safety Evaluator Verification use case
Updated integration architecture to current canonical chain
Removed phase-specific roadmap (replaced with principles-based evolution)

Backward Compatibility

Guarantee: Minor and patch versions maintain compatibility with 1.0.0

Breaking Changes: Require major version increment (2.0.0) with minimum 12-month notice

Interoperability Requirement

All implementations of Persisto MUST:

Accept attestations from other implementations using same profile
Produce attestations verifiable by other implementations
Maintain semantic compatibility across platforms
Respect cryptographic signatures from any Portable Identity provider

Non-Compliance: Implementation claiming ”Persisto-compatible” without interoperability is protocol violation.

Open Licensing

License: Creative Commons Attribution-ShareAlike 4.0 International (CC BY-SA 4.0)

Rights Granted:

Anyone may implement, adapt, translate, or build upon specifications
Derivative protocols explicitly encouraged
Commercial implementations permitted
Educational use unrestricted

Requirements:

Attribution to Persisto Ergo Didici
Derivative works under same license (ShareAlike)
No exclusive licenses granted
No proprietary ownership claims

Rationale: Learning verification is civilizational infrastructure, not commercial product. The ability to verify that capability persists cannot become intellectual property.

VII. Conclusion

Time as Verification Primitive

(Non-normative rationale – informative)

When the Fabrication Threshold made sophisticated performance available without the formation that performance was supposed to indicate, civilization lost its primary learning verification method. Examinations, credentials, interviews — all became potentially assisted performance rather than proof of capability.

Persisto Ergo Didici provides the missing infrastructure:

Not by rejecting AI assistance — futile and counterproductive — but by measuring what assisted performance cannot fake: genuine capability persisting independently across time when tested in novel contexts without support.

This is measurement protocol, not philosophical position.

Testable. Falsifiable. Replicable. Open.

Learning either persists or it does not. Capability either survives temporal separation or it collapses.

Tempus Probat Veritatem. Time proves truth. The protocol provides infrastructure for establishing which.

Final Statement

Persisto Ergo Didici is not vision. It is protocol.

Open. Neutral. Necessary.

When behavior stopped proving capability, time became the last unfakeable dimension. This protocol provides standardized infrastructure for temporal verification.

Anyone may implement. Anyone may integrate. Anyone may improve.

But no one may capture. No one may monopolize. No one may own.

Learning verification is civilizational infrastructure. It must remain free.

VIII. Appendices

Appendix A: Measurement Profiles (Non-Normative)

CRITICAL: The thresholds and parameters in this appendix are indicative examples only. Implementations MUST NOT claim protocol conformance based solely on Appendix A thresholds.

Cascade Mathematics

Branching Factor:

B = (Direct Beneficiaries Enabling Others) / (Total Direct Beneficiaries)

Generation Count:

G = Maximum depth of independent propagation chain

Cascade Multiplier:

M = B^G

Retention Coefficient (Optional):

k = ln(C(T+X) / C_ind(0)) / X

Capability maintenance (k ≈ 0) indicates successful internalization. Not all learned skills improve over time; many stabilize at competent levels.

Appendix B: Implementation Checklist

Minimum Viable Implementation:

[ ] Temporal separation mechanism (T+90 minimum)
[ ] Novel problem set generation or selection
[ ] Scaffold removal verification
[ ] Independent administration capability
[ ] Binary Pass/Fail threshold
[ ] Cryptographic signing (Portable Identity integration)
[ ] Attestation format (machine-readable)

High-Assurance Implementation adds: environment verification, identity verification, audit trail, problem set rotation, compliance profile documentation.

Ultimate Implementation adds: continuous identity verification, network isolation verification, device restriction enforcement, procedural problem generation, multi-factor security.

Appendix C: JSON Attestation Format (Informative)

{
  "protocol": "PersistoErgoDidici",
  "version": "1.1.0",
  "learner_id": "did:portable:abc123...",
  "domain": "Python Programming",
  "baseline_score_raw": 85,
  "baseline_score_independent": 78,
  "baseline_date": "2026-01-01T00:00:00Z",
  "test_date": "2026-07-01T10:00:00Z",
  "separation_days": 90,
  "profile": "Standard",
  "capability_score": 76,
  "persistence_ratio": 0.97,
  "verification_status": "PASS",
  "temporal_strength": "Acceptable",
  "signature": "0x...",
  "issuer": "UniversityName or SelfIssued"
}

Implementation Resources

Canonical Specification: PersistoErgoDidici.org/protocol
Reference Implementation: PersistoErgoDidici.org/reference
Integration Guide: PersistoErgoDidici.org/integrate
Community Forum: PersistoErgoDidici.org/community

Related Standards

The Eight Canonical Verification Standards:

GenuineFormation.org — BUILDS
TheEdge.is — REVEALS
PersistoErgoDidici.org — ESTABLISHES
CascadeProof.org — VERIFIES
MeaningLayer.org — SPECIFIES
ContributionGraph.org — MAPS
PortableIdentity.global — CARRIES
CogitoErgoContribuo.org — CONTRIBUTES

→ Seven Standards. One Proof.

Protocol Version: 1.1.0 Status: Specification Final License: CC BY-SA 4.0 (Open Protocol) Last Updated: July 2026 Canonical URL: PersistoErgoDidici.org/protocol

End of Specification