Dense Shorthand Notation

Dense Shorthand Notation (Symbolic Logic Grammar)

Overview

Expressing complex state transitions, type signatures, and conditional business rules in natural English prose ("Whenever a user attempts to update their profile, if their role is admin that implies they can bypass the email verification check, which returns an authorized session...") consumes 25 to 40 tokens per rule.

Because modern LLMs are pre-trained on billions of lines of code, mathematics, and formal logic, they natively parse Symbolic Logic Shorthand (User.admin => BypassVerify -> Session(200)).

The Dense Shorthand Notation Protocol replaces wordy logical explanations with compact ASCII operators (=>, ->, ::, |, !), cutting prompt token footprint by 65% while eliminating natural language ambiguity.

Verbose English Prose vs. Symbolic Shorthand

┌─────────────────────────────────────────────────────────────┐
│                 Logical Density Comparison                  │
│                                                             │
│  Verbose English Prose (68 Tokens):                         │
│  "If the incoming request is authenticated and the user     │
│   has the role of superuser or editor, then allow them to   │
│   publish the post and return a status of 201 Created.      │
│   Otherwise, if they are not authenticated, return 401,     │
│   and if they lack permissions, return 403 Forbidden."      │
│                                                             │
│  Symbolic Shorthand Grammar (18 Tokens - 73.5% Cut!):       │
│  • Auth & (Superuser | Editor) => Publish -> 201(Created)   │
│  • !Auth => 401(Unauthorized)                               │
│  • Auth & !(Superuser | Editor) => 403(Forbidden)           │
│  ↳ 18 tokens, 100% Mathematical Precision & Zero Ambiguity  │
└─────────────────────────────────────────────────────────────┘

The Master Shorthand Operator Codebook

Master Dense Shorthand Prompt Templates

Pattern 1: State Machine & Transition Rules

Use when asking an agent to generate complex workflow or lifecycle code:

Implement the Order Lifecycle State Machine in TypeScript:

### State Transitions:
- `Draft + Submit => PendingPayment`
- `PendingPayment + (Stripe::Success) => Paid ~> DispatchJob`
- `PendingPayment + (Stripe::Failed | Timeout::15m) => Cancelled -> RestockInventory`
- `Paid + Ship => Fulfilled`
- `* + Admin::ForceCancel => Refunded`

Constraints: Strict TypeScript types, exhaustive switch, zero external dependencies.

Pattern 2: API Route Authorization Matrix

Generate FastAPI route security dependencies:
- `GET /metrics` :: Role: SRE | Admin
- `POST /billing/refund` :: Role: Finance & Tier >= 2
- `DELETE /users/{id}` :: Role: Admin & !Target.isSuperuser

Token & Line Reduction Benchmark

Specifying a 10-state e-commerce order management workflow:

Agent Operational Directive

MANDATORY: When documenting state transitions, permission matrices, or algorithmic transformation pipelines, use symbolic shorthand operators (=>, ->, |, !). Maximize density and mathematical precision.