# Bidirectional Navigator

> Safe proof ↔ theorem navigation with non-backtracking constraint.

- Skill: `plurigrid/bidirectional-navigator` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx skillmds@latest add plurigrid/bidirectional-navigator`
- Raw SKILL.md: https://api.skillmd.com/api/skills/plurigrid/bidirectional-navigator/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: plurigrid (https://skillmd.com/u/plurigrid)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/plurigrid/bidirectional-navigator

---


# Bidirectional Navigator

**Category**: Proof Navigation + Caching
**Type**: Graph Index Structure
**Language**: Julia
**Status**: Production Ready
**Version**: 1.0.0
**Date**: December 22, 2025

## Overview

Safe proof ↔ theorem navigation with non-backtracking constraint. Implements Friedman's B operator to enable linear homotopy type theory (LHoTT) resource-aware evaluation where proofs are consumed exactly once.

## Key Data Structures

```julia
struct Theorem
    id::Int
    name::String
end

struct Proof
    id::Int
    theorem_id::Int
    name::String
end

struct BidirectionalMap
    forward::Dict{Int, Int}     # Proof ID → Theorem ID
    backward::Dict{Int, Vector{Int}}  # Theorem ID → [Proof IDs]
    non_backtracking_ok::Bool
end
```

## Key Functions

- **`create_index(theorems, proofs)`**: Build bidirectional mapping
- **`evaluate_forward(index, proof_id)`**: O(1) proof → theorem lookup
- **`evaluate_backward(index, theorem_id)`**: Cached theorem → proofs lookup
- **`check_non_backtracking()`**: Verify B operator constraint (no u→v→u)
- **`linear_evaluation_possible()`**: Check LHoTT compatibility

## Mathematical Foundation

**Friedman's Non-Backtracking Operator (B)**
```
No u→v→u cycles ⟺ Linear resource-aware evaluation possible
```

Enables:
- Automatic proof consumption tracking
- Linear type system integration (LHoTT)
- Memory-efficient navigation (no revisits)

## Usage

```julia
using BidirectionalIndex

# Create index
index = create_index(theorems, proofs)

# Forward navigation (Proof → Theorem)
theorem_id = evaluate_forward(index, proof_42)

# Backward navigation (Theorem → Proofs)
related_proofs = evaluate_backward(index, theorem_5)

# Verify constraints
if check_non_backtracking(index)
    println("✓ B operator satisfied, linear evaluation ok")
end
```

## Integration Points

- Agent-based proof discovery with caching
- Linear homotopy type theory resource tracking
- Efficient theorem-proof lookup in large catalogs

## Performance

- Index creation: < 0.1 seconds
- Forward lookup: O(1)
- Backward lookup: O(1) cached after first access
- Scalable to 5,652+ theorems

## References

- Friedman (2008): Non-backtracking operator theory
- Linear Homotopy Type Theory (LHoTT) semantics