Tantangan Evaluasi Kalkulus pada Arsitektur AI

Membangun platform edukasi kalkulus interaktif seperti calculus.academa.ai menghadapi masalah determinisme fundamental: Large Language Models (LLM) bekerja dengan probabilitas token berikutnya, bukan manipulasi aljabar simbolik yang ketat. Pada kalkulus multivariabel (seperti integral lipat, gradien, matriks Hessian) dan diferensial simbolik, LLM rentan menghasilkan 'hallucinated arithmetic' dan langkah pembuktian yang tampak meyakinkan namun secara matematis keliru.

Untuk mengatasi masalah ini, terdapat dua pendekatan arsitektur utama: LLM Direct Generation (mempercayakan penalaran komputasi dan narasi pedagogis sepenuhnya pada model bahasa) atau Hybrid LLM-CAS (menggunakan Computer Algebra System deterministik seperti SymPy untuk validasi komputasi, dan LLM hanya untuk perumusan penjelasan linguistik).

Analisis Trade-Off: LLM Direct vs Hybrid LLM-CAS

1. Akurasi Simbolik dan Penalaran Multivariabel

Pada model LLM Direct, kesalahan tanda negatif, kegagalan eliminasi variabel pada integrasi parsial, dan kesalahan reduksi fraksi simbolik sering lolos. Sebaliknya, pendekatan Hybrid LLM-CAS memecah evaluasi menjadi dua lapisan: CAS memverifikasi kebenaran formula secara aksiomatis via representasi Abstract Syntax Tree (AST), sedangkan LLM bertugas menyusun umpan balik langkah demi langkah (scaffolding pedagogical feedback).

2. Latensi Inferensi

Eksekusi CAS lokal berjalan dalam orde milidetik (10–50 ms untuk sebagian besar operasi diferensiasi atau ekspansi polinomial). LLM direct memerlukan chain-of-thought tokens yang panjang, menghasilkan latency 1.5–5 detik per evaluasi. Pendekatan hybrid dapat langsung mengembalikan respons gagal ke user jika validasi langkah awal di CAS salah, tanpa perlu memicu inferensi LLM yang lambat.

3. Biaya Operasional (API Tokens)

Mengirim prompt penalaran lengkap (few-shot prompting, rubrik penilaian, dan context kalkulus) membutuhkan konsumsi token masuk dan keluar yang signifikan. Dengan memindahkan beban grading ke worker CAS internal, konsumsi token dapat dipangkas hingga 60-80%, membatasi pemanggilan API LLM hanya ketika pengguna meminta petunjuk elaboratif atau penjelasan kesalahan konseptual.

4. Kompleksitas Sistem dan Keandalan (Maintainability)

LLM direct memiliki arsitektur backend lebih ringkas (hanya orchestration layer menuju model provider API), namun membutuhkan prompt engineering berkelanjutan dan pengujian regresi non-deterministik. Pendekatan Hybrid membutuhkan worker CAS terisolasi, parsing teks ke ekspresi matematis yang aman, dan penanganan edge-case sintaks aljabar pengguna.

Arsitektur Hybrid LLM-CAS

Pola implementasi yang disarankan untuk platform kalkulus interaktif membagi request ke dalam pipeline berikut:

  1. Client Layer: Mengirimkan ekspresi LaTeX atau string aljabar mentah.
  2. Input Sanitization Boundary: Mencegah injection dan membatasi ukuran ekspresi sebelum dievaluasi.
  3. CAS Evaluation Worker: Menjalankan engine komputasi simbolik dalam sandbox (SymPy/Maxima) untuk memeriksa ekuivalensi matematis (simplify(step_n - expected_step) == 0).
  4. LLM Feedback Generator: Jika CAS menemukan inkonsistensi matematis, LLM menerima payload diagnosa terstruktur (misal: 'turunan terhadap x benar, namun integrasi terhadap y melanggar aturan rantai') untuk menghasilkan feedback natural kepada siswa.

Implementasi Boundary Validation Service

Mengevaluasi string ekspresi matematika sembarangan di CAS (seperti fungsi parse_expr atau eval di Python) membuka celah Remote Code Execution (RCE) dan serangan Denial of Service (DoS) melalui polinomial kompleks berderajat tinggi. Diperlukan boundary service yang membatasi operasi AST sebelum diserahkan ke worker SymPy:

import ast
from typing import Set

ALLOWED_NODES: Set[type] = {
    ast.Expression,
    ast.BinOp,
    ast.UnaryOp,
    ast.Constant,
    ast.Name,
    ast.Call,
    ast.Add,
    ast.Sub,
    ast.Mult,
    ast.Div,
    ast.Pow,
    ast.USub,
}

ALLOWED_FUNCTIONS: Set[str] = {
    "sin", "cos", "tan", "exp", "log", "sqrt", "diff", "integrate"
}

ALLOWED_IDENTIFIERS: Set[str] = {"x", "y", "z", "t", "e", "pi"}

class MathematicalValidationError(ValueError):
    pass

class MathExpressionValidator(ast.NodeVisitor):
    def __init__(self, max_depth: int = 15):
        self.max_depth = max_depth
        self.current_depth = 0

    def generic_visit(self, node: ast.AST):
        self.current_depth += 1
        if self.current_depth > self.max_depth:
            raise MathematicalValidationError("Ekspresi melampaui kedalaman AST maksimum.")

        if type(node) not in ALLOWED_NODES:
            raise MathematicalValidationError(f"Operasi AST tidak diizinkan: {type(node).__name__}")

        super().generic_visit(node)
        self.current_depth -= 1

    def visit_Call(self, node: ast.Call):
        if not isinstance(node.func, ast.Name):
            raise MathematicalValidationError("Pemanggilan fungsi kompleks tidak valid.")
        if node.func.id not in ALLOWED_FUNCTIONS:
            raise MathematicalValidationError(f"Fungsi aljabar tidak didukung: {node.func.id}")
        self.generic_visit(node)

    def visit_Name(self, node: ast.Name):
        if node.id not in ALLOWED_IDENTIFIERS and node.id not in ALLOWED_FUNCTIONS:
            raise MathematicalValidationError(f"Identifier tidak diizinkan: {node.id}")

def validate_and_parse_input(raw_expr: str) -> str:
    """Memvalidasi keamanan sintaks ekspresi sebelum diserahkan ke CAS worker."""
    if len(raw_expr) > 256:
        raise MathematicalValidationError("Panjang payload ekspresi melebihi batas (maks 256 karakter).")
    
    try:
        tree = ast.parse(raw_expr, mode="eval")
    except SyntaxError as exc:
        raise MathematicalValidationError(f"Kesalahan sintaks matematika: {exc.msg}") from exc

    validator = MathExpressionValidator()
    validator.visit(tree)
    return raw_expr

# Self-check
if __name__ == "__main__":
    valid_expr = "sin(x) + diff(x**2, x)"
    assert validate_and_parse_input(valid_expr) == valid_expr

    malicious_expr = "__import__('os').system('rm -rf /')"
    try:
        validate_and_parse_input(malicious_expr)
        assert False, "Validasi gagal menangkal eksekusi kode berbahaya."
    except MathematicalValidationError:
        pass
Catatan Keamanan: Jangan gunakan sympify(input_str) secara langsung terhadap payload input pengguna tanpa parsing AST atau konfigurasi evaluate=False dan whitelist simbol ketat. Gunakan timeout berbasis subprocess untuk eksekusi CAS guna mencegah thread starvation akibat kalkulasi integral non-konvergen.

Kesimpulan Keputusan Arsitektur

Gunakan pendekatan LLM Direct murni hanya untuk prototipe cepat atau pertanyaan kalkulus berbasis teks konseptual (seperti menjelaskan makna intuitif dari teorema Stokes). Untuk sistem pembelajaran yang membutuhkan verifikasi ketat terhadap step-by-step derivasi, platform harus menggunakan Hybrid LLM-CAS: delegasikan kebenaran komputasi kepada CAS, dan gunakan LLM murni sebagai generator umpan balik pedagogis.