LLM을 위한 Y-Combinator: λ-Calculus로 Long-Context Rot 해결하기

# λ-RLM 핵심 패턴 - 직접 구현 예시
# github.com/lambda-calculus-LLM/lambda-RLM 참고

from typing import List, Callable

def split(text: str, k: int) -> List[str]:
    """SPLIT combinator: 텍스트를 k개 청크로 균등 분할"""
    chunk_size = len(text) // k
    return [text[i*chunk_size:(i+1)*chunk_size] for i in range(k)]

def lambda_rlm(
    prompt: str,
    model_fn: Callable[[str], str],  # leaf에서만 호출되는 LLM
    context_window: int = 32000,
    k_star: int = 2,  # Theorem 4: 최적 partition size = 2
    task_type: str = "aggregate"
) -> str:
    """λ-RLM 재귀 실행기 (Y-combinator 패턴)"""
    tau_star = context_window  # leaf threshold
    
    def phi(P: str) -> str:  # 재귀 executor
        if len(P) <= tau_star:
            # Base case: LLM 직접 호출 (유일한 신경망 연산)
            return model_fn(P)
        else:
            # Recursive case: 순수 심볼릭 연산
            chunks = split(P, k_star)           # SPLIT - 결정론적
            results = [phi(chunk) for chunk in chunks]  # MAP - 재귀
            return reduce_by_task(results, task_type)   # REDUCE - 결정론적
    
    return phi(prompt)

def reduce_by_task(results: List[str], task_type: str) -> str:
    """태스크별 composition operator"""
    if task_type == "aggregate":
        return "\n".join(results)  # MERGE
    elif task_type == "search":
        return max(results, key=lambda x: len(x))  # BEST
    elif task_type == "summarize":
        return "\n".join(results)  # CONCAT (이후 상위 M 호출)
    return "\n".join(results)

# 사용 예시
import openai
def call_llm(text: str) -> str:
    resp = openai.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": text}]
    )
    return resp.choices[0].message.content

# 128K 토큰 문서를 2K context 모델로 처리
long_doc = "..." * 50000  # 매우 긴 문서
result = lambda_rlm(
    prompt=long_doc,
    model_fn=call_llm,
    context_window=2000,
    k_star=2,  # 최적값
    task_type="aggregate"
)