People rarely value things one at a time. A student wants a lecture only if they also get its lab, and a renter wants either a large trunk or a roof rack but not both. Preference elicitation methods can handle such interactions, but only once someone has written down, by hand, which items or attributes interact. We propose to automate that step. A language model reads a person's free-text description of what they want and outputs the interaction structure: which groups of items complement each other, which substitute for each other, and which are independent. For each claimed interaction it also outputs a short explanation that points to the exact phrase in the person's own text that supports it. We train only on English and test on languages the model never saw during this training, including Urdu, Swahili, and Hindi.
The bet is that pointing to the user's words travels across languages better than explaining in English prose. Free-form chain-of-thought explanations are known to transfer poorly to low-resource languages. A pointer into the source text plus a label from a three-word vocabulary keeps the explanation inspectable without tying the reasoning to English tokens. If this holds, one model could remove a manual knowledge-engineering step from preference elicitation and fair allocation for users who do not write in English. The same experiments also give a direct test of an unresolved tension in the literature: explanations make classifiers easier to inspect, while continuous hidden reasoning transfers across languages better.
Core Claim
The utility model we target is Generalized Additive Independence (GAI). It writes a person's utility as a sum of small sub-utilities, each defined over a group of attributes that may interact. Preference Elicitation and Generalized Additive Utility shows that once the interaction graph is known, utilities can be calibrated with cheap "local" queries about a few attributes at a time, chosen by expected value of information. Calibration needs only $2m$ global queries for $m$ factors, which is the same cost as an additive model. That paper also states the catch: the graph itself must be known in advance. Writing it down is exactly the hand-curation step that older symbolic systems never got past. Goldman et al. argue that manual domain modeling has no termination criterion, and RESTAURANT Revisited describes how hand-specified cross-links between knowledge structures grow out of control as systems scale.
We claim three things. First, a multilingual model can predict this graph from free text. Second, a model trained with span-grounded typed explanations will beat both an otherwise identical model trained with label-only supervision and one trained with free-text English rationales, measured on zero-shot target-language accuracy of graph edges. Third, the predicted graph will cut the number of elicitation queries needed to reach a fixed regret, compared with assuming additivity or assuming every pair interacts. "Span-grounded typed explanation" means a supporting span copied from the input plus one of the labels needs-together, either-or, or unrelated.
Relation to Prior Work
Two lines of work show that language models can replace hand-written structure. Both stop short of preferences and of other languages. LIRAS translates English scenario descriptions into formal planning domains that a Bayesian inverse-planning engine then reasons over. It reaches a correlation with human judgments of $r = 0.75$ to $0.87$, against about $0.63$ for o3. That result motivates our approach, and we borrow its pattern of language feeding a downstream symbolic solver. LIRAS, however, builds action models in English grid worlds, not utility graphs. ExpeTrans replaces hand-curated classification heuristics with tips the model extracts from its own mistakes. With a GPT-3.5 backbone it reports 63.8% average accuracy over 13 English datasets, against 49.1% for zero-shot prompting and 54.9% for zero-shot chain-of-thought. That is evidence that explanation-like intermediate text helps classification. Its tasks are monolingual and single-label, so it says nothing about structured outputs.
The explanation-augmented classifiers supply our training recipe. DynaGuard reasons inside think tags before emitting a pass/fail label, trained with supervised fine-tuning followed by Group Relative Policy Optimization (GRPO), a reinforcement-learning method that scores groups of sampled outputs against each other. It reaches 73.1% F1 on DynaBench, against 13.1% for LlamaGuard3. GRACE trains a model to write rationales whose hidden states serve as embeddings, again with GRPO. We reuse the supervised-then-GRPO recipe, with a reward that checks each predicted edge and its cited span. Both papers evaluate only in English.
The paper that constrains our design is Is continuous CoT better suited for multilingual reasoning?. On zero-shot Urdu GSM8k it finds that continuous latent reasoning (CODI) scores 12.28% while textual chain-of-thought fine-tuning scores 6.84%. Its interpretation is that explicit textual reasoning ties the model to language-specific tokens. We take that result seriously rather than arguing against it. It is the reason we reject free English rationales, and it is why CODI is one of our main competitors. Our hypothesis is that the harm comes from long generated prose, and that an explanation consisting of a copied source span plus a tiny closed vocabulary avoids it.
For cross-lingual transfer we rely on Crosslingual Generalization through Multitask Finetuning. It shows that English-only instruction tuning of BLOOMZ and mT0 transfers to other languages, with a 50% gain over base BLOOM on non-English XNLI. That paper supplies our backbones and our English-only training regime. XNLI and MLQA document how much accuracy drops for distant languages and warn that translated test sets carry translation artifacts. That warning shapes how we build test data.
On the allocation side, Deploying Fair and Efficient Course Allocation Mechanisms notes that its deployed Yankee Swap mechanism cannot express bundle synergies. Learning Unanimously Acceptable Lotteries via Queries explicitly limits itself to additive values. Both papers motivate the downstream use of our extracted graphs.
Research Program
No benchmark for extracting interaction structure from text exists in the material, so the first deliverable is one. We start from two domains. One is the 26-variable car-rental domain of Braziunas and Boutilier. The other is a course-bundle domain modeled on the UMass course allocation setting, with lectures, linked labs, prerequisite pairs, and time-conflicting substitutes.
For each instance we sample a hidden GAI utility: a sparse interaction graph whose edges are labeled complementary or substitutable, plus sub-utility values. Annotators then write a first-person description of what they want that is consistent with that utility. Every gold edge comes with the annotator's marked supporting span. English descriptions provide training data. For the test languages we use native speakers, not translators, for most of the set. They write fresh descriptions from the same hidden utilities in Urdu, Swahili, Hindi, Arabic, Chinese, German, and Spanish. A smaller translated subset lets us measure how much translationese inflates scores. We plan roughly 3,000 English training descriptions and 300 native test descriptions per language. These are planned sizes, not measured ones.
The model is a multilingual instruction-tuned backbone. We use mT0 as the main backbone, and we also use LLaMA-3.2-1B-Instruct so we can match the CODI paper's setup. Given a description, the model emits one record per candidate interaction. Each record contains the edge, its type, and the copied supporting span. Training is supervised fine-tuning on English, followed by GRPO. The reward credits a correct edge type and a predicted span that overlaps the gold span. It also gives a small penalty for asserting an edge whose span does not appear in the input.
The predicted graph is passed unchanged to the Braziunas–Boutilier elicitation procedure. A simulated user answers its queries from the hidden true utility. For the course domain, we feed the elicited utilities to an allocation rule and score the outcome under the true non-additive utilities.
Baselines
The do-nothing reference is the empty graph, which means assuming additivity. It costs nothing to extract, and it is what deployed course-allocation systems do today. Its counterpart is the complete pairwise graph, which is safe but expensive to elicit. These two bracket the downstream query cost, and the oracle graph gives the floor. Our method beats this reference only if it lands meaningfully closer to the oracle's query count than either bracket at the same regret threshold.
The strongest competitor for raw extraction is direct prompting of the same multilingual backbone. We run it zero-shot and with few-shot English exemplars, with and without free chain-of-thought. All prompt variants get the same development-set tuning budget as our method. For comparison only, we also run one larger instruction-tuned model under the same prompts.
The strongest competitor for cross-lingual transfer is CODI-style continuous latent reasoning, trained on the same English data and backbone. On a related problem, Is continuous CoT better suited for multilingual reasoning? reports zero-shot Urdu GSM8k accuracy of 12.28% for CODI against 6.84% for chain-of-thought fine-tuning. That is the best transfer evidence in the file. There is no reported result found on Lacuna for interaction-structure extraction from text, so no existing number can serve as a target. Beating CODI means matching or exceeding its target-language edge F1 while also producing spans that a human can check.
The ablation that isolates our key ingredient is three models with identical backbone, data, steps, and GRPO budget. The first is trained on labels only. The second is trained on labels plus free-text English rationales written by annotators. The third is trained on labels plus span-grounded typed rationales. If the third does not beat the second on the average over held-out languages, the core hypothesis fails.
Finally, translate-test runs the English-trained model on machine-translated input and maps cited spans back by word alignment.
Why not just…?
Why not just prompt a strong LLM to output the graph directly? This is a real threat. On a structured task with explicit cues, a capable model may already do well. The evidence against relying on it is indirect: label-only prompting lags in ExpeTrans (49.1% against 63.8%) and in DynaGuard's comparison with LlamaGuard3. Our experiment settles the question directly. If direct prompting comes within a few F1 points of our method in the target languages, the contribution shrinks to the benchmark and the downstream elicitation results. We would then report that, and redirect the method toward the low-resource languages where the gap remains.
Why not just translate everything into English? In XNLI, translate-test is competitive for most languages. Its weakness for our task is specific: translation can merge or reorder the hedges and conditionals ("only if", "either") that signal interactions. It also breaks the link between an explanation and the user's original words. We measure both effects, edge F1 and span-recovery rate, on the native-written sets. Zero-shot Reading Comprehension by Cross-lingual Transfer Learning found translation pipelines underperforming internal multilingual representations, but that was a different task. We treat translate-test as a serious baseline, not a strawman.
Why not just assume additivity and spend more queries? Under additive noise, Round-Robin has tight envy guarantees, according to Fair Division Under Inaccurate Preferences. Those guarantees say nothing when the true utility has complements, because no number of additive queries can represent "the lab is worthless without the lecture." The downstream experiment measures what this costs: regret and zero-utility allocations under the true utilities when additive models are used.
Why not just use continuous latent reasoning and give up inspectability? If CODI wins on transfer by a wide margin, it should be preferred for raw accuracy. But the whole point of a predicted graph is that a person or an elicitation system can check and correct individual edges, and a latent vector offers nothing to correct. We therefore also measure how often a human reviewer fixes a wrong edge in one pass when given our cited spans, compared with no spans.
Proposed Experiments
The first experiment is extraction. We report edge-detection F1 and edge-type accuracy per language. We also report the transfer gap: English score minus target-language score, separately for native and translated test sets.
The second experiment is downstream use. For each extracted graph we count the elicitation queries needed to reach a fixed fraction of the oracle's utility. We report expected-value-of-information computation time alongside, which Braziunas and Boutilier report at about one second per query on the car-rental domain. On the course domain, we measure Nash welfare and the number of students who receive zero value under the true non-additive utilities. Allocations there are made with Yankee Swap and Round-Robin applied to the elicited utilities.
The third experiment is a faithfulness check. We edit or delete the cited span in the input and test whether the predicted edge flips. A model whose explanations are faithful should flip far more often than one that cites spans as after-the-fact decoration.
The decisive result needs two things together. On the average over Urdu, Swahili, and Hindi, the span-grounded model must beat the free-rationale ablation and match or exceed CODI. Its graphs must also close most of the query-count gap between the additive bracket and the oracle. If span-grounding fails to beat free rationales, the claimed resolution of the interpretability-versus-transfer tension is wrong. If extraction is accurate but elicitation costs barely change, the graph is not the bottleneck worth attacking.
References
- Preference Elicitation and Generalized Additive Utility
- The Use of a Domain Model in Understanding Informal Process Descriptions
- \RESTAURANT Revisited or "Lunch with BORIS"
- Language-Informed Synthesis of Rational Agent Models for Grounded Theory-of-Mind Reasoning On-The-Fly
- ExpeTrans: LLMs Are Experiential Transfer Learners
- DynaGuard: A Dynamic Guardian Model With User-Defined Policies
- GRACE: Generative Representation Learning via Contrastive Policy Optimization
- Is continuous CoT better suited for multilingual reasoning?
- Crosslingual Generalization through Multitask Finetuning
- XNLI: Evaluating Cross-lingual Sentence Representations
- MLQA: Evaluating Cross-lingual Extractive Question Answering
- Deploying Fair and Efficient Course Allocation Mechanisms
- Learning Unanimously Acceptable Lotteries via Queries
- Zero-shot Reading Comprehension by Cross-lingual Transfer Learning with Multi-lingual Language Representation Model
- Fair Division Under Inaccurate Preferences