Decoupling Knowledge and Reasoning for LLMs

# Illustrative sketch (not from the paper)
import torch
import torch.nn as nn

class MobiusLayer(nn.Module):
    def __init__(self, dim, knowledge_db):
        super().__init__()
        self.ffn = nn.Linear(dim, dim)                     # knowledge storage (decoupled)
        self.attn = nn.MultiheadAttention(dim, 8)          # reasoning component
        self.knowledge_db = knowledge_db                  # globally shared vectors
        self.backward_residual = None                     # will hold shallow knowledge

    def forward(self, x, prev_states):
        # Backward Residual Connection: add shallow-layer knowledge
        if self.backward_residual is not None:
            x = x + self.backward_residual
        # Dynamic Latent Reasoning: query the whole knowledge DB
        query = self.ffn(x)                               # retrieve latent knowledge
        attn_output, _ = self.attn(query, self.knowledge_db, self.knowledge_db)
        # store current shallow knowledge for deeper layers
        self.backward_residual = query.detach()
        return attn_output, prev_states + [x]

# Mock global knowledge vector database (e.g., 1024 vectors of dim 768)
knowledge_db = torch.randn(1024, 768)

# Stack a few Mobius layers
layers = nn.ModuleList([MobiusLayer(768, knowledge_db) for _ in range(4)])

def forward_pass(tokens):
    hidden = tokens
    states = []
    for layer in layers:
        hidden, states = layer(hidden, states)
    # Parallel multi-token decoding from refined latent states (simplified)
    logits = hidden @ hidden.T  # placeholder for actual decoder
    return logits

// Illustrative sketch (not from the paper)
const torch = require('torch-js'); // placeholder for a tensor library

class MobiusLayer {
  constructor(dim, knowledgeDb) {
    this.ffn = torch.nn.Linear(dim, dim); // decoupled knowledge storage
    this.attn = torch.nn.MultiheadAttention(dim, 8); // reasoning
    this.knowledgeDb = knowledgeDb; // globally shared vectors
    this.backwardResidual = null; // shallow‑layer knowledge cache
  }

  forward(x) {
    // Backward Residual Connection
    if (this.backwardResidual) {
      x = torch.add(x, this.backwardResidual);
    }
    // Dynamic Latent Reasoning: query full knowledge DB
    const query = this.ffn.apply(x);
    const [attnOut] = this.attn.apply(query, this.knowledgeDb, this.knowledgeDb);
    // store shallow knowledge for deeper layers
    this.backwardResidual = query.clone();
    return attnOut;
  }
}

// Mock global knowledge vector database (e.g., 1024 vectors of dim 768)
const knowledgeDb = torch.randn([1024, 768]);

// Build a stack of Mobius layers
const layers = [];
for (let i = 0; i < 4; i++) {
  layers.push(new MobiusLayer(768, knowledgeDb));
}

function forwardPass(tokens) {
  let hidden = tokens;
  for (const layer of layers) {
    hidden = layer.forward(hidden);
  }
  // Parallel multi-token decoding from refined latent states (simplified)
  const logits = torch.matmul(hidden, hidden.transpose()); // placeholder decoder
  return logits;
}