Iterative Resolution of Prompt Ambiguities Using a Progressive Cutting-Search Approach

Fabrizio Marozzo

REVIEW 4 major objections 5 minor 24 references

Iterative Resolution of Prompt Ambiguities Using a Progressive Cutting-Search Approach

T0 review · 4 major / 5 minor · reviewed 2026-08-16 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read Clarifying questions beat one-shot prompts on ambiguous AI tasks.

desk verdict A modest interactive-clarification study whose headline accuracy claim outruns its own metrics—worth a referee, but the evaluation needs to catch up first. read the letter →

arxiv 2505.02952 v2 pith:GJN5RTO6 submitted 2025-05-05 cs.AI cs.CLcs.ETcs.IRcs.LG

Fabrizio Marozzo This is my paper · ORCID

classification cs.AIcs.CLcs.ETcs.IRcs.LG

keywords promptambiguityresolutioniterativepromptingprogressivecutting-searchclarificationdialogueengineeringgenerativeAIusersatisfaction

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Natural-language requests to generative AI are routinely ambiguous, and the common fix is to test the output, discover it is wrong, and rewrite the prompt. This paper proposes replacing that trial-and-error loop with a structured clarification dialogue: the system detects candidate ambiguities, asks the user to choose among alternative interpretations (often with input/output examples), and only after all ambiguities are resolved generates the final code or text. Evaluated on 75 prompts across coding, data analysis, and creative writing, the approach reports higher output accuracy, roughly half the user interactions in coding and data analysis, and higher satisfaction ratings than a standard one-shot workflow. The paper's contention is that the protocol, not the underlying model, creates the improvement, which means the method could be wrapped around existing chatbots without retraining. If the claim holds, guided clarification would be a practical, low-cost upgrade to how people prompt generative AI.

What carries the argument

The machinery is the 'progressive cutting-search approach': a decision-tree dialogue in which each clarification question with its answer options is a branch, and each user response eliminates every interpretation not consistent with the chosen option. A chatbot (GPT-4o via API) carries out the natural-language steps: detecting candidate ambiguities, wording questions, generating I/O examples, and writing the final solution. The protocol adds dynamic pruning, meaning ambiguities resolved implicitly by earlier answers are removed from the queue, so the dialogue ends when the interpretation space has been narrowed to one. The final validation step, showing edge-case examples, lets the user confirm the solution before accepting it.

What would settle it

Run the same 75 prompts under three conditions with the system prompt and dialogue policy fully disclosed: the proposed cutting-search dialogue, a free-form clarification chat from the same model, and one-shot prompting. If free-form clarification matches or beats the proposed protocol in accuracy and time, the specific progressive cutting-search structure is not the operative ingredient; if the one-shot arm matches the guided arms, the whole premise fails.

Watch

Extended reading notes

Core claim

The central claim is that poor outputs from generative AI are mostly caused by unresolved ambiguity in the user's prompt, and that a progressive cutting-search dialogue can remove that ambiguity before generation. The system analyzes the prompt, lists each detected ambiguity, and for each one asks the user to choose among alternative readings, often showing input/output examples; every choice cuts invalid interpretations, and resolving one ambiguity can automatically eliminate others. Only when no ambiguity remains does it generate the final solution, then validate it with representative examples and edge cases. The experiments use ten human evaluators on 75 expert-annotated prompts and report ambiguity-detection F1 of 0.85 for coding, 0.82 for data analysis, and 0.69 for creative writing; roughly half the interaction count of the one-shot baseline in coding and data analysis; and satisfaction ratings between 4.1 and 4.8 on a five-point scale.

Load-bearing premise

The whole comparison assumes that the chatbot, prompted with an undisclosed system prompt and dialogue policy, detects the same ambiguities a human expert would and asks non-leading questions; if the model's question quality is doing the work, the progressive cutting-search protocol is not what the experiments demonstrate.

Editorial extensions

If this is right

If the reported gains hold, users of coding and data-analysis assistants could reach correct outputs in roughly half the interactions, shifting effort from debugging generated code to answering a few clarifying questions.
The clarified prompt plus its chosen options becomes a precise, repeatable specification, so the same final output can be regenerated deterministically from the resolved intent.
The method inherits its ceiling from ambiguity detection: with F1 at 0.69 for creative writing, free-text prompts will still need better detection before the dialogue can resolve what it does not see.
Because the protocol sits on top of any chatbot API, it could be deployed as a wrapper around existing models without retraining or changing model weights.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

The paper does not isolate the protocol from the model's question-writing skill; a fair test would compare its dialogue with free-form clarifying questions from the same model to see whether the cutting-search structure itself adds accuracy.
The decision-tree framing suggests a measurable quantity the paper does not compute: the expected number of questions needed per prompt, which could be minimized like any tree-building cost and compared across question orderings.
The interaction logs produced by such a system are a natural training resource: they show what disambiguated versions of common ambiguous prompts look like, so a future model could learn to ask or preempt the same questions in one shot.
The time comparison depends on where the one-shot user stops; with less experienced users the gap might widen, and with experts who disambiguate instinctively it might shrink, so the headline savings are likely population-dependent.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Here's my honest read. The core idea—interactively clarify ambiguous prompts before generating a final answer—is not new. He et al. (2025) and Yadav et al. (2021), both cited, already cover clarification dialogues for ambiguous prompts. What the paper adds is a specific decision-tree style 'progressive cutting-search' protocol and a small evaluation across coding, data analysis, and creative writing. That's a real, if modest, contribution, and it ships a dataset on GitHub, which deserves credit.

What it does well: the three-phase pipeline is clearly explained, the case studies are concrete and easy to follow, and the ambiguity-detection F1 scores are an honest attempt to measure one part of the pipeline. I appreciate that creative writing comes out lower (F1 0.69) than coding (0.85); that matches prior experience.

The soft spots are mostly evidentiary. The abstract and conclusion repeatedly claim 'superior accuracy' for final outputs, but none of the reported metrics compare the correctness of final generated solutions between the iterative and one-shot arms. F1 only measures ambiguity detection, not whether the final code or text is better. The time results (Table 2) have no defined correctness criterion—'until the correct output is achieved' is never operationalized—and are averages from n=30 with no standard deviations or significance tests. The one-shot baseline is under-specified, and the GPT-4o system prompts are undisclosed, so you can't tell if the benefit comes from the framework or from a well-engineered prompt. These are fixable gaps, not internal contradictions. The paper is not circular; there are no fitted parameters.

Overall, this is a modest, honest paper that needs revision before its headline claim can stand. I would send it to peer review, because the dataset and protocol have value to the community, but I'd expect substantial changes: measure final-output accuracy against a defined rubric, release prompts and evaluation scripts, report variance, and either add significance testing or soften the accuracy claim.

For your reading group: maybe. It's a quick read and a useful example of how evaluation design can lag the claim.

Referee Report

4 major / 5 minor

Summary. The paper proposes an iterative prompt-disambiguation workflow for generative AI systems. Starting from an ambiguous natural-language prompt, the system first detects ambiguities, then runs a structured clarification dialogue with alternative interpretations and input/output examples, and finally generates a solution with representative examples and edge cases. The approach is instantiated with GPT-4o via API and evaluated on 75 prompts across coding, data analysis, and creative writing. The reported results include precision/recall/F1 for ambiguity identification against expert annotations, a comparison of interaction counts and completion times against a conventional one-shot approach, and user satisfaction ratings. The authors claim superior accuracy, competitive resolution times, and higher user satisfaction relative to conventional one-shot solutions.

Significance. If substantiated, the claimed result would be practically useful: a structured clarification protocol that reduces user effort and yields more accurate final outputs than unguided iterative prompting would be a directly deployable contribution to prompt engineering and interactive LLM systems. The paper also ships a public dataset of ambiguous prompts with expert-annotated ambiguities, which is a valuable resource. However, the current evidence does not establish the headline accuracy claim, because the experiments measure ambiguity-detection F1, interaction counts, completion time, and subjective satisfaction, not the correctness of the final generated outputs. The satisfaction claim also lacks a one-shot comparator. The manuscript is therefore a useful case-study description with a promising evaluation design, but it needs additional validation before its central claims can be accepted.

major comments (4)

[Abstract and §4.2] The central claim that the iterative method yields 'superior accuracy' of final outputs is not tested. Section 4.2.1 reports ambiguity-identification precision/recall/F1 against expert annotations, which is a property of the detection phase, not of the final generated solution. Section 4.2.2 measures interaction counts and time until a 'correct output' is achieved, but the correctness criterion is never defined operationally and no results show how many final outputs were judged correct under each condition. The paper needs an explicit correctness measure for final outputs (e.g., expert ratings or executable test cases) and a direct comparison between the iterative arm and the one-shot arm on that measure. Without this, a reader cannot distinguish 'more accurate outputs' from 'more satisfying conversations'.
[§4.2.3] The user-satisfaction results do not support the abstract's claim of 'higher user satisfaction compared to conventional one-shot solutions.' Table 3 reports ratings for the iterative process only, and all five questions ask about the iterative process rather than comparing it with the one-shot condition. There is no one-shot satisfaction baseline. To support the comparison, the evaluators would need to rate both workflows on comparable scales, ideally blind to condition and in randomized order.
[§4.2.2] The time-efficiency comparison is not sufficiently rigorous to support the quantitative claims. The table reports point averages from ten selected tests per use case with no standard deviations, confidence intervals, or significance tests. The one-shot baseline is described only as users 'manually revise and resubmit' until correct, with no protocol specifying how many attempts are allowed, who judges correctness, or how the stopping condition is determined. The paper should specify the baseline protocol, report variability and sample sizes, and state how inter-evaluator agreement on 'correct' outputs was assessed.
[§3 and §4.2] The implementation details needed to attribute the observed behavior to the proposed method are missing. Section 3 states that the system uses 'a chatbot such as GPT-4o via API' and a 'progressive cutting-search strategy', but the actual prompts, question templates, dialogue policy, model parameters, and stopping rules are never disclosed. It is therefore unclear whether the improvement comes from the proposed framework or from the particular clarification questions the model happens to generate. The authors should release the full system prompts and dialogue templates used in both arms, or otherwise perform an ablation that isolates the framework's contribution.

minor comments (5)

[Title and running header] The paper uses inconsistent terminology: the title and Section 3 describe a 'progressive cutting-search approach', while the running header on even pages reads 'Resolution of Prompt Ambiguities Using a Pruning Approach'. Choose one term and use it consistently.
[§2, reference [12]] Reference [12], cited for the claim that ambiguous requirements require iterative refinement, appears to describe error-correcting codes rather than prompt refinement or AI-assisted programming. Please verify the citation or replace it with a more relevant source.
[Figure 1] Figure 1 is difficult to interpret as rendered; the placeholder boxes marked '[?]' and the repeated 'x' in the caption are unclear. A cleaner diagram with labeled arrows would help readers follow the three phases.
[§4.2.1] The paper reports F1 scores but does not state whether these are macro- or micro-averaged across prompts, nor does it report per-prompt variance. This information is needed to judge the stability of the detection results across the 25 prompts per domain.
[§4.2] The dataset description says each evaluator was assigned ten queries, which implies 100 assignments across ten evaluators, but the dataset has 75 prompts. The assignment procedure (e.g., overlapping assignments, replacement, or unequal evaluator loads) should be stated explicitly.

Circularity Check

0 steps flagged · score 0.0 of 10

No circular dependency: the evaluation uses external expert annotations and measured interaction counts; the unsupported accuracy claim is an evidence gap, not a circular reduction.

full rationale

The paper does not contain a derivation chain whose conclusions are equivalent to its inputs by construction. The core method is an interactive prompting procedure: GPT-4o detects ambiguities, asks clarifying questions, and generates a final solution. No parameter is fitted to the outcome being predicted, and no result is imported from prior work by the same author. The ambiguity-identification evaluation compares the system's detected ambiguities against expert-annotated reference ambiguities, which is an external ground truth rather than an output derived from the method's own definitions. The time and interaction comparisons are empirical measurements, and the satisfaction ratings are collected questionnaire data. The abstract's claim of 'superior accuracy' of final outputs is not directly supported by the reported metrics, since the experiments measure ambiguity-detection F1, interaction counts, time, and subjective satisfaction rather than a head-to-head accuracy comparison of final generated solutions. That is a serious evaluation-validity concern, but it is not circularity: no step reduces to a fitted input, a self-citation chain, or a definitional equivalence. The paper is therefore self-contained with respect to circularity, and the correct finding is no significant circularity.

Assumptions & free parameters 0 free parameters · 4 assumptions · 0 invented entities

No mathematical parameters are fitted; the method is a prompting protocol. The axioms are the unverified assumptions about the model's behavior, the quality of the expert annotations, the fairness of the baseline comparison, and the representativeness of the user study. No new physical or conceptual entities are introduced.

assumptions (4)

domain assumption GPT-4o via API can reliably detect ambiguities and generate appropriate clarification questions without a disclosed system prompt
Section 3 states the system 'leverages advanced NLP techniques, including a chatbot such as GPT-4o' and Section 4.2 uses GPT-4o for both methods. No system prompt, temperature, or validation of question quality beyond F1 on the self-constructed dataset is provided.
domain assumption The expert-annotated ambiguities in the 75-prompt dataset are complete and correct ground truth
Section 4.2.1 uses these annotations as the reference for precision and recall. No inter-annotator agreement is reported, so the reference set is assumed to be uncontroversial.
domain assumption The one-shot baseline's interaction counts and times are measured fairly and comparably
Section 4.2.2 describes the standard approach as requiring manual revisions, but the protocol for counting interactions, deciding when an output is 'correct,' and allocating evaluator effort across the two arms is not specified.
domain assumption User satisfaction ratings from 10 expert evaluators generalize to broader users
Section 4.2.3 reports mean ratings from questionnaires without confidence intervals, selection criteria, or any check for evaluator bias, so the ratings are assumed to be representative.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Iterative Resolution of Prompt Ambiguities Using a Progressive Cutting-Search Approach." pith.science (2026). https://pith.science/paper/GJN5RTO6

@misc{pith2026250502952,
  author       = {Pith},
  title        = {Pith review of: Iterative Resolution of Prompt Ambiguities Using a Progressive Cutting-Search Approach},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/GJN5RTO6}},
  note         = {Machine review of arXiv:2505.02952}
}

read the original abstract

Generative AI systems have revolutionized human interaction by enabling natural language-based coding and problem solving. However, the inherent ambiguity of natural language often leads to imprecise instructions, forcing users to iteratively test, correct, and resubmit their prompts. We propose an iterative approach that systematically narrows down these ambiguities through a structured series of clarification questions and alternative solution proposals, illustrated with input/output examples as well. Once every uncertainty is resolved, a final, precise solution is generated. Evaluated on a diverse dataset spanning coding, data analysis, and creative writing, our method demonstrates superior accuracy, competitive resolution times, and higher user satisfaction compared to conventional one-shot solutions, which typically require multiple manual iterations to achieve a correct output.

Figures

Figures reproduced from arXiv: 2505.02952 by the authors.

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

24 extracted references · 14 canonical work pages

[1]

The Language Model Understood the Prompt was Ambiguous: Probing Syntactic Uncertainty Through Generation

Aina, L., Linzen, T.: The language model understood the prompt was ambiguous: Probing syntactic uncertainty through generation. arXiv:2109.07848 (2021)

work page Pith review arXiv 2021
[2]

Journal of Elec- trical Systems and Information Technology 11(1), 22 (2024)

Akhtar, Z.B.: Unveiling the evolution of generative ai (gai): a comprehensive and investigative analysis toward llm models (2021–2024) and beyond. Journal of Elec- trical Systems and Information Technology 11(1), 22 (2024)

work page 2024
[3]

arXiv:2108.07258 (2021)

Bommasani, R., Hudson, D.A., Adeli, E., Altman, R., Arora, S., von Arx, S., Bernstein, M., Bohg, J., Boutellier, R., Chang, K., et al.: On the opportunities and risks of foundation models. arXiv:2108.07258 (2021)

arXiv 2021
[4]

In: Advances in Neural Information Pro- cessing Systems (2020)

Brown, T.B., Mann, B., Ryder, N., Subbiah, M., Kaplan, J., Dhariwal, P., et al.: Language models are few-shot learners. In: Advances in Neural Information Pro- cessing Systems (2020)

work page 2020
[5]

arXiv:2107.03374 (2021)

Chen, M., Tworek, J., Jun, H., Yuan, Q., Pinto, H.P.d.O., Kaplan, J., et al.: Eval- uating large language models trained on code. arXiv:2107.03374 (2021)

arXiv 2021
[6]

Proceedings of the Asia-Pacific Software Engineering Conference (2023)

Choi, H., Park, H., Choi, Y.J., Han, K.: Consistency of code: A prompt based approach to comprehend functionality. Proceedings of the Asia-Pacific Software Engineering Conference (2023)

work page 2023
[7]

In: Proc

Chowdhery, A., Narang, S., inston, J., et al.: Palm: Scaling language modeling with pathways. In: Proc. of the Int. Conf. on Machine Learning (2022)

work page 2022
[8]

In: Proc

Devlin, J., Chang, M.W., Lee, K., Toutanova, K.: Bert: Pre-training of deep bidirec- tional transformers for language understanding. In: Proc. of NAACL-HLT (2019)

work page 2019

Show all 24 references

[9]

Ekin, S.: Prompt engineering for chatgpt: A quick guide to techniques, tips, and best practices (2023) 14 F. Marozzo

2023
[10]

In: Proceed- ings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)

Fan, A., Lewis, M., Dauphin, Y.: Hierarchical neural story generation. In: Proceed- ings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). pp. 889–898 (2018)

2018
[11]

arXiv:2501.15167 (2025)

He, Y., Wang, J., Li, K., Wang, Y., Sun, L., Yin, J., Zhang, M., Wang, X.: En- hancing intent understanding for ambiguous prompts through human-machine co- adaptation. arXiv:2501.15167 (2025)

2025
[12]

IEEE Transactions on Communications68(1), 26–39 (2019)

Huang, L., Zhang, H., Li, R., Ge, Y., Wang, J.: Ai coding: Learning to construct error correction codes. IEEE Transactions on Communications68(1), 26–39 (2019)

2019
[13]

arXiv preprint arXiv:2001.08361 (2020)

Kaplan, J., McCandlish, S., Henighan, T., Brown, T.B., Chess, B., Child, R., Gray, S., Radford, A., Wu, J., Amodei, D.: Scaling laws for neural language models. arXiv preprint arXiv:2001.08361 (2020)

2020 arXiv
[14]

IEEE Access (2024)

Li, Y., Shi, J., Zhang, Z.: An approach for rapid source code development based on chatgpt and prompt engineering. IEEE Access (2024)

2024
[15]

Advances in Neural Information Processing Systems 36 (2024)

Liu, J., Xia, C.S., Wang, Y., Zhang, L.: Is your code generated by chatgpt really correct? rigorous evaluation of large language models for code generation. Advances in Neural Information Processing Systems 36 (2024)

2024
[16]

arXiv:2310.18648 (2023)

Nguyen-Duc, A., Cabrero-Daniel, B., Przybylek, A., Arora, C., Khanna, D., Herda, T., Rafiq, U., Melegati, J., Guerra, E., Kemell, K.K., et al.: Generative artificial intelligence for software engineering–a research agenda. arXiv:2310.18648 (2023)

2023 arXiv
[17]

In: 2024 5th International Conference on Communications, Information, Electronic and Energy Systems (CIEES)

Nikolaeva, D., Petrova, D.: A survey of the programming paradigms used in pro- gramming languages. In: 2024 5th International Conference on Communications, Information, Electronic and Energy Systems (CIEES). pp. 1–5. IEEE (2024)

2024
[18]

arXiv:2203.02155 (2022)

Ouyang, L., Wu, J., Jiang, X., Almeida, D., Wainwright, C., Mishkin, P., et al.: Training language models to follow instructions with human feedback. arXiv:2203.02155 (2022)

2022 arXiv
[19]

Radford, A., Narasimhan, K., Salimans, T., Sutskever, I.: Language models are unsupervised multitask learners, openAI Blog, 2019

2019
[20]

In: Proceedings of the 36th International Conference on Machine Learning (2019), arXiv:1910.10683

Raffel, C., Shazeer, N., Roberts, A., Lee, K., Narang, S., Matena, M., Zhou, Y., Li, W., Liu, P.J.: Exploring the limits of transfer learning with a unified text-to- text transformer. In: Proceedings of the 36th International Conference on Machine Learning (2019), arXiv:1910.10683

2019 arXiv
[21]

arXiv:2407.09025 (2024)

Tian, Y., Zhao, J., Dong, H., Xiong, J., Xia, S., Zhou, M., Lin, Y., Cambronero, J., He, Y., Han, S., et al.: Spreadsheetllm: Encoding spreadsheets for large language models. arXiv:2407.09025 (2024)

2024 arXiv
[22]

IEEE Transactions on Software Engineering (11) (2023)

Wang, C., Yang, Y., Gao, C., Peng, Y., Zhang, H., Lyu, M.R.: Prompt tuning in code intelligence: An experimental evaluation. IEEE Transactions on Software Engineering (11) (2023)

2023
[23]

arXiv preprint arXiv:2305.13246 (2023)

Wang, Z., Zhang, G., Yang, K., Shi, N., Zhou, W., Hao, S., Xiong, G., Li, Y., Sim, M.Y., Chen, X., et al.: Interactive natural language processing. arXiv preprint arXiv:2305.13246 (2023)

2023 arXiv
[24]

AI Open 2, 85–92 (2021)

Yadav, A., Patel, A., Shah, M.: A comprehensive review on resolving ambiguities in natural language processing. AI Open 2, 85–92 (2021)

2021

Pith tools

Reviewed August 16, 2026 · model on record in the stance chip above.

[1] [1]

The Language Model Understood the Prompt was Ambiguous: Probing Syntactic Uncertainty Through Generation

Aina, L., Linzen, T.: The language model understood the prompt was ambiguous: Probing syntactic uncertainty through generation. arXiv:2109.07848 (2021)

work page Pith review arXiv 2021

[2] [2]

Journal of Elec- trical Systems and Information Technology 11(1), 22 (2024)

Akhtar, Z.B.: Unveiling the evolution of generative ai (gai): a comprehensive and investigative analysis toward llm models (2021–2024) and beyond. Journal of Elec- trical Systems and Information Technology 11(1), 22 (2024)

work page 2024

[3] [3]

arXiv:2108.07258 (2021)

Bommasani, R., Hudson, D.A., Adeli, E., Altman, R., Arora, S., von Arx, S., Bernstein, M., Bohg, J., Boutellier, R., Chang, K., et al.: On the opportunities and risks of foundation models. arXiv:2108.07258 (2021)

arXiv 2021

[4] [4]

In: Advances in Neural Information Pro- cessing Systems (2020)

Brown, T.B., Mann, B., Ryder, N., Subbiah, M., Kaplan, J., Dhariwal, P., et al.: Language models are few-shot learners. In: Advances in Neural Information Pro- cessing Systems (2020)

work page 2020

[5] [5]

arXiv:2107.03374 (2021)

Chen, M., Tworek, J., Jun, H., Yuan, Q., Pinto, H.P.d.O., Kaplan, J., et al.: Eval- uating large language models trained on code. arXiv:2107.03374 (2021)

arXiv 2021

[6] [6]

Proceedings of the Asia-Pacific Software Engineering Conference (2023)

Choi, H., Park, H., Choi, Y.J., Han, K.: Consistency of code: A prompt based approach to comprehend functionality. Proceedings of the Asia-Pacific Software Engineering Conference (2023)

work page 2023

[7] [7]

In: Proc

Chowdhery, A., Narang, S., inston, J., et al.: Palm: Scaling language modeling with pathways. In: Proc. of the Int. Conf. on Machine Learning (2022)

work page 2022

[8] [8]

In: Proc

Devlin, J., Chang, M.W., Lee, K., Toutanova, K.: Bert: Pre-training of deep bidirec- tional transformers for language understanding. In: Proc. of NAACL-HLT (2019)

work page 2019