> ## Documentation Index
> Fetch the complete documentation index at: https://doc.blueapi.ir/llms.txt
> Use this file to discover all available pages before exploring further.

# EMEP Algorithm Flowchart Index and Standard Template

> Table of every mandated algorithm with links to specification pages, plus the standard flowchart template with START/INPUT/VALIDATION/PROCESSING/DECISION/BRANCHES/OUTPUT/END.

Every algorithm in EMEP must be specified with a Mermaid flowchart before implementation. This page lists all mandated algorithms and provides the standard template.

## Standard Algorithm Flowchart Template

```mermaid theme={null}
flowchart TB
    START([START]) --> INPUT[INPUT:<br/>List required inputs]
    INPUT --> VALIDATION[VALIDATION:<br/>Check preconditions]
    VALIDATION --> DECISION1{DECISION:<br/>Valid?}
    DECISION1 -->|No| ERROR[ERROR:<br/>Return validation failure]
    DECISION1 -->|Yes| PROCESSING[PROCESSING:<br/>Core algorithm steps]
    PROCESSING --> DECISION2{DECISION:<br/>Converged / Complete?}
    DECISION2 -->|No| LOOP[BRANCHES:<br/>Adjust and repeat]
    LOOP --> PROCESSING
    DECISION2 -->|Yes| OUTPUT[OUTPUT:<br/>Return results]
    OUTPUT --> END([END])
    ERROR --> END

    style START fill:#e8f5e9
    style END fill:#e8f5e9
    style ERROR fill:#ffebee
    style DECISION1 fill:#fff3e0
    style DECISION2 fill:#fff3e0
```

Caption: The standard template enforces six mandatory sections. START and END are rounded terminals. INPUT and OUTPUT are rectangles. VALIDATION and PROCESSING are process blocks. DECISION nodes are diamonds with yes/no branches. ERROR handling must terminate at END. Iterative processes loop from DECISION back to PROCESSING via BRANCHES.

## Mandated Algorithm Index

| Algorithm                            | Home Page                                                               | Phase   | Domain        |
| ------------------------------------ | ----------------------------------------------------------------------- | ------- | ------------- |
| Model Import Pipeline                | [Model Import](/compatibility/model-import)                             | Phase 2 | Compatibility |
| Compatibility Analysis               | [Model Compatibility](/compatibility/model-compatibility)               | Phase 2 | Compatibility |
| Tokenizer Compatibility Check        | [Tokenizer Compatibility](/compatibility/tokenizer-compatibility)       | Phase 2 | Compatibility |
| Architecture Compatibility Check     | [Architecture Compatibility](/compatibility/architecture-compatibility) | Phase 2 | Compatibility |
| Tensor Shape Validation              | [Tensor Shape Validation](/compatibility/tensor-shape-validation)       | Phase 2 | Compatibility |
| Merge Engine Execution               | [Merge Engine](/merge/merge-engine)                                     | Phase 3 | Merge         |
| Task Arithmetic Merge                | [Task Arithmetic](/math/task-arithmetic)                                | Phase 3 | Math          |
| SLERP Interpolation                  | [SLERP Math](/math/slerp-math)                                          | Phase 3 | Math          |
| TIES-Merging Algorithm               | [TIES Math](/math/ties-math)                                            | Phase 3 | Math          |
| DARE Sparsification and Merge        | [DARE Math](/math/dare-math)                                            | Phase 3 | Math          |
| Tensor Operation Primitives          | [Tensor Math](/math/tensor-math)                                        | Phase 3 | Math          |
| Merge Strategy Selection             | [Merge Strategies](/merge/merge-strategies)                             | Phase 3 | Merge         |
| Merge Validation                     | [Merge Validation](/merge/merge-validation)                             | Phase 3 | Merge         |
| Tensor Operation Execution           | [Tensor Operations](/merge/tensor-operations)                           | Phase 3 | Merge         |
| Evolution Engine Main Loop           | [Evolution Engine](/evolution/evolution-engine)                         | Phase 4 | Evolution     |
| Genome Encoding                      | [Genome](/evolution/genome)                                             | Phase 4 | Evolution     |
| Population Initialization            | [Population](/evolution/population)                                     | Phase 4 | Evolution     |
| Mutation Operators                   | [Mutation](/evolution/mutation)                                         | Phase 4 | Evolution     |
| Crossover Operators                  | [Crossover](/evolution/crossover)                                       | Phase 4 | Evolution     |
| Selection Mechanisms                 | [Selection](/evolution/selection)                                       | Phase 4 | Evolution     |
| Fitness Computation                  | [Fitness](/evolution/fitness)                                           | Phase 4 | Evolution     |
| Multi-Objective Optimization         | [Multi-Objective Optimization](/evolution/multi-objective-optimization) | Phase 4 | Evolution     |
| Evaluation Framework Execution       | [Framework](/evaluation/framework)                                      | Phase 5 | Evaluation    |
| Benchmark Specification Loading      | [Benchmark Specification](/evaluation/benchmark-specification)          | Phase 5 | Evaluation    |
| Persian Evaluation Protocol          | [Persian Evaluation](/evaluation/persian-evaluation)                    | Phase 5 | Evaluation    |
| Safety Evaluation Protocol           | [Safety Evaluation](/evaluation/safety-evaluation)                      | Phase 5 | Evaluation    |
| Regression Evaluation Protocol       | [Regression Evaluation](/evaluation/regression-evaluation)              | Phase 5 | Evaluation    |
| Benchmark Integrity Check            | [Benchmark Integrity](/evaluation/benchmark-integrity)                  | Phase 5 | Evaluation    |
| Experiment Tracking Lifecycle        | [Experiment Tracking](/tracking/experiment-tracking)                    | Phase 6 | Tracking      |
| Model Registry Operations            | [Model Registry](/tracking/model-registry)                              | Phase 6 | Tracking      |
| Dataset Registry Operations          | [Dataset Registry](/tracking/dataset-registry)                          | Phase 6 | Tracking      |
| Artifact Registry Operations         | [Artifact Registry](/tracking/artifact-registry)                        | Phase 6 | Tracking      |
| Model Lineage Construction           | [Model Lineage](/tracking/model-lineage)                                | Phase 6 | Tracking      |
| Reproducibility Protocol             | [Reproducibility Protocol](/tracking/reproducibility-protocol)          | Phase 6 | Tracking      |
| Model Provenance Verification        | [Model Provenance](/tracking/model-provenance)                          | Phase 6 | Tracking      |
| Quantization Pipeline                | [Quantization](/deployment/quantization)                                | Phase 8 | Deployment    |
| Inference Execution                  | [Inference](/deployment/inference)                                      | Phase 8 | Deployment    |
| Deployment Packaging                 | [Deployment Specification](/deployment/deployment-specification)        | Phase 8 | Deployment    |
| Offline Deployment                   | [Offline Deployment](/deployment/offline-deployment)                    | Phase 8 | Deployment    |
| Performance Validation               | [Performance Validation](/deployment/performance-validation)            | Phase 8 | Deployment    |
| API Request Handling                 | [API Specification](/interfaces/api-specification)                      | Phase 1 | Interfaces    |
| CLI Command Execution                | [CLI Specification](/interfaces/cli-specification)                      | Phase 1 | Interfaces    |
| Configuration Loading and Validation | [Configuration Specification](/interfaces/configuration-specification)  | Phase 1 | Interfaces    |
| Unit Test Execution                  | [Unit Test Plan](/testing/unit-test-plan)                               | Phase 1 | Testing       |
| Integration Test Execution           | [Integration Test Plan](/testing/integration-test-plan)                 | Phase 2 | Testing       |
| Model Merge Test Protocol            | [Model Merge Tests](/testing/model-merge-tests)                         | Phase 3 | Testing       |
| Numerical Accuracy Testing           | [Numerical Testing](/testing/numerical-testing)                         | Phase 3 | Testing       |
| Evaluation Test Protocol             | [Evaluation Testing](/testing/evaluation-testing)                       | Phase 5 | Testing       |
| Performance Test Protocol            | [Performance Testing](/testing/performance-testing)                     | Phase 8 | Testing       |
| Security Test Protocol               | [Security Testing](/testing/security-testing)                           | Phase 7 | Testing       |
| Failure Injection Protocol           | [Failure Injection](/testing/failure-injection)                         | Phase 9 | Testing       |
| Risk Assessment Workflow             | [Risk Management](/risk/risk-management)                                | Phase 0 | Risk          |
| Failure Mode Analysis                | [Failure Modes](/risk/failure-modes)                                    | Phase 0 | Risk          |
| Disaster Recovery Execution          | [Disaster Recovery](/operations/disaster-recovery)                      | Phase 9 | Operations    |
| Backup Strategy Execution            | [Backup Strategy](/operations/backup-strategy)                          | Phase 9 | Operations    |
| Monitoring and Alerting              | [Monitoring](/operations/monitoring)                                    | Phase 8 | Operations    |
| GPU Health Check                     | [GPU Health](/operations/gpu-health)                                    | Phase 8 | Operations    |
| Storage Operations                   | [Storage Operations](/operations/storage-operations)                    | Phase 8 | Operations    |
| Enterprise Model Update              | [Model Update Protocol](/enterprise/model-update-protocol)              | Phase 7 | Enterprise    |
| Enterprise Model Rollback            | [Model Rollback](/enterprise/model-rollback)                            | Phase 7 | Enterprise    |
| Secure Model Packaging               | [Secure Model Packaging](/enterprise/secure-model-packaging)            | Phase 7 | Enterprise    |
| Model Supply Chain Verification      | [Model Supply Chain](/security/model-supply-chain)                      | Phase 7 | Security      |
| Artifact Signing Protocol            | [Artifact Signing](/security/artifact-signing)                          | Phase 1 | Security      |
| Dependency Safety Check              | [Dependency Safety](/security/dependency-safety)                        | Phase 1 | Security      |
| Offline Security Protocol            | [Offline Security](/security/offline-security)                          | Phase 7 | Security      |

## Template Compliance Rules

1. Every algorithm flowchart must begin with `([START])` and end with `([END])`
2. Every input must be declared in an `INPUT` block before validation
3. Every validation must branch to error handling on failure
4. Iterative processes must show the loop explicitly: `DECISION` → `BRANCHES` → `PROCESSING`
5. Every output must be declared in an `OUTPUT` block before `END`
6. Color coding: green for START/END, red for ERROR, orange for DECISION, blue for INPUT/OUTPUT/PROCESSING
7. No algorithm flowchart may exceed 15 nodes without decomposition into sub-flowcharts

## Next Steps

See [Diagram Index](/diagrams/diagram-index) for the full catalog of all diagram types, or visit any algorithm home page for its specific flowchart.