The core_practical directory contains the practical engineering layer of Algorithm 11 (A11).
It provides concrete, reproducible examples that demonstrate how the canonical A11 architecture operates in real decision‑making scenarios, including full reasoning traces and a minimal Python reference implementation.

This layer is not part of the A11 Core Standard.
Its purpose is to show how the standard behaves in practice and how it can be integrated into real engineering systems.

Version: v1.0.0 (Stable)
Status: Reference Demonstration Layer

This directory provides:

• a complete demonstration case for an autonomous robot
• a full L1–L11 reasoning trace
• diagrams illustrating projective branching, balancing, and rollback
• a minimal Python reference implementation
• structural documentation for engineering integration

The goal is to make A11 observable, testable, and understandable in a real scenario.

core_practical/
│
├── README.md                     ← this file
│
├── case_autonomous_robot/        ← full demonstration case
│   ├── README.md
│   ├── STRUCTURE.md              ← architectural skeleton of the case
│   ├── CASE.md                   ← complete scenario description
│   ├── TRACE_EXAMPLE.md          ← full reasoning trace (L1–L11)
│   │
│   ├── diagrams/                 ← flow, branching, rollback diagrams
│   │   ├── branching.md
│   │   ├── flow.md
│   │   └── rollback.md
│   │
│   └── python_reference/         ← minimal reference implementation
│       ├── a11_state.py
│       ├── constraints.py
│       ├── cycle.py
│       ├── transitions.py
│       ├── rollback.py
│       └── example_run.py

This case demonstrates how A11 performs:

• Projective Freedom (L5) — generation of conceptual branches
• Projective Constraint (L6) — conceptual filtering
• Balance (L7) — stabilization of projective and practical pairs
• Practical Freedom (L8) — expansion into actionable variants
• Practical Constraint (L9) — feasibility filtering
• Foundation (L10) — structural justification for the decision
• Realization (L11) — deterministic action and trace output
• full compliance with A11 Architectural Invariants

It is the canonical example of how A11 behaves in a real autonomous system.

The python_reference/ directory contains a minimal, readable implementation of:

• state structures
• level transitions (L1–L11)
• projective and practical constraint evaluation
• rollback logic
• deterministic cycle execution
• example run script

This implementation is:

• deterministic
• transparent
• aligned with the A11 architecture
• suitable for engineers integrating A11 into their own systems

It is not a production system — it is a reference model illustrating architectural principles.

Engineers can:

• read CASE.md to understand the scenario
• inspect STRUCTURE.md to see the architectural skeleton
• run the Python reference to observe A11 in action
• study TRACE_EXAMPLE.md to understand the reasoning trace
• use diagrams to visualize projective branching, balancing, and rollback

This layer is designed to be self‑contained, deterministic, and easy to explore.

The practical layer:

• does not define or modify the standard
• does not introduce new architectural rules
• only demonstrates how the standard works in practice

All authoritative definitions remain in:

/core/
A11 — Structural Architecture Specification.pdf
A11 — Cognitive Architecture Specification.pdf
A11 — Decision Layer Specification.pdf
A11 — Language Specification.pdf
A11 — System Integration Guide.pdf
A11 — Architectural Invariants.pdf

Additional demonstration cases may be added, such as:

• multi‑agent coordination
• energy‑constrained planning
• human–AI collaborative decision‑making
• uncertainty‑aware navigation
• conflict resolution in hybrid systems

Each case will follow the same structure and remain fully compliant with A11.