🤖 machine learning

LLM-TabLogic: Preserving Inter-Column Logical Relationships in Synthetic Tabular Data via Prompt-Guided Latent Diffusion

The paper introduces LLM-TabLogic, a novel framework that combines Large Language Model reasoning with latent space diffusion to generate synthetic tabular data that effectively preserves complex inter-column logical relationships without requiring domain knowledge, thereby outperforming existing baselines in fidelity, utility, and privacy.

Original authors: Yunbo Long, Liming Xu, Alexandra Brintrup

Published 2026-05-19

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Yunbo Long, Liming Xu, Alexandra Brintrup

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Problem: "Frankenstein" Data

Imagine you are a chef trying to create a new recipe book. You have a real cookbook with thousands of recipes. You want to make a fake cookbook that looks and tastes exactly like the real one, but without using any of the original recipes (to protect the chef's secrets).

The problem is that real data (like recipes) has logic.

If a recipe says "Bake at 400°F," it can't also say "Bake for 10 minutes" if the dish is a delicate soufflé that needs 2 hours.
If a shipping record says "Shipped from London," the "Country" column must say "UK." It can't say "France."

Most computer programs that generate fake data are like blind copycats. They look at the "London" column and the "Country" column separately. They might generate a row that says "London" and "France" because they both appear often in the real data, even though that combination is impossible in the real world. This creates "Frankenstein" data: it looks real on the surface, but the internal logic is broken, making it useless for real-world decisions.

The Solution: LLM-TabLogic

The authors of this paper built a new system called LLM-TabLogic. Think of it as a two-step process involving a "Smart Architect" and a "Master Builder."

Step 1: The Smart Architect (The LLM)

First, they use a Large Language Model (LLM)—a super-smart AI that reads and understands text.

What it does: Instead of just looking at numbers, the AI reads the column names and descriptions (like "Order Date" and "Delivery Date").
The Magic: It acts like a detective, figuring out the rules. It realizes, "Ah, the 'Delivery Date' must always be after the 'Order Date'." It also spots that "City" must match "Country."
The Compression: The AI then writes down these rules as a simple "cheat sheet" or a set of instructions. It strips away the complex, rigid rules from the data so the next step doesn't have to worry about breaking them.

Step 2: The Master Builder (The Diffusion Model)

Next, they use a Diffusion Model. Imagine this as a sculptor who starts with a block of noise (static) and slowly carves it into a statue.

The Process: Usually, sculptors (diffusion models) struggle with complex shapes because they get confused by the details.
The Twist: Because the "Smart Architect" already gave them the cheat sheet of rules, the sculptor only has to focus on creating the shape and texture of the data (the numbers and categories) without worrying about the logic.
The Result: The model generates new, fake rows of data that look statistically perfect.

Step 3: Reassembling the Puzzle

Finally, the system takes the "sculpted" data and uses the "cheat sheet" from the Architect to fill in the missing logical pieces.

If the sculptor generated a "Quantity" and a "Price," the system automatically calculates the "Total" to ensure the math is perfect.
If it generated a "City," it forces the "Country" to match the rule.

Why is this better than the old ways?

The paper tested this against five other methods (including old-school techniques and newer AI models). Here is how they compared:

Old Methods (like SMOTE): They are like photocopiers. They just take existing rows and mix them slightly. They are good at keeping the "flavor" but bad at creating new, diverse combinations. They also often fail to keep the privacy safe.
Deep Learning Models (like CTGAN or TabDDPM): These are like statisticians. They are great at matching the average numbers and patterns, but they often miss the "story." They might generate a "Delivery Date" that is before the "Order Date" because they didn't understand the timeline.
LLM-TabLogic: This is the Hybrid. It understands the story (logic) because of the LLM, but it generates the data (numbers) efficiently using the Diffusion model.

The Results: What did they find?

The paper tested this on real-world industrial data (like retail sales and purchasing records).

Logic is King: LLM-TabLogic was the only method that got the "logic" right almost 100% of the time. It never generated impossible dates or mismatched countries.
Privacy: It kept the data private. It didn't just copy-paste real people's data; it created new, unique rows that looked real but didn't belong to anyone specific.
Usefulness: When they used this fake data to train other computers to make predictions (like "Will this shipment be late?"), the results were almost as good as if they had used the real data.

The Bottom Line

The paper claims that LLM-TabLogic is the first method that successfully teaches a computer to understand the rules of a table (like a supply chain) before generating fake data.

By separating the logic (handled by the smart text-reading AI) from the generation (handled by the noise-to-data sculptor), they created synthetic data that is:

Logically Consistent: No impossible dates or mismatched locations.
Private: It doesn't leak real secrets.
Useful: It works for real business simulations.

The authors admit the system relies on the AI understanding the column names correctly (if the names are confusing, the AI might get confused), but for now, it sets a new standard for creating realistic, safe, and logical fake data.

Technical Summary: LLM-TabLogic

Problem Statement

Synthetic tabular data is increasingly vital for addressing data scarcity and privacy concerns in industrial applications such as supply chain analytics and digital twin simulations. However, existing generative models face a critical limitation: while they often preserve global statistical properties (e.g., marginal distributions and pairwise correlations), they frequently fail to maintain domain-specific inter-column logical relationships.

In complex real-world systems, columns are interdependent through strict constraints, such as:

Temporal constraints: Delivery dates must occur after order dates.
Mathematical constraints: Total sales price must equal unit price multiplied by quantity.
Hierarchical constraints: A specific city must belong to a corresponding country.

Current methods, including interpolation-based techniques (SMOTE), Generative Adversarial Networks (CTGAN), diffusion models (TabDDPM, TabSyn), and Large Language Model (LLM) approaches (GReaT), struggle to explicitly preserve these intricate, row-specific dependencies. This failure results in synthetic data that lacks real-world utility for simulation and decision-making, despite potentially high statistical fidelity.

Methodology: LLM-TabLogic

The authors propose LLM-TabLogic, a novel framework that integrates LLM reasoning with score-based latent diffusion to generate synthetic tabular data that strictly adheres to inter-column logical relationships. The approach operates through a four-stage pipeline:

1. Serialization and Prompt-Guided Reasoning

The process begins by serializing column names and their metadata descriptions into natural language. These serialized inputs, combined with general prompts and task-specific instructions, are fed into an LLM (e.g., GPT-4 or DeepSeek). The LLM performs logical reasoning to infer and compress complex inter-column relationships into structured representations. The output is categorized into three dependency types:

Hierarchical Consistency ( $R_H$ ): Mappings between granular and aggregate attributes (e.g., City $\to$ Country).
Mathematical Dependencies ( $R_M$ ): Mappings between independent variables and derived variables (e.g., Price $\times$ Quantity $\to$ Total).
Temporal Dependencies ( $R_T$ ): Ordered sequences of columns (e.g., Order Date $\to$ Delivery Date).

2. Tabular Data Compression

Instead of forcing a generative model to learn rigid, deterministic rules (which provide no probabilistic signal), the framework uses the LLM-derived relationships to compress the data.

Deterministic variables (e.g., derived columns) are removed or replaced with their generating functions.
The remaining "independent" variables form a compressed dataset ( $X_c$ ).
This step effectively decouples the logical constraints from the stochastic generation process, allowing the generative model to focus on learning the underlying distribution of the independent variables.

3. Latent Space Generation

The compressed data $X_c$ is tokenized and encoded into a latent space using a Transformer-based Variational Autoencoder (VAE). A score-based diffusion model is then trained on these latent embeddings ( $H_0$ ).

Forward Process: Gaussian noise is progressively added to the latent embeddings.
Reverse Process: A neural network learns the score function ( $\nabla \log p(H_t)$ ) to iteratively denoise the data, recovering the original latent distribution.
Synthetic latent embeddings ( $H'$ ) are sampled from this learned distribution.

4. Synthetic Data Decompression

The generated latent embeddings are decoded back into the compressed data space ( $X'_c$ ). Finally, the decompression function ( $f_{decom}$ ) utilizes the previously extracted logical relationships ( $R_H, R_M, R_T$ ) to reconstruct the full dataset ( $X'$ ). This step re-introduces the derived variables and enforces the hierarchical and temporal constraints, ensuring the final synthetic data is logically consistent with the original schema.

Key Contributions

Novel Framework: The paper introduces the first method to explicitly preserve complex inter-column relationships in synthetic tabular data generation without requiring manual domain knowledge, leveraging LLMs for relationship inference.
Evaluation Framework: The authors propose a comprehensive evaluation framework assessing synthetic data across six dimensions: Accuracy, Diversity, Utility, Privacy, Consistency, and Dependency. This moves beyond traditional metrics (like ML utility) to include logical consistency.
Hybrid Architecture: The approach uniquely combines the semantic reasoning capabilities of LLMs (for relationship extraction) with the high-fidelity distribution modeling of score-based diffusion models (for data generation).

Experimental Results

The method was evaluated on two real-world industrial datasets (Retail and Purchasing) and compared against five baselines: SMOTE, CTGAN, TabDDPM, TabSyn, and GReaT.

Logical Consistency: LLM-TabLogic achieved near-perfect scores (approx. 99.9% - 100%) on Hierarchical Consistency Score (HCS) and Multivariate Dependency Index (MDI), significantly outperforming all baselines. While GReaT showed strong logical preservation, it struggled with other metrics. Latent space-based models (CTGAN, TabDDPM) performed poorly on logical consistency.
Data Fidelity: The method achieved state-of-the-art performance in $\alpha$ -Precision (high-order statistics) and pairwise correlations, matching or exceeding the performance of TabSyn and SMOTE.
Utility: In downstream machine learning tasks (classification via XGBoost), LLM-TabLogic achieved the highest AUC scores on the Retail dataset and second-highest on the Purchasing dataset, demonstrating that logical consistency translates to better predictive utility.
Privacy: The method achieved an optimal balance between Data Fidelity and Privacy (measured by Distance to Closest Record, DCR). Unlike SMOTE, which offered high fidelity but poor privacy, and TabDDPM, which offered high privacy but low utility, LLM-TabLogic maintained high utility while ensuring strong privacy preservation.

Significance and Claims

The paper claims that LLM-TabLogic sets a new benchmark for synthetic tabular data generation by solving the "logical consistency" gap that has limited the applicability of existing methods in real-world industrial scenarios.

First of its Kind: The authors assert this is the first method to effectively preserve inter-column relationships without requiring explicit domain knowledge, relying instead on LLM reasoning.
Industrial Applicability: By ensuring that synthetic data adheres to real-world constraints (e.g., supply chain logistics, financial calculations), the method enables reliable use in digital twins, agent-based simulations, and decision-making systems where logical errors would render synthetic data useless.
Balanced Trade-off: The approach successfully navigates the traditional trade-off between data fidelity, utility, and privacy, offering a robust solution for privacy-preserving data sharing in sensitive industrial domains.

The authors acknowledge limitations, noting that the method's performance depends on the LLM's ability to interpret column descriptions (which may fail with ambiguous or abbreviated names) and that current evaluations are limited to supply chain and healthcare datasets. Future work aims to extend this to cross-table relationships and more diverse industrial domains.