Efficient Table Reasoning Through Partitioned Analysis

# Illustrative sketch (not from the paper)
import torch

# 1. Normalize table and add row_id column
def normalize_table(raw_table):
    # raw_table: list of dict rows
    normalized = []
    for i, row in enumerate(raw_table):
        row_copy = dict(row)
        row_copy["row_id"] = i  # insert row identifier
        normalized.append(row_copy)
    return normalized

# 2. Simple LLM‑style prompt to analyze question (placeholder)
def analyze_question(question):
    # Returns required columns and row‑filter pattern (mocked)
    return {"required_cols": ["col_a", "col_b"], "row_filter": lambda r: int(r["col_c"]) > 10}

# 3. Decompose table into column groups and row chunks
def decompose_table(table, col_groups):
    # col_groups: list of list of column names
    chunks = []
    for cols in col_groups:
        chunk = [{k: v for k, v in row.items() if k in cols or k == "row_id"} for row in table]
        chunks.append(chunk)
    return chunks

# 4. Select minimal evidence based on analysis
def select_evidence(chunks, analysis):
    selected = []
    for chunk in chunks:
        # keep only rows that satisfy the filter
        filtered = [r for r in chunk if analysis["row_filter"](r)]
        if filtered:
            selected.append(filtered)
    return selected

# 5. Serialize selected parts for LLM input
def serialize_evidence(evidence):
    # Convert list of rows to a compact string (mock)
    lines = []
    for chunk in evidence:
        for row in chunk:
            lines.append(str(row))
    return "\n".join(lines)

# Example pipeline (mock data)
raw_table = [{"col_a": 1, "col_b": 2, "col_c": 15}, {"col_a": 3, "col_b": 4, "col_c": 5}]
question = "What is the sum of col_a where col_c > 10?"

norm_table = normalize_table(raw_table)
analysis = analyze_question(question)
col_groups = [["col_a", "col_c"], ["col_b", "col_c"]]
chunks = decompose_table(norm_table, col_groups)
evidence = select_evidence(chunks, analysis)
context = serialize_evidence(evidence)
print(context)  # would be fed to an LLM

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

// 1. Normalize table and add row_id
function normalizeTable(rawTable) {
  return rawTable.map((row, idx) => ({ ...row, row_id: idx }));
}

// 2. Mock LLM analysis of the question
function analyzeQuestion(question) {
  // Returns required columns and a row filter function (mocked)
  return {
    requiredCols: ['colA', 'colB'],
    rowFilter: (r) => Number(r.colC) > 10,
  };
}

// 3. Decompose table into column groups (row chunks)
function decomposeTable(table, colGroups) {
  return colGroups.map((cols) =>
    table.map((row) => {
      const subset = { row_id: row.row_id };
      cols.forEach((c) => {
        if (c in row) subset[c] = row[c];
      });
      return subset;
    })
  );
}

// 4. Select minimal evidence based on analysis
function selectEvidence(chunks, analysis) {
  const selected = [];
  chunks.forEach((chunk) => {
    const filtered = chunk.filter(analysis.rowFilter);
    if (filtered.length) selected.push(filtered);
  });
  return selected;
}

// 5. Serialize evidence for LLM input
function serializeEvidence(evidence) {
  return evidence.flat().map((row) => JSON.stringify(row)).join('\n');
}

// Example pipeline (mock data)
const rawTable = [
  { colA: 1, colB: 2, colC: 15 },
  { colA: 3, colB: 4, colC: 5 },
];
const question = 'What is the sum of colA where colC > 10?';

const normTable = normalizeTable(rawTable);
const analysis = analyzeQuestion(question);
const colGroups = [['colA', 'colC'], ['colB', 'colC']];
const chunks = decomposeTable(normTable, colGroups);
const evidence = selectEvidence(chunks, analysis);
const context = serializeEvidence(evidence);
console.log(context); // would be sent to an LLM