Improving LLM Reasoning with Dynamic Rules

# Illustrative sketch (not from the paper)
import torch

# Assume a transformer model with a list of layers
def identify_confidence_layer(model, inputs, rule_keys):
    entropies = []
    for i, layer in enumerate(model.layers):
        attn = layer.attention(inputs)  # placeholder for actual attention output
        # entropy over attention distribution w.r.t. rule_keys
        entropy = -torch.sum(attn * torch.log(attn + 1e-9), dim=-1).mean()
        entropies.append(entropy)
    confidence_idx = torch.argmin(torch.stack(entropies))
    return confidence_idx

# Encode external rules and project them into the model's KV cache space
def embed_and_project(rules, encoder, adapter):
    embeddings = encoder.encode(rules)          # pretrained sentence encoder
    projected = adapter(embeddings)            # learnable adapter to KV space
    return projected

# Decoding step that triggers dynamic rule re‑attention
def decode_step(model, token, kv_cache, confidence_idx, rule_kv):
    if token == "<SEARCH>":  # special search token
        # replace the KV cache at the confidence layer with the retrieved rule KV
        kv_cache[confidence_idx] = rule_kv
    output, new_cache = model.decode(token, kv_cache)
    return output, new_cache

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

// Identify the confidence layer by minimal attention entropy
function identifyConfidenceLayer(model, inputs, ruleKeys) {
  const entropies = [];
  model.layers.forEach((layer, i) => {
    const attn = layer.attention(inputs); // placeholder
    // entropy = -sum(p * log(p))
    const entropy = torch.neg(torch.sum(torch.mul(attn, torch.log(torch.add(attn, 1e-9))), -1)).mean();
    entropies.push(entropy);
  });
  const stacked = torch.stack(entropies);
  const confidenceIdx = torch.argmin(stacked).item();
  return confidenceIdx;
}

// Encode rules and project into KV cache space
function embedAndProject(rules, encoder, adapter) {
  const embeddings = encoder.encode(rules); // sentence encoder
  const projected = adapter(embeddings);      // learnable adapter
  return projected;
}

// Decoding step with dynamic rule re‑attention
function decodeStep(model, token, kvCache, confidenceIdx, ruleKV) {
  if (token === '<SEARCH>') { // special search token
    kvCache[confidenceIdx] = ruleKV; // replace KV at confidence layer
  }
  const { output, newCache } = model.decode(token, kvCache);
  return { output, newCache };
}