Paper deep dive
Constraint-Guided Enterprise Data Mapping with Large Language Models
Sebastian Monka, Pramod Anantharam, Thien Vo Minh, Lavdim Halilaj
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 93%
Last extracted: 8/29/2026, 4:12:05 AM
Summary
The paper introduces Constraint-Guided Mapping (CGM), a neuro-symbolic method for enterprise entity alignment that uses schema-grounded hard and soft constraints to restrict the hypothesis space before neural ranking and LLM disambiguation. This approach ensures structural validity, handles unit/granularity mismatches, and reduces expert effort by ~7x compared to manual workflows, while matching the performance of larger LLMs at significantly lower cost.
Entities (6)
Relation Signals (5)
Constraint-Guided Mapping → uses → Large Language Models
confidence 95% · We propose constraint-guided mapping (CGM), a neuro-symbolic method... neural ranking with bounded LLM disambiguation
Constraint-Guided Mapping → evaluatedon → Valentine
confidence 92% · Public Valentine results add an external ranking sanity check
Constraint-Guided Mapping → achieves → 7x cost reduction
confidence 90% · a small model with constraints matches a frontier LLM used without them at ~28x lower cost
Constraint-Guided Mapping → outperforms → Manual Matching
confidence 90% · lowers expert effort by ~7x versus spreadsheet workflows
Constraint-Guided Mapping → comparedto → Magneto
confidence 88% · For comparison we (i) run SOTA Magneto... on Valentine
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Enterprise entity alignment must handle semi-structured records, implicit attributes, and unit or granularity mismatches. Manual matching is still common in practice, but does not scale as schemas and providers evolve. LLM-only matching improves semantic recall, yet can violate structural and physical invariants, producing fluent yet operationally invalid correspondences. We propose constraint-guided mapping (CGM), a neuro-symbolic method with three stages: (i) schema-grounded admissibility constraints with metadata mc = <tau_c, delta_c>, where tau_c denotes the constraint type and delta_c provides executable relation and normalization logic; (ii) constraint-restricted candidate generation with cascade relaxation to guarantee a nonempty feasible set under noise; and (iii) neural ranking with bounded LLM disambiguation restricted to that feasible set. Methodologically, constraints operate as hypothesis-space operators rather than post-hoc validators, enabling controlled degradation under relaxation and auditable, human-guidable decisions. On a controlled structural-decoy benchmark, hard admissibility shrinks the candidate space by ~480x without dropping the GT, and a layer-by-layer ablation shows this gate, not the LLM, is the decisive lift (F1 0.08 to 0.66). The benefit is model-independent and adds no extra inference cost: a small model with constraints matches a frontier LLM used without them at ~28x lower cost. The method, not a single tuned configuration, transfers across seven enterprise makes (macro F1 0.70), each under its own automatically discovered, expert-refinable constraints, and lowers expert effort by ~7x versus spreadsheet workflows. Public Valentine results add an external ranking sanity check and mark the boundary: constraints should be hard only where structural invariants are match-determining.
Tags
Links
- Source: https://arxiv.org/abs/2608.24218v1
- Canonical: https://arxiv.org/abs/2608.24218v1
Trouble viewing inline? Open PDF directly →
Full Text
56,376 characters extracted from source content.
Expand or collapse full text
textrm ⊳ Constraint-Guided Enterprise Data Mapping with Large Language Models Sebastian Monka1 Email: sebastian.monka@de.bosch.com Pramod Anantharam2 Email: pramod.anantharam@us.bosch.com Thien Vo Minh3 Email: Thien.VoMinh@vn.bosch.com Lavdim Halilaj1 Email: lavdim.halilaj@de.bosch.com Affiliation: 1Bosch Center for Artificial Intelligence, Renningen, Germany 2Bosch Center for Artificial Intelligence, Pittsburgh, USA 3Robert Bosch GmbH, Ho Chi Minh City, Vietnam Abstract Enterprise entity alignment must handle semi-structured records, implicit attributes, and unit or granularity mismatches. Manual matching is still common in practice, but it does not scale as schemas and providers evolve. LLM-only matching improves semantic recall, yet it can violate structural and physical invariants, producing fluent yet operationally invalid correspondences. We propose constraint-guided mapping (CGM), a neuro-symbolic method with three stages: (i) schema-grounded admissibility constraints with metadata mc=⟨τc,δc⟩m_c= _c, _c , where τc _c denotes the constraint type and δc _c provides executable relation and normalization logic; (i) constraint-restricted candidate generation with cascade relaxation to guarantee a nonempty feasible set under noise; and (i) neural ranking with bounded LLM disambiguation restricted to that feasible set. Methodologically, constraints operate as hypothesis-space operators rather than post-hoc validators, enabling controlled degradation under relaxation and auditable, human-guidable decisions. On a controlled structural-decoy benchmark, hard admissibility shrinks the candidate space ∼480× 480× without dropping the GT, and a layer-by-layer ablation shows this gate—not the LLM—is the decisive lift (F1 →0.660.08\!→\!0.66). The benefit is model-independent and adds no extra inference cost: a small model with constraints matches a frontier LLM used without them at ∼28× 28× lower cost. The method—not a single tuned configuration—transfers across seven enterprise makes (macro F1 0.700.70), each under its own automatically discovered, expert-refinable constraints, and lowers expert effort by ∼7× 7× versus spreadsheet workflows. Public Valentine results add an external ranking sanity check and mark the boundary: constraints should be hard only where structural invariants are match-determining. 1 Introduction Enterprise data products must align heterogeneous schemas from different organizations, legacy systems, and evolving conventions. Although schema matching and entity resolution are well studied Rahm and Bernstein (2001); Bellahsene et al. (2013), enterprise alignment remains largely manual as schemas, providers, and naming conventions continuously change. Prior methods combine schema- and instance-level signals, often as independently scored components; we instead formalize enterprise alignment as constraint-guided correspondence inference, where symbolic constraints define admissible candidates and neural components rank and disambiguate only within this bounded hypothesis space. As a motivating example, aligning a source record Panda 141 i.e. (engine_c=10001000, year range 1991--1996) to the target Fiat Panda 141 (engine_size=1.0 L, build date 20.08.1993) requires implicit-attribute extraction, unit conversion (10001000\,c=1.0=1.0\,L), and granularity matching—not lexical similarity. Such failure modes defeat lexical or unconstrained neural matching. We address them with CGM: executable symbolic constraints (δc _c) define the admissible space, and neural components rank and disambiguate only within it. Contributions. (1) A constraint-preconditioned neuro-symbolic method: hard constraints act as hypothesis-space operators before neural reasoning, with cascade relaxation guaranteeing a nonempty feasible set and bounded LLM disambiguation valid by construction. (2) A controlled study of why and when constraints help: competitive with SOTA matchers on public schema matching, and—via a released synthetic benchmark, a layer-by-layer ablation, and an ambiguity-trap analysis—showing that where numbers, units, and identifiers decide the match, probabilistic matching is misled while admissibility stays valid by construction, with the hard gate the decisive layer (F1 →0.660.08\!→\!0.66). (3) A model ablation showing the benefit is model-independent and adds no extra per-mapping LLM calls: a small model with constraints reaches the same 100%100\% validity as a frontier model at ∼ 28×28× lower cost. (4) An enterprise deployment reducing expert effort by ∼ 7×7×, with implementation and benchmark released. 2 Problem Setting and Requirements We align source entities to canonical targets under schemas Ss,StS_s,S_t. Compared to curated benchmarks, enterprise data couples three heterogeneity classes: representation (composite/implicit fields), structure (unit and aggregation mismatch), and semantics (abbreviations, multilingual variants, temporal drift)—the failure modes of the motivating example above. Representation and structure define admissibility; semantics is resolved within admissible candidates. These demand invariants beyond lexical similarity, yielding four requirements: (1) controlled semantic decomposition of implicitly encoded fields; (2) explicit constraint enforcement for unit and granularity compatibility; (3) graceful degradation when constraints are incomplete; and (4) auditability of the contributing constraints and signals. Together these motivate a constraint-guided pipeline with hard admissibility, cascade relaxation, and bounded neural disambiguation. 3 Related Work Entity matching and alignment are long-standing data-integration problems Rahm and Bernstein (2001); Bellahsene et al. (2013); Valentine provides a benchmarking framework Koutras et al. (2021) and recent surveys summarize LLM opportunities and limits Freire et al. (2025). The distinguishing axis across paradigms is when structural validity is enforced. Constraint/rule systems enforce domain invariants through declarative specifications: reliable when assumptions hold, but brittle under paraphrases, sparse metadata, and heterogeneous naming Qi and Wang (2025); Khoee et al. (2025). PLM- and LLM-based matchers improve semantic flexibility (Ditto and follow-ups Li et al. (2020); Döhmen et al. (2024); Xu and others (2024); Zhang et al. (2023); Parciak et al. (2025); profile-based reasoning Peeters and Bizer (2023)) but typically score correspondences without a hard admissibility gate and may propagate representation/normalization errors. Constrained, grounded neuro-symbolic pipelines—constrained decoding (CRANE) and retrieval-/knowledge-grounded methods (ReMatch, KG-RAG4SM, SMoG, MATP) Banerjee et al. (2025); Sheetrit et al. (2024); Ma et al. (2025); Jeon et al. (2025); Zheng et al. (2026)—improve reliability but operate at the token level or over a softly filtered pool. Magneto, the closest baseline in scope, targets scalable enterprise mapping via retrieval and iterative refinement Freire and others (2025). Unlike all of these, we treat constraints as hypothesis-space operators applied before neural reasoning—schema-grounded hard admissibility (with δc _c-encoded normalization) over the entity-level candidate space, with cascade relaxation guaranteeing a nonempty feasible set and traceable degradation. For comparison we (i) run SOTA Magneto Freire and others (2025) and standard matchers (COMA, Cupid, SimilarityFlooding, Jaccard) on Valentine, and adapt the same Magneto to record-level matching on our synthetic and enterprise benchmarks (Appendix E); (i) on enterprise data use an unconstrained retrieval-augmented LLM matcher as a faithful proxy (our LLM baseline: rule-informed retrieval ++ LLM decision without gating); and (i) release a synthetic benchmark (Section 6.1) isolating the core heterogeneity classes. 4 Problem Formalization We formalize enterprise alignment as constraint-guided correspondence inference. Let Es,EtE_s,E_t be source/target entity sets with schema attributes Ss,StS_s,S_t. The ground-truth alignment is a set-valued map M:Es→2EtM:E_s→ 2^E_t, where et∈M(es)e_t∈ M(e_s) iff es,ete_s,e_t are semantically and structurally consistent. The system returns a prediction M~(es) M(e_s) drawn from a bounded shortlist M^(es) M(e_s) with |M^(es)|=k≪|Et|| M(e_s)|=k |E_t|. Schema-grounded constraints. Domain knowledge is a set of constraints C, each c=⟨asi,mc,atj⟩c= a_s^i,\,m_c,\,a_t^j referencing a source and target attribute with metadata mc=⟨τc,δc⟩m_c= _c, _c : type τc∈hard,soft _c∈\hard,soft\ and executable relation/normalization logic δc _c. Instantiated from δc _c and representative examples (then expert-reviewed), each constraint is a predicate c:(Es(asi),Et(atj))→0,1c:(E_s(a_s^i),E_t(a_t^j))→\0,1\ enforcing compatibility (identifier, unit, aggregation). Hard constraints C~h C_h eliminate invalid correspondences; soft constraints C~s C_s contribute ranking evidence (⋅~ · denotes the executable, instantiated form). Admissible space and cascade relaxation. For ese_s, the admissible space under hard constraints is ℋC~h(es)=et∈Et∣∀c∈C~h:c(es,et)=1H_ C_h(e_s)=\e_t∈ E_t ∀ c∈ C_h:\ c(e_s,e_t)=1\. To handle noise, we relax hard constraints in priority order, taking the largest subset C~h∗ C_h^* with ℋC~h∗(es)≠∅H_ C_h^*(e_s)≠ and setting ℋ(es):=ℋC~h∗(es)H(e_s):=H_ C_h^*(e_s). Relaxation is monotone (C~h′⊆C~h⇒ℋC~h(es)⊆ℋC~h′(es) C_h C_h _ C_h(e_s) _ C_h (e_s)), so it terminates in at most |C~h|| C_h| steps; if all hard constraints are dropped (C~h∗=∅ C_h^*= ) then ℋ(es)=EtH(e_s)=E_t and the method reduces to unconstrained retrieval. Prediction and evaluation. The system predicts M~(es)⊆M^(es)⊆ℋ(es) M(e_s) M(e_s) (e_s): hard constraints (with relaxation) induce ℋH, neural ranking forms the shortlist M M, and disambiguation resolves M~ M within it. A prediction is complete (M~(es)=M(es) M(e_s)=M(e_s)), partial (M(es)⊂M~(es)M(e_s)⊂ M(e_s)), or wrong otherwise. 5 Approach CGM applies a constraint-guided design in which executable hard constraints C~h C_h define ℋ(es)H(e_s) before neural ranking and LLM disambiguation, so neural inference runs under symbolic admissibility (M~(es)⊆M^(es)⊆ℋ(es) M(e_s) M(e_s) (e_s))—preserving semantic flexibility while guaranteeing structural consistency. Figure 1 overviews the pipeline. Source datasetEsE_s Target datasetEtE_t Expert matching criteria LLM constraint transformation Constraints C1C_1: constraint 1 C2C_2: constraint 2 C3C_3: constraint 3 Validation 1 | Constraint generation Encoder Encoder 2 | Constraint-restricted candidate generationC1C_1C2C_2C3C_3 LLM bounded prediction Results M~(es) M(e_s) 3 | Constraint-guided mappingCCC~s C_sC~s C_sC~h⇒ℋ(es) C_h (e_s)M^(es) M(e_s) Figure 1: CGM as a constrained funnel: hard constraints C~h C_h shrink the catalog to the admissible set ℋ(es)H(e_s), soft-constraint neural ranking forms the shortlist M^(es) M(e_s), and the LLM selects only within it—so M~(es)⊆M^(es)⊆ℋ(es) M(e_s) M(e_s) (e_s) by construction. 5.1 Constraint Definition and Validation Expert knowledge is encoded as executable constraints that specify the referenced source and target attributes, a transformation or constraint expression, and a type τ∈hard,softτ∈\hard,soft\. Hard constraints define admissibility; soft constraints provide ranking signals (Appendix B works one hard and one soft rule end to end, Table 7). Expert-assisted constraint specification. The expert specifies a constraint skeleton by selecting source attribute asa_s, metadata mc=⟨τ,δ⟩m_c= τ,δ , and target attribute ata_t. Given representative examples, the LLM proposes an executable predicate over Es(as)E_s(a_s) and Et(at)E_t(a_t). The user can edit δ (transformation logic) or adjust only τ∈hard,softτ∈\hard,soft\. Automatic constraint discovery. When constraints cannot be enumerated upfront, an adapted AIDE-style search Jiang et al. (2025) proposes candidate predicates and a fast, LLM-free selector chooses the hard-constraint subset maximizing recall×selectivity: keep the GT in ℋ(es)H(e_s) (recall) while shrinking it (selectivity), with cascade relaxation when a set empties. This complements expert specification—experts author δc _c directly or audit the selected set—and is cheap and reproducible (no LLM, no embedder). Selection is strictly separated from evaluation: per make the gold alignment is split 60/4060/40 (seeded), mining and subset search see only the train split, kept rules must survive an overfit guard on the disjoint test split, and every reported number is measured on that test split (Appendix F). Validation and refinement. LLM-proposed constraints C~ C undergo lightweight validation for execution safety, schema consistency, expert-intent alignment, and sample-level compatibility; failed proposals trigger structured feedback with bounded retries, all logged for auditability. This step is load-bearing because the LLM reliably selects the right attributes but its proposed transformation δ is unreliable—either omitting a required normalization or over-fitting a destructive one. The recall×selectivity selector catches both pathologies automatically (quantified per make in the Discussion, Section 6.4), leaving the expert a narrow, high-leverage role: supply the normalization the LLM omits. 5.2 Constraint-Restricted Candidate Generation For a source entity ese_s we enforce hard constraints first (including value-dependent checks such as unit compatibility) to obtain ℋ(es)H(e_s); if strict enforcement is empty we apply cascade relaxation (Section 4) and record the active subset C~h∗ C_h^*. Empty-set relaxation alone is insufficient when a source key matches a non-empty but wrong block—an internal code can collide with a differently-numbered target range (the target catalog renumbers the same vehicle), so the gate returns plausible yet wrong candidates and never relaxes. We therefore relax additionally when the best admissible similarity falls below a threshold, re-admitting candidates under the remaining constraints; on Make E this recovers the colliding-code cases empty-set relaxation misses (Section 6.3). The coverage bottleneck is thus not only missing keys but also colliding ones. Soft-Constraint Neural Ranking. Within the admissible set ℋ(es)H(e_s), an encoder (the Encoder of Figure 1, here text-embedding-3-large) embeds each record, and semantic similarity is computed over these embeddings: s(es,et)=sim(es,et)+∑c∈C~swcc(es,et).s(e_s,e_t)=sim(e_s,e_t)+ _c∈ C_sw_c\,c(e_s,e_t). Candidates are ranked as M^(es)=TopKet∈ℋ(es)s(es,et). M(e_s)= *TopK_e_t (e_s)s(e_s,e_t). Here sim(es,et)∈[0,1]sim(e_s,e_t)∈[0,1] is the cosine similarity of the records’ embeddings, each soft predicate c(es,et)∈0,1c(e_s,e_t)∈\0,1\ is evaluated from δc _c, and wc≥0w_c≥ 0 weights soft constraint c (uniform wc=1w_c=1 unless tuned on a validation split). The top-k scored candidates form the shortlist M^(es) M(e_s) passed to disambiguation. 5.3 Bounded LLM Disambiguation and Configuration Models. Unless stated otherwise all LLM stages use gpt-5.4-mini (hosted Azure, temperature 00); retrieval uses text-embedding-3-large. The chat model is a per-run parameter (Section 6.1); models are off-the-shelf, no fine-tuning. We default to gpt-5.4-mini because inside CGM it matches the frontier gpt-5.4 (both reach 100%100\% constraint-validity, Section 6.1) at a fraction of the cost. The LLM has two bounded roles: it instantiates constraints (emitting the executable δc _c from an expert skeleton, editable by the expert) and disambiguates over the ranked shortlist M^(es) M(e_s), not the full target set—so the per-entity LLM budget is constant in k and independent of |Et||E_t|. Disambiguation and admissibility guarantee. The disambiguation prompt contains ese_s and the shortlist M^(es) M(e_s) with identifiers—already pre-filtered to satisfy the active hard constraints C~h∗ C_h^*—plus an optional expert priority hint (a soft refinement, not required for admissibility). The model returns ⟨selected_keys,abstain,reasoning⟩ selected\_keys, abstain, reasoning (optionally via schema-constrained decoding) with keys from the supplied identifiers; the selection is intersected with M^(es) M(e_s), and abstain (or full relaxation) yields “no confident match”. Admissibility thus holds by post-filter rather than by trusting the model: M~(es)⊆M^(es)⊆ℋ(es) M(e_s) M(e_s) (e_s) by construction—the LLM can reorder, select, or reject, but any identifier outside the admissible set is dropped, so it cannot introduce or hallucinate a target outside that space. Validity is defined w.r.t. the active set ℋ(es)H(e_s) after relaxation; constraints dropped by cascade or similarity relaxation are reported separately as coverage failures. We log C~h∗ C_h^*, applied δc _c, scores, and relaxation level; prompt templates are in Appendix C. Expert priority as a reusable artifact. Beyond executable constraints, the expert can supply a short natural-language priority over attributes—e.g. “model identity first (never cross models at equal displacement), then displacement, then every period-overlapping variant”—injected into the disambiguation prompt from the config without code. This encodes expert knowledge as a soft, auditable, reusable artifact rather than a bespoke rule, converting residual partial matches into complete ones at near-zero marginal effort—what makes the disambiguation “expert-improved” (quantified in Section 6.4). 6 Evaluation Evaluation roadmap. Our central claim is causal: constraints improve mapping by reshaping the hypothesis space before neural reasoning, not by adding a feature to a scorer. We test it on three datasets (Table 4, Appendix A): a released synthetic ablation isolates the mechanism, quality, and model scale (Section 6.1); public Valentine places our ranker against SOTA matchers and marks when admissibility should relax (Section 6.2); and enterprise data tests deployment under production noise and scale (Section 6.3). 6.1 Controlled Synthetic Ablation We first isolate the mechanism on a controlled, record-level diagnostic with exact ground truth, where the lexically most similar target is deliberately the wrong one and only an exact structural key recovers the GT—a stress test concentrating the adversarial cases, not a real-world distribution. Each GT label is reworded down in text similarity and paired with near-identical distractors that each violate exactly one structural key, instantiating the four heterogeneity classes of Section 4; to match enterprise conditions the generator also leaves keys missing, allows one-to-many, and varies decimal formats. Source S0008 is canonical: its GT is lexically the farthest candidate (0.340.34 vs. 0.750.75) yet the only admissible one (Appendix B; the generator is released). Constraints carve the space (LLM-free). With the LLM held out so the effect is attributable to constraints alone, hard admissibility on the ∼12 12k-target catalog shrinks the candidate set ∼480× 480× without dropping the GT (recall 100%100\% via cascade relaxation) and makes every retained candidate structurally valid, where the unfiltered similarity pool is almost entirely invalid. The operator thus reshapes the hypothesis space before any neural reasoning. Which mechanism does the work (end-to-end decomposition). Adding the LLM back, we build the pipeline up one layer at a time on a held-out split, so each rung’s delta isolates the layer it adds (Table 1; same model and prompt). We score complete (predicted set equals GT), partial (GT plus extras—overcomplete and reviewable, never structurally wrong), and wrong, with macro per-source F1/Jaccard since complete/partial/wrong is gameable. The pattern is sharp: feature selection and normalization alone do not help—handed normalized but un-gated candidates, the LLM is still misled—and the hard-admissibility gate is the decisive jump (F1 →0.660.08\!→\!0.66); the final rung trades a little exact-complete for a lower wrong rate, a conservative operating point. The residual wrong rate concentrates where the discriminating key is missing and admissibility cannot fire—a coverage limit, not a flaw in the mechanism. The same ordering holds on a harder distribution with deep one-to-many targets and 9%9\% unmatchable (NO_MATCH) sources, where SOTA Magneto collapses to F1 0.020.02 as structural decoys keep the GT out of its retrieved shortlist (Recall@5050 0.170.17), a retrieval bottleneck no reranker fixes (Table 11, Appendix E). Table 1: Decomposition of the CGM funnel on the synthetic benchmark (n=120n=120 held-out, gpt-5.4-mini, |Et|≈12,094|E_t|≈12,094). Each rung adds one mechanism, so its delta attributes the gain; F1/Jaccard are macro per-source set-overlap. Normalization without a gate hurts (L1→ 2); the gate is the decisive jump (L2→ 3, F1 +0.58+0.58). Rung Adds Compl.↑ Wrong↓ F1↑ Jacc.↑ L0 all-columns RAG — 10.0 69.2 0.19 0.16 L1 rule columns (raw) feature selection 18.3 55.0 0.32 0.28 L2 ++ rule functions normalization 0.0 66.7 0.08 0.05 L3 ++ hard gate admissibility 52.5 26.7 0.66 0.63 L4 ++ relax ++ hint relaxation ++ expert 49.2 23.3 0.66 0.61 Across classes and model scales. The gain is neither one easy case nor a capability gap a larger model closes. CGM wins every heterogeneity class, with the largest margin on the purely numeric signals (granularity and unit; Appendix E). Varying the chat model across a frontier/mid/small axis (gpt-5.4/-mini/-nano), every CGM configuration drives valid-match to 100%100\%, whereas the unconstrained LLM stays mostly invalid regardless of scale (Table 8). Because admissibility is a symbolic filter, CGM issues the same number of LLM calls—no extra cost—so the smallest model inside CGM matches the frontier model used without constraints at ≈28×≈28× lower cost. Scaling the LLM does not substitute for constraints. 6.2 Public Benchmark: External Sanity Check (Valentine) As an external sanity check we run the ranking component on the public Valentine suite, which matches schema columns (not records), so it only tests whether our ranker stays competitive on neutral data—MRR and Recall@GT on a ten-scenario NYC suite against the bundled matchers (COMA, Cupid, SimilarityFlooding, Jaccard) and SOTA Magneto Freire and others (2025) (Table 2). CGM is competitive with the SOTA matcher rather than dominant: MRR 1.001.00 (its top-scored candidate is correct for every source column) and Recall@GT 0.710.71 vs. Magneto’s 0.930.93/0.760.76. The near-perfect MRR is expected and not our main evidence—Valentine columns are lexically and semantically separable, the easy corner where any strong ranker saturates; the constraint argument is needed precisely where Valentine is not, on record-level structural decoys. Magneto’s residual Recall@GT edge comes from a global top-|GT||GT| cutoff resolved by its bipartite 1:11:1 assignment, not a better signal. A rigid type gate lowers our MRR (→0.941.00\!→\!0.94) because Valentine has correct cross-type matches—the boundary condition of the thesis: admissibility should engage only where structural invariants are match-determining. Where structural constraints decide. Valentine’s ambiguity traps are the regime CGM targets: columns separable only by value distribution, where a name-based resolver gets 3/103/10 but a value-distribution constraint 8/108/10. The same signal gap is why the SOTA matcher fails on our record-level task: with structural decoys the GT never enters the top-k—a retrieval failure even Magneto’s LLM reranker cannot fix, and our unconstrained LLM baseline fails identically. The two drivers, catalog scale and structural decoys, combine in enterprise data and drop Magneto to zero on the real Make A catalog (Appendix E, Table 9), whereas at the strict gate (the no-relaxation counterpart to Magneto’s Recall@55) CGM keeps the GT for 0.720.72 of synthetic and 0.860.86/0.960.96 of Make E/Make A sources—rising toward the 100%100\% of Section 6.1 as relaxation trades selectivity. Table 2: Schema matching on a ten-scenario public Valentine suite (MRR, Recall@GT). Magneto is the SOTA matcher (mpnet retriever); CGM is our neural ranker (text-embedding-3-large). CGM leads MRR; Magneto keeps a Recall@GT edge through its bipartite 1:11:1 reranker. A rigid type gate lowers CGM’s MRR to 0.940.94 by pruning correct cross-type matches. Best per row bold. Cupid Jaccard SimFlood COMA Magneto CGM MRR 0.47 0.70 0.75 0.76 0.93 1.00 R@GT 0.43 0.56 0.57 0.65 0.76 0.71 6.3 Enterprise Deployment The controlled studies isolate the mechanism; we finally ask whether its gains survive real schema drift, production scale, and one-to-many structure. CGM is deployed internally as the Data Mapping Copilot on expert-validated data across seven makes (anonymized Make A–G), each matched against its make-specific pool of up to ∼ 1212k targets (at production scale ∼ 66k source, ∼ 335335k target entries). Crucially, each make is mapped by the same pipeline under its own autoresearch-discovered constraints on a held-out split—so the question is not whether one tuned configuration works but whether the method transfers. Constraint coverage. Before judging mapping quality we measure whether constraints produce useful admissible sets in real catalogs—the recall×selectivity ceiling the LLM operates within. The deployed config is not hand-tuned: the LLM-free selector of Section 5.1 chooses the subset maximizing recall×selectivity, modeling the production engine’s cascade relaxation. The discriminating identifier constraint is the structural workhorse (Table 12, Appendix F): on Make A, where an LLM would otherwise rank nearly 1212k targets by name alone, it collapses the pool ∼18× 18× at near-full recall, and removing it re-inflates the set for little recall gain—exactly the controlled behavior cascade relaxation provides. The same holds across makes once each make’s discriminating key is identified, as the autoresearch loop does (e.g. a generation code needing a make-specific prefix transform on Make C, an engine code on Make F); reading coverage before quality shows the per-make F1 spread is set by whether such a key exists and by GT cardinality, not by LLM capability. Mapping quality. The central deployment result is that CGM generalizes across all seven makes under one method: per make the autoresearch loop discovers the constraints (Section 5.1), and the identical pipeline reaches macro F1 0.700.70 (0.660.66 source-weighted; Table 3), versus F1 0.210.21 for the same naive LLM over the raw record (the L0 rung, measured on Make E in Appendix D). What varies is not whether the method works but by how much, and the constraint view explains it: where the catalog exposes a discriminating code the gate is decisive, while the two one-to-one makes (Make F, Make G) face a harder exact-match ceiling because the source cannot always separate same-engine siblings—a cardinality limit, not an LLM failure. The discriminator recipe is constant—model name (soft) ++ identifier/code (hard) ++ displacement—so the constraint primitives transfer where bespoke per-make rules do not. Table 3: CGM generalizes across seven enterprise makes (held-out split; gpt-5.4-mini), each under its own autoresearch-discovered constraints (model name soft ++ identifier/code hard ++ displacement) with the identical end-to-end pipeline. nsn_s sources, |Et||E_t| candidates, card. mean GT per source; Wrong == a relevant target missed; F1/Jaccard macro per-source, sorted by F1. Make nsn_s |Et||E_t| card. Compl.↑ Wrong↓ F1↑ Jacc.↑ Make A 45 11,934 6.1 84.4 15.6 0.855 0.851 Make B 28 2,917 2.2 64.3 21.4 0.793 0.763 Make C 88 706 8.3 62.5 34.1 0.711 0.687 Make D 30 11,205 5.2 40.0 46.7 0.654 0.583 Make E 98 373 1.7 36.7 41.8 0.634 0.561 Make F 55 8,183 1.0 40.0 60.0 0.400 0.400 Make G† 7 3,051 1.0 85.7 14.3 0.857 0.857 Macro mean 59.1 33.4 0.701 0.672 Make names anonymized. †Make G has only ns=7n_s=7 held-out sources; reported for completeness, excluded from emphasis. Source-weighted F1 0.660.66; macro F1 excluding Make G 0.670.67. Architecture comparison. The same layer-by-layer decomposition on Make E (Appendix D) reproduces the synthetic ordering on real data—feature selection and normalization add little, the hard-admissibility gate is again the decisive jump (F1 →0.600.32\!→\!0.60), and relaxation plus the optional expert hint give the final lift—and holds qualitatively on every make. Expert effort. Expert effort is the practical endpoint. Each make is mapped by one domain expert and the fleet spans many makes with comparable tasks, so we compare the four setups as medians across makes (Table 13). Effort falls monotonically from spreadsheet workflows through Rules and Rules ++ LLM to CGM—10.510.5 to 1.51.5 days per make, a ∼7× 7× reduction with the fewest interactions. 6.4 Discussion When each method wins; one bottleneck. Neural and symbolic components are complementary because they read different signals: the ranker excels at semantic similarity (paraphrase, abbreviations, multilingual aliases), hard constraints at exact structural distinctions (identifiers, codes, normalized displacements, year ranges). This principle explains the per-make variance (Table 3), the synthetic challenges, and the Valentine traps—all cases where text misleads and an exact key decides. CGM does not uniformly dominate mature hand-tuned rules, but versus LLM-only it sharply cuts wrong predictions and lowers expert effort. The LLM reliably finds which attributes discriminate but is unreliable on the transformation—on Make E it omits the c→literc\!→\!liter normalization, on Make D it invents a substitution collapsing an exact engine-code key (100%→10%100\%\!→\!10\%)—both caught by the recall×selectivity selector, leaving the expert only the omitted normalization (the priority hint then cuts wrong →25.5%39.8\!→\!25.5\%). Constraint discovery lowers authoring effort but is a supporting mechanism; the central contribution is constraint-guided inference. Performance is governed by constraint coverage, not embeddings or LLM scale (Sections 6.1, 6.3); cascade relaxation degrades gracefully toward retrieval when keys are absent. Porting beyond automotive (finance, life sciences, geospatial) requires only re-instantiating the schema-agnostic δc _c. Limitations. The synthetic study is a deliberate stress test, not a real-world distribution; the expert-effort study is small; and Valentine tests column-level ranking, not record-level transfer. The central claim—constraints reshape the hypothesis space before neural reasoning—nonetheless holds across the diagnostic, model-scale, and coverage evidence. 7 Conclusion We presented constraint-guided mapping (CGM): constraints act as hypothesis-space operators before neural ranking and bounded LLM disambiguation, with cascade relaxation. A layer-by-layer decomposition shows the hard-admissibility gate—not the LLM—is the decisive layer (F1 →0.660.08\!→\!0.66), model-independently and at no extra cost; the method transfers across seven enterprise makes (macro F1 0.700.70) and cuts expert effort ∼7× 7×. Future work targets automatic constraint induction, uncertainty calibration, and validation beyond automotive. We release the implementation, the benchmark generator, and the Valentine harness; enterprise data is restricted. Appendix A Evaluation Roadmap Table 4: Evaluation as an evidence ladder: each experiment answers one plain question about the constraint mechanism, rather than standing alone as a separate dataset. Read top to bottom—isolate the mechanism, then test whether model scale or a public baseline change the picture, then whether it transfers and pays off in practice. Question Experiment Verdict Evidence Where Does the gate shrink the search space without dropping the GT? Synthetic ++ rule ablation Yes admissible set ∼0.2% 0.2\% of catalog, GT kept (100%100\% synth., 96%96\% Make A) §6.1 Which layer actually drives the gain? Layer decomposition (L0→ 4) Hard gate F1 jumps →0.660.08\!→\!0.66 §6.1, App. D Can a bigger LLM replace constraints? Model ablation No CGM 100%100\% valid for every model, 28×28× lower cost App. E.1 Is the ranker competitive on public data? Valentine Yes MRR 1.001.00 vs. SOTA Magneto 0.930.93 §6.2 Does one method transfer across makes? Enterprise (77 makes) Yes mean F1 0.700.70 with per-make constraints §6.3 Does it cut expert effort in practice? Expert study Yes →1.510.5\!→\!1.5 days per make (7×7×) App. F Appendix B Synthetic Benchmark: Schema and Worked Example The synthetic benchmark deliberately uses different source and target schemas, so each correspondence must cross a structural heterogeneity rather than a name change. Table 5 lists the field-level mismatches and the constraint δc _c that bridges each; the same four classes appear in the enterprise data (Section 2). Table 5: Source→ field mismatches in the synthetic benchmark. Each structural key is encoded differently on the two sides; the hard constraint normalizes both to a comparable form, the soft constraint handles fuzzy naming. The generator is released. Source field Target field Heterogeneity Constraint δc _c engine_code (B4D) in model_label (Astra 2.0 (B4D)) implicit attribute hard: extract code; equality engine_c (2000) displacement_l (2.0) unit inconsistency hard: c/1000=Lc/1000=L year_start–year_end build_date granularity hard: year ∈[start,end]∈[start,end] generation (Mk3) generation_code version / identifier hard: equality model_text (Astra 2.0) model_label (reworded) lexical naming soft: embedding sim. Worked example. Table 6 traces one source through its candidates. The GT target is the lexically least similar candidate (0.340.34 vs. 0.750.75 for every distractor): a similarity- or LLM-only ranker keying on names is misled with near-certainty. Each distractor is near-identical in text yet violates exactly one hard constraint—a wrong embedded engine code or a wrong generation—so admissibility prunes all three and retains only the GT, and CGM maps correctly. Where a discriminating key is instead absent on the source (e.g. generation empty), the corresponding rule cannot fire and such a distractor survives: the constraint-coverage bottleneck quantified in Section 6.1. Table 6: One source and its candidate targets (benchmark seed 1313). Source S0008: model_text=“Astra 2.0”, engine_code=B4D, engine_c=2000, year range 2002--2004, generation=Mk3. “Sim.” is source–target text similarity; the GT is the lowest, yet the only admissible candidate. Cand. model_label gen. Sim. Outcome T0034 Opel Astra Hatchback (B4D) Mk3 0.34 GT – admissible T0035 Astra 2.0 (EP6) Mk3 0.75 reject: code EP6≠ 4D T0036 Astra 2.0 (G4F) Mk3 0.75 reject: code G4F≠ 4D T0037 Astra 2.0 (B4D) 141 0.75 reject: gen. 141≠ 3 From columns to decision: the rule engine. Each rule is a pair of expressions over column names: a source_expression over the source attribute and a target_expression over the target attribute (the LLM-emitted fields of Appendix C), not a per-record script. The rule engine evaluates both expressions on every row to bring the two sides into a comparable form, and only then does execution run (Table 7). Hard and soft rules share this two-sided structure and differ only at execution. For the hard unit rule the source expression converts engine_c to liters (1998→2.01998→ 2.0) and the target expression strips the unit token from displacement_l (2.0 L→ 2.0); execution tests equality, keeping only targets whose normalized value matches and pruning the rest before the LLM—a structurally impossible option, however close its name, can never be selected. The soft naming rule works the same way—the source splits the model name out of model_text (G4F - Astra→ ) and the target lowercases model_label (Astra→ )—but execution computes cosine similarity rather than equality: it never prunes, only orders the survivors so the correct target ranks first. Hard rules gate admissibility (equality, pre-LLM); soft rules set order (similarity, within ℋH)—the funnel of Figure 1 in miniature: structure first removes the impossible, then meaning ranks the plausible. Table 7: A rule is a source_expression and a target_expression over the two column names (Appendix C); the engine evaluates both on every row, then execution compares—equality for hard (gates admissibility), cosine similarity for soft (sets order). Shown for one source record (engine_c=1998, model_text=“G4F - Astra”). Hard and soft share the two-sided structure and diverge only at execution: hard gates admissibility by equality of normalized values, soft orders the survivors by name similarity. Hard rule (unit) Soft rule (naming) Source expr. round("engine_c"/1000, 1) split("model_text", ’ - ’)[1] Target expr. split("displacement_l", ’ ’)[0] lower("model_label") Rule Engine src: 1998 → 2.0; tgt: 2.0 L → 2.0 src: G4F - Astra → Astra; tgt: Astra → astra Execution equality: match(2.0, 2.0) cosine sim: sim(Astra, astra) Appendix C Prompt Templates We use templated prompts with deterministic decoding (temperature 00). Variables in braces are filled per call; the constraint-instantiation prompt is specialized for hard vs. soft rules. Constraint instantiation (skeleton → executable δc _c). Generate an executable rule for data mapping. Input: source column a_s with example values, target column a_t with example values, constraint type tau in hard, soft, expert comment comment. Output (JSON): name, source_expression, target_expression, rule_type, description. Hard rules: source/target expressions must normalize to IDENTICAL values for a match (extractions, unit/type casts, range expansion allowed). Soft rules: keep expressions SIMPLE (text extraction only); embedding similarity handles fuzzy matching. Bounded disambiguation. Source record: e_s Candidate targets (pre-filtered to satisfy the hard constraints; the only admissible matches): shortlist with identifiers Select every candidate key that correctly matches the source; a source may map to several targets, so prefer including a plausible match to dropping a correct one. Choose keys ONLY from the candidate list; do not invent identifiers. If none is a confident match, abstain. optional expert priority hint, injected from the config Output: keys as "Target keys: [...]" (default) or JSON selected_keys, abstain, reasoning (structured mode). The hard constraints are not re-stated to the model; the candidate list is already pre-filtered, and the returned keys are intersected with the shortlist, so the prediction is admissible by construction regardless of what the model emits. Appendix D Enterprise Architecture Ablation To attribute the gain to specific mechanisms rather than to the pipeline as a whole, we decompose the CGM funnel layer by layer on enterprise Make E (held-out split, n=98n=98, gpt-5.4-mini), adding one layer at a time so each per-rung delta is the contribution of that layer (macro per-source F1). The pattern mirrors the synthetic decomposition of Table 1: the naive LLM over the serialized raw record (L0) barely works (F1 0.210.21); rule-based feature selection and unit/format normalization (L0→ 2) add little (F1 →0.320.21\!→\!0.32); the hard-admissibility gate (L2→ 3) is the decisive jump (F1 →0.600.32\!→\!0.60, complete →337\!→\!33); and similarity-relaxation plus the expert priority hint (L3→ 4) add the final lift (F1 0.630.63, complete 3737, wrong 4242). A side observation reinforces the selection effect: handing the LLM the full raw source row instead of the rule-selected fields hurts (complete →24.532.7\!→\!24.5, wrong →45.939.8\!→\!45.9)—the extra columns are noise, so the soft constraints act as feature selection on the source side, mirroring the gate on the target side. Appendix E Additional Synthetic Analyses These four cuts of the synthetic ablation complement the layer-by-layer decomposition in the main text (Table 1, n=120n=120 held-out): how the gain varies with model scale (E.1), why the SOTA neural matcher collapses on this record-level task (E.2), how each heterogeneity class behaves in isolation (E.3), and how the whole picture holds on a harder distribution (E.4). E.1 Model Scale On the full corpus (N=500N=500, Table 8) we report validity and cost—both model-independent, so the sample size is incidental: the constraint lift drives every chat model on a frontier/mid/small axis to 100%100\% valid at equal cost, while the unconstrained LLM stays ∼ 10%10\% valid regardless of scale. Table 8: Model ablation on the synthetic benchmark (N=500N=500, |Et|≈12,094|E_t|\!≈\!12,094): for each chat model we read across one row, from the unconstrained LLM only baseline to the same model inside CGM (encoder fixed). Valid == % of predictions satisfying the active hard-constraint set (after cascade/similarity relaxation, Section 5.2); cost in USD per 10001000 mappings is indicative and essentially equal in both settings (CGM issues the same calls), so we report it once. The pattern is the same on every row: the LLM alone stays ∼ 10%10\% valid from frontier to small model, while admissibility lifts every model to 100%100\% at the same cost—the gain is model-independent and adds no per-mapping LLM calls. Valid (%)↑ Model LLM only ++ CGM Cost ($/1k) gpt-5.4 10.6 100 3.59 gpt-5.4-mini 9.0 100 0.49 gpt-5.4-nano 10.2 100 0.13 E.2 Why Retrieval Fails on Structural Decoys The SOTA neural matcher Magneto, adapted to the same record-level task, collapses on every heterogeneity class (0%0\% complete, Recall@5∼0.055\, 0.05; consistent with its record-level collapse in Section 6.2): its failure is a retrieval failure—GT in the top-55 for only ∼5% 5\% of sources at this catalog scale, not a ranking one—so even its optional GPT reranker, which only re-orders the SLM shortlist, cannot recover a GT target retrieval never surfaced—a hard ceiling we can quantify: on the extended benchmark at ∼12 12k targets the GT is in Magneto’s top-5050 for only 17%17\% of sources (Recall@5050 0.170.17), so any reranker over that shortlist is bounded at Recall@55 ≤0.17≤ 0.17, versus CGM’s admissible-set retention of 0.620.62 (Table 11). The synthetic generator lets us isolate the two factors that drive this collapse (Table 9): structural decoys and catalog scale. At a small catalog Magneto’s Recall@55 falls from 0.620.62 (semantic, decoys off—the Valentine-like corner) to 0.150.15 once decoys are added; scaling the catalog to enterprise size (∼12 12k) lowers it further to 0.180.18 (semantic) and 0.050.05 (with decoys). Each factor moves it the same direction, and enterprise data combines both—which is exactly why the same matcher that is SOTA on Valentine collapses here. The lesson is signal-specific and matcher-agnostic: when the discriminating key is structural (code, unit, generation, year), no embedder or LLM quality substitutes for an admissibility constraint. Table 9: Record-level Magneto on the synthetic benchmark, isolating the two factors behind its collapse (mean Recall@55 over 33 seeds, N=500N=500). Adding structural decoys and scaling the catalog each lower retrieval independently; enterprise data is the bottom-right corner (both factors), Valentine the top-left (neither). At a small catalog the retrieval ceiling stays high (Recall@5050 0.990.99 semantic, 0.500.50 structural); at ∼12 12k it does not, so an LLM reranker over the shortlist has little GT to promote. Catalog Semantic (decoys off) Structural (decoys on) Small 0.62 0.15 Enterprise (∼12 12k) 0.18 0.05 E.3 Per-Heterogeneity Breakdown The synthetic benchmark is a controlled simplification of the enterprise mapping task, so we can place the real unconstrained-LLM baseline and CGM on identical instances per heterogeneity class (Table 10). Isolating one structural heterogeneity at a time (N=50N=50 adversarial-only instances) strips out the easy lexical cases and concentrates exactly the adversarial ones where a structural key, not text, decides—so the unconstrained LLM scores lower here (00–4%4\% complete, 99–15%15\% valid) than as the mixed L0 baseline (10%10\%), by design rather than inconsistency, while CGM reaches 4242–72%72\% at 100%100\% valid—largest on the purely numeric signals (unit, granularity). An LLM-free dose-response sweep (one heterogeneity varied at a time) isolates the constraint component and confirms the method’s single sensitivity: it is invariant to value noise, rewording, and one-to-many cardinality, and degrades only as the discriminating source key goes missing—the coverage bottleneck. Table 10: Per-heterogeneity ablation (N=50N=50, |Et|≈12,094|E_t|\!≈\!12,094; identical instances): complete-match % for the unconstrained LLM (gpt-5.4-mini) vs. CGM. The LLM collapses on every class while CGM lifts complete most on the purely numeric signals (unit, granularity; best bold); CGM predictions are 100%100\% valid by construction here as everywhere (Table 8). Record-adapted SOTA Magneto (mpnet retriever) collapses identically—0%0\% complete in every class, Recall@5∼0.055\, 0.05—a retrieval bottleneck no reranker fixes. Heterogeneity LLM CGM Implicit attribute encoding 4.0 42.0 Unit inconsistency 2.0 70.0 Version / identifier 2.0 56.0 Granularity mismatch 4.0 72.0 All mixed 0.0 42.0 E.4 Extended Synthetic Benchmark Robustness on a harder distribution (deep one-to-many ++ NO_MATCH). The extended synthetic benchmark adds deep one-to-many quotas and a 9%9\% NO_MATCH rate to stress the same mechanism on a more realistic distribution, and places all three method families on it with the CGM funnel decomposed (Table 11). The picture is unchanged: SOTA Magneto effectively fails (complete 0%0\%, F1 0.020.02; its retrieval ceiling Recall@5050 0.170.17 bounds out even its GPT reranker—which we verified is otherwise functional, improving Recall@55 →0.480.36\!→\!0.48 in a small-catalog control where the GT is retrievable, so the enterprise failure is a retrieval ceiling, not a disabled reranker), the naive LLM barely functions (F1 0.170.17), and the hard-admissibility gate is again the decisive lift (F1 →0.560.17\!→\!0.56). The two normalization-only rungs (L1, L2) do not help without the gate—they even hurt—exactly as on the base benchmark. Table 11: Extended synthetic benchmark (deep one-to-many ++ 9%9\% NO_MATCH, |Et|≈12|E_t|\!≈\!12k): SOTA Magneto and the LLM→ funnel decomposition in one view. LLM/CGM rungs use gpt-5.4-mini (n=200n=200 held-out, the L0–L4 ladder); Magneto uses its mpnet retriever (33 seeds, N=500N=500), both on the same generator. F1 is macro per-source set overlap. The hard gate (L2→ 3) is the decisive jump. We report Magneto at the retrieval stage because its LLM (GPT) reranker is provably capped here: a reranker only reorders the retrieved top-5050, and the GT is in that shortlist for just 17%17\% of sources (Recall@5050 0.170.17), bounding any reranker—MagnetoGPT included—at Recall@5≤0.175≤ 0.17, far below CGM. Method / rung Adds Compl.↑ Wrong↓ F1↑ Magneto (base mpnet) SOTA baseline 0.0 96.1 0.02 L0 all-columns RAG LLM-only 7.5 76.5 0.17 L1 rule columns (raw) feature selection 16.5 60.5 0.32 L2 ++ rule functions normalization 0.0 73.5 0.08 L3 ++ hard gate admissibility 43.0 35.0 0.56 L4 ++ relax ++ hint relaxation ++ expert 40.5 35.0 0.54 Appendix F Enterprise Coverage and Deployment Details These tables support the enterprise deployment (Section 6.3); the per-make mapping quality is in the main text (Table 3). Table 12 reports the LLM-free constraint-coverage ablation (Section 6.3)—the recall×selectivity ceiling on the two largest catalogs, before the LLM operates—and Table 13 gives the full expert-effort study. Both use the same autoresearch-discovered constraints as the per-make deployment, underscoring the point that the same constraint primitives transfer across makes where bespoke per-make rules do not. Split hygiene and overfit guard. Constraint selection and evaluation are strictly separated. Per make the expert-validated gold alignment is split 60/4060/40 into train/test with a fixed seed, and the protocol is: (i) candidate predicates are mined from the train split only and unioned with the fixed schema-grounded pool; (i) the LLM-free recall×selectivity subset search runs on train only; (i) an overfit guard re-scores the selected config and every kept proposal on the held-out test split and discards a proposal whose train→ score drop is large—if the mined config does not generalize better than the fixed-pool config on test, the conservative fixed-pool config is used; (iv) the end-to-end pipeline, LLM included, is then run on the test split only. Neither the selector nor the LLM ever sees the evaluation data, and every experiment (train and test metrics, keep/discard/overfit decisions) is journaled per make. Both Table 3 and Table 12 therefore report held-out test-split numbers. Table 12: Rule ablation on enterprise data (LLM-free; internal held-out split). Recall == sources whose GT is kept in ℋH; Sel. =1−|ℋ|/|Et|=1-|H|/|E_t|. The auto-selected config collapses the candidate space at near-flat recall; removing the discriminating identifier rule re-inflates it. Make (|Et||E_t|) Hard-rule config Recall Mean |ℋ||H| Sel. Make E (373373) none 100.0 373.0 0.0 selected (model ++ variant) 86.0 50.2 86.5 −- internal-model 93.4 364.0 2.4 Make A (11,93411,934) none 100.0 11934.0 0.0 selected (model ++ type-group) 96.4 664.2 94.4 −- model-type-group 96.4 5479.3 54.1 Table 13: Expert effort under cross-dataset mapping: one domain expert per make, median values across the deployed makes (a between-make field comparison with comparable tasks, not a within-subject trial). TTC: time to completion; MpH: mappings per hour; Interactions: cases where the available data is insufficient and the expert must seek extra information to complete a mapping; Constraints: hard++soft rules authored (CGM only; the baselines use a different rule mechanism, hence “–”). Best per metric in bold. Setup TTC (days) MpH Interactions Constraints Excel (manual) 10.5 118 – – Rules 6.0 207 112 – Rules + LLM 4.5 276 48 – CGM (Expert) 1.5 827 31 2 hard + 1 soft References Banerjee et al. (2025) D. Banerjee, T. Suresh, S. Ugare, S. Misailovic, and G. Singh CRANE: reasoning with constrained LLM generation. In Proceedings of the 42nd International Conference on Machine Learning (ICML), External Links: Link Cited by: §3. Bellahsene et al. (2013) Z. Bellahsene, A. Bonifati, and E. Rahm Schema matching and mapping. In Schema Matching and Mapping, External Links: ISBN 978-1-4614-6714-8 Cited by: §1, §3. Döhmen et al. (2024) T. Döhmen, R. Geacu, M. Hulsebos, and S. Schelter SchemaPile: a large collection of relational database schemas. Proceedings of the ACM on Management of Data 2 (3), p. 172:1–172:25. External Links: Document Cited by: §3. Freire et al. (2025) J. Freire, G. Fan, B. Feuer, C. Koutras, Y. Liu, E. Pena, A. Santos, C. Silva, and E. Wu Large language models for data discovery and integration: challenges and opportunities. IEEE Data Engineering Bulletin 49 (1), p. 3–15. External Links: Link Cited by: §3. Freire et al. (2025) J. Freire et al. Magneto: scalable and robust schema mapping with LLMs. Proceedings of the VLDB Endowment (PVLDB) 18. Note: To appear Cited by: §3, §3, §6.2. Jeon et al. (2025) M. Jeon, J. Suh, and S. Cho Schema matching on graph: iterative graph exploration for efficient and explainable data integration. arXiv preprint arXiv:2511.20285. External Links: Link Cited by: §3. Jiang et al. (2025) Z. Jiang, D. Schmidt, D. Srikanth, D. Xu, I. Kaplan, D. Jacenko, and Y. Wu AIDE: ai-driven exploration in the space of code. arXiv preprint arXiv:2502.13138. External Links: Document, Link Cited by: §5.1. Khoee et al. (2025) A. G. Khoee, S. Wang, Y. Yu, R. Feldt, and D. Parthasarathy GateLens: a reasoning-enhanced LLM agent for automotive software release analytics. arXiv preprint arXiv:2503.21735. External Links: Link Cited by: §3. Koutras et al. (2021) C. Koutras, G. Siachamis, A. D. Ionescu, K. Psarakis, J. Brons, M. Fragkoulis, C. Lofi, A. Bonifati, and A. Katsifodimos Valentine: evaluating matching techniques for dataset discovery. In 2021 IEEE 37th International Conference on Data Engineering (ICDE), p. 468–479. External Links: Document Cited by: §3. Li et al. (2020) Y. Li, J. Li, Y. Suhara, A. Doan, and W. Tan Deep entity matching with pre-trained language models. Proceedings of the VLDB Endowment (PVLDB) 14 (1), p. 50–60. External Links: Link Cited by: §3. Ma et al. (2025) C. Ma, S. Chakrabarti, A. Khan, and B. Molnár Knowledge graph-based retrieval-augmented generation for schema matching. arXiv preprint arXiv:2501.08686. External Links: Link Cited by: §3. Parciak et al. (2025) M. Parciak, B. Vandevoort, F. Neven, L. M. Peeters, and S. Vansummeren LLM-Matcher: a name-based schema matching tool using large language models. In Companion of the 2025 International Conference on Management of Data (SIGMOD), p. 203–206. External Links: Document Cited by: §3. Peeters and Bizer (2023) T. Peeters and C. Bizer Entity matching using large language models. arXiv preprint arXiv:2310.11244. External Links: Link Cited by: §3. Qi and Wang (2025) D. Qi and J. Wang CleanAgent: automating data standardization with LLM-based agents. Proceedings of the VLDB Endowment (PVLDB) 18. Note: Also available as arXiv:2403.08291 Cited by: §3. Rahm and Bernstein (2001) E. Rahm and P. A. Bernstein A survey of approaches to automatic schema matching. The VLDB Journal 10, p. 334–350. External Links: Document Cited by: §1, §3. Sheetrit et al. (2024) E. Sheetrit, M. Brief, M. Mishaeli, and O. Elisha ReMatch: retrieval enhanced schema matching with LLMs. arXiv preprint arXiv:2403.01567. External Links: Link Cited by: §3. Xu et al. (2024) C. Xu et al. KcMF: knowledge-consistent multi-source framework for schema matching. Information Sciences. Cited by: §3. Zhang et al. (2023) J. Zhang, Z. Shen, B. Srinivasan, S. Wang, H. Rangwala, and G. Karypis NameGuess: column name expansion for tabular data. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing (EMNLP), p. 13276–13290. External Links: Document Cited by: §3. Zheng et al. (2026) X. Zheng, N. Li, X. Luan, K. Wang, L. Shi, M. Sun, and H. Wang Beyond correctness: exposing LLM-generated logical flaws in reasoning via multi-step automated theorem proving. In Proceedings of the 48th International Conference on Software Engineering (ICSE), Research Track, Cited by: §3.