Towards Verifiable Text Generation with Symbolic References

Authors: lucas  torroba hennigen
shannon  zejiang shen
aniruddha  nrusimha
bernhard  gapp
david  sontag
yoon  kim
Venue: colmweb_org_COLM_2024_Conference
Published: 2024-03-21 21:33:36

Abstract: LLMs are vulnerable to hallucinations, and thus their outputs generally require laborious human verification for high-stakes applications. To this end, we propose symbolically grounded generation (SymGen) as a simple approach for enabling easier manual validation of an LLM’s output. SymGen prompts an LLM to interleave its regular output text with explicit symbolic references to fields present in some conditioning data (e.g., a table in JSON format). The references can be used to display the provenance of different spans of text in the generation, reducing the effort required for manual verification. Across a range of data-to-text and question-answering exper- iments, we find that LLMs are able to directly output text that makes use of accurate symbolic references while maintaining fluency and factuality. In a human study we further find that such annotations can streamline human verification of machine-generated text.

Main paper: 
 introduction: 
 Many applications of generative AI involve generating text based on structured data (e.g, tabular data, surveys, API outputs, etc.) that is known (or assumed) to be trustworthy. For example, newspapers may be interested in generating summaries of sports games based on official match statistics, and search providers would want generative search engines to ground its output in search results. These applications require conditional text generation that is fluent, accurate, and verifiable with respect to the conditioning information. Large language models (LLMs) have advanced to the point where they can sometimes be relied upon to generate fluent-and faithful-enough summaries of text and other structured data. However they remain far from perfect (Liu et al., 2023; Yue et al., 2023) , and insofar as high-stakes applications will almost certainly require a human to manually verify that an LLM's generation is accurate with respect to its conditioning information, there is a need to develop frameworks that maintain the fluent and accurate few-shot generation capabilities of LLMs while enabling streamlined human verification of the model's output. This paper proposes symbolically grounded generation (SymGen) as a step towards verifiable text generation with LLMs. Given a string representation of data in a structured but human-readable format (e.g., JSON, YAML, etc.), we prompt the LLM to generate the output with explicit symbolic references into the provided data structure instead of generating the text directly. The references are then rendered using a parser, which can faithfully represent values from the original data, and can moreover be used to include visual cues that enable a user to readily verify the provenance of a particular span of text (see Fig. 2 for an overview). In contrast to classic templated approaches for text generation (Kukich, 1983; McKeown, 1992; McRoy et al., 2000) , SymGen instead offloads the template specification process to an LLM. We exploit the fact that LLMs have likely been sufficiently exposed to such kind of templated text during pretraining that they are able perform zero-and fewshot text generation with symbolic references across multiple domains.To demonstrate its effectiveness, we evaluate SymGen on its ability to retain the same textual quality as regular generation while improving the ability of users to verify the final LLM response. Specifically, we study SymGen's performance along four axes and across five datasets: textual quality ( §3), citation accuracy ( §4.1), helpfulness of SymGen citations ( §4.2), and effectiveness in downstream extensions of SymGen to question-answering and mathematical reasoning ( §5). Overall, our experiments on zero-and few-shot data-to-text generation and question answering indicate that LLMs can be prompted to generate fluent text that is interleaved with symbolic references which explicitly refer to data fields. Further, we find that the annotations enabled by SymGen simplify the process of post-hoc verification, both as perceived by the user and by reducing the average verification time by 20%. Compare a standard LLMgenerated (A) with a SymGen (B, ours) description of a basketball game, based on match statistics. SymGen imbues spans of generated text (highlighted in blue) with symbolic references to the source data, enabling easier verification: e.g., when hovering over a span, the number "30" displays a tooltip and link (highlighted in yellow) indicating the value it is referencing. 
text generation with symbolic references: 
 Task formulation. Let V be some vocabulary, and let F be a set of fields in a data structure. One special case of conditional generation consists of taking as input some structured data encoded as field-value tuples d = {( f i , v i )} n i=1 with field f i ∈ F , value v i ∈ V * , and some instruction x ∈ V * , and then producing an appropriate response y = [w 1 , . . . , w n ] ∈ V * . One simple technique for this task is to encode the field-value tuples as regular text (e.g., as a JSON dictionary as in Fig. 2 (1)) and provide it to an LLM alongside an instruction (e.g., "Summarize a basketball match given its statistics in JSON.").In this paper, we propose a simple symbolically grounded generation (SymGen) approach for such tasks. The idea is to first generate a response in symbolic form ỹ ∈ (V ∪ F ) * , which interleaves regular text and references to fields from the data. For example, in Fig. 2 , the response in (2) would be: ỹ = [The, visitor.city, . . . , ).].We can subsequently render ỹ by substituting each field f j ∈ F with its corresponding value v j ∈ V * in the data to obtain the final response. For example, in Fig. 2 the symbolic form ( 2) is rendered into y = [The, Portland, . . . , ).], which is shown in (3). Importantly, the inclusion of symbolic references enables fine-grained attribution of portions of the text to their generating fields in the data. In this sense, SymGen is similar in spirit to citation-enabled LLMs (Liu et al., 2023; Yue et al., 2023; Gao et al., 2023) , except that our approach focuses on providing very precise and easy-to-validate citations. We stress that our aim with SymGen is not to improve the overall quality of the rendered response, but instead to ensure its textual quality is maintained ( §3) while improving the ability of end-users to verify its correctness ( §4).Operationalization. While there are many ways of operationalizing the approach above, in practice we have found that prompted LLMs are highly effective at this task. In general, our strategy consists of prompting the LLM to generate its responses in a hybrid form, where fields in the JSON data (which is itself included at the beginning of the prompt) should be referenced using a Jinja-like syntax, i.e., the LLM should generate {{ field }} Figure 2 : Overview of the proposed symbolically grounded generation (SymGen) pipeline, on an example generated by GPT-4. Given the structured data input (1), we use a prompted LLM to generate a response (2) that contains symbolic references into the data (e.g., the variable visitor.city marked by A ). A parser then substitutes the symbolic references with their corresponding values in the structured data (e.g., Portland for visitor.city) to obtain the final rendered text (3). Our SymGen pipeline can implicitly leverage the input data to generate prose without any symbolic references (e.g., the span marked by B ). It can also transform existing variables (e.g., adding up two numbers, marked by C ) to create unavailable data in the source, while preserving references to the original variables.to refer to a specific field in the data as opposed to generating the field's value as it would do by default. We can then use an off-the-shelf Jinja parser1 to render the final text, with minor postprocessing (e.g., based on regular expressions) to make sure we preserve an alignment between rendered references and the field they refer to. Specifically, we consider two methods based of the above:1. Direct SymGen: As described above, we encode the structured data as a JSON dictionary, and then prompt the LLM to generate its output using Jinja-like syntax. 2. Indirect SymGen: We also explore a variant of the above, where we prompt an LLM to first generate the response directly without any symbolic references, and afterwards prompt it to convert this response into one with a Jinja-like syntax.Effectively, this consists of first tasking the LLM with building a plan, and then conditioning on this plan to obtain the symbolically grounded response.We detail the used prompts in App. I.2. The advantage of the indirect approach is that it should maintain the same text quality as regular (non-symbolic) generation as long as converting regular prose into symbolically-augmented text is no harder than generating the regular text in the first place; the caveat is that this approach can be more costly with APIs that charge on a per-token basis, as it requires roughly twice the amount of tokens to be generated. We also found this strategy to be unreliable with weaker LLMs such as GPT-3.5,2 so we only employ this with GPT-4. This is one of many possible of operationalizations of this method. In particular, we also explored alternatives to Jinja-like references (e.g., Python f-strings for the reference format), and alternatives to JSON (e.g., YAML). We found that the LLMs we tested were able to also work with these formats, which suggests that further gains may be possible by exploring other practical operationalizations SymGen.Evaluation. As mentioned earlier, the main aim of SymGen is to enhance verifiability of the final text without compromising the textual quality over the final generation. To determine whether this is the case, we study SymGen's performance along four axes. The first is whether the textual quality of the final, rendered text is comparable to the quality of the text generated by a standard, prompted LLM ( §3). Then we evaluate the citation accuracy, (Wiseman et al., 2017) .Table 1 : For SynthBio, we report BLEU (Papineni et al., 2002) and BERTScore F1 (BERT F1; Zhang et al., 2020) against the reference biographies. For Rotowire, we report the BLEU and ROUGE (ROU.-L; Lin, 2004) of the generated answers against the reference generations in the dataset. We also report the (general) error rate (ER) and the global error rate (GER).i.e., whether the symbolic references introduced by SymGen are not only correct but also non-trivial in the sense that they cannot be added post-hoc by a naïve baseline ( §4.1), and we further assess whether these links actually enable better verifiability in terms of speed and accuracy ( §4.2) via human evaluation. Finally, we explore some extensions of SymGen to question-answering and mathematical reasoning ( §5). Collectively across all studies, our analysis is conducted on five datasets, which are shown in Tab. 8 of App. I.1. Unless otherwise stated, in all cases we compare against a baseline that consists of prompting the LLM to generate the response directly, without any symbolic references. 
textual quality study: 
 The first empirical study in this work aims to understand whether SymGen generations exhibit the same quality as a (prompted) LLM baseline; our main goal is not to improve upon this baseline (although in some cases we observe improvements) as our overarching goal is to improve generation verifiability without sacrificing performance. For this set of experiments, we evaluate on two traditional data-to-text datasets ( §3.1), and on a new counterfactual obituary generation ( §3.2) dataset. For the former, our focus is in analyzing the fluency of the resulting text, whereas in the latter we focus on the factuality of the generated text. We consider both zero-and few-shot settings for each of those tasks.Depending on the nature of the task (e.g., complexity, size of the structured data, etc.), we evaluate our approach on a mix of GPT-3.5 (with 4K or 16K context windows) and GPT-4 (with 8K or 32K context windows). The full experimental setups, including the prompts, are given in App. I. Anecdotally, we found that extensive experiments with different prompts were not necessary to get LLMs to perform symbolic generation; we expect that further improvements are possible with more prompt engineering.SymGen is similar in spirit to data-to-text methods, where the goal is to generate some text based on structured data. Classical approaches to this problem consist of designing a template based on the schema of the data, and populating it with the values of a datapoint at runtime (Kukich, 1983; McKeown, 1992; McRoy et al., 2000) . However, relying solely on the schema of the data tends to yield formulaic text. Neural approaches to data-totext generation (Wiseman et al., 2017; 2018; Wang, 2019; Yin & Wan, 2022) Lin, 2004) of the inferred answers from the generated text against the true answer given by the source JSON. We also report the percentage of answers that the QA model did not find an answer for (the unknown rate; UR), and the regular (ER) and global (GER) error rates. Refer to §3.2 for a discussion.datasets. To this end, we revisit this setting in the context of zero-and few-shot data-to-text generation with LLMs.Datasets. We first consider SynthBio (Yuan et al., 2021) , a collection of synthetically constructed fictional entities, described in terms of a collection of key-value pairs, which has been used in prior work on templated generation with finetuned models (Zhang et al., 2022) . The task is to generate a textual description of the entity. We also consider the Rotowire (Wiseman et al., 2017) dataset, where the objective is to generate a summary of a basketball game given its box (individual player statistics) and line (aggregate team statistics) scores. The Rotowire dataset presents a challenging testbed for our approach, since its data structure is substantially more complex than the previous task (i.e., there are many more fields in each datapoint) and it relies on more specific in-domain knowledge (i.e., understanding how to read basketball box scores charts). To keep LLM API costs manageable, we sample 100 examples from the test set to evaluate on. Refer to App. I for more details.Experimental details. On SynthBio, we generate a short biography for each entity in the test set using GPT-3.5-4K and GPT-4-8K, and we evaluate against reference texts using BLEU (Papineni et al., 2002) and BERTScore F1 (Zhang et al., 2020) . We consider both zero-and 2-shot learning. See App. I.2.1 for the prompts and example generations. On Rotowire, we explore both GPT-3.5-16K and GPT-4-32K (the longer context windows are needed due to the length of the JSON), and evaluate against reference texts using using BLEU and ROUGE (Lin, 2004) . See App. I.2.2 for the Rotowire prompts and examples. We experimented with direct and in-direct strategies on both GPT-4-8K and GPT-3.5-4K models. We found that for many examples GPT-3.5-4K would ignore the instructions/incontext examples and directly output a response with symbolic references in the first step. Though the metrics were still reasonable (e.g., for SynthBio, BLEU was 32.67 for 0-shot and 33.10 for 2-shot), we omit these results since they do not reflect the correct strategy.Our results are shown in the respective tables for each dataset (SynthBio, Tab. 1a; Rotowire, Tab. 1b). The results for data-to-text generation are generally positive. For Syn-thBio, in the few-shot case, we find that both symbolic generation strategies we considered yield comparable or superior performance to the baseline, indicating that SymGen indeed does not degrade the textual quality of the final generation.3 Interestingly, in the zeroshot GPT-3.5-4K case, direct symbolic generation underperforms the baseline, though this gap is bridged via in-context learning. This could suggest that biographical generation in symbolic space is slightly harder than regular (non-symbolic) generation for GPT-3.5-4K. 4For Rotowire, we find that the quality of symbolic generation generally trails the baseline, though this difference is smaller when using GPT-4-32K and indirect generation. Interestingly, GPT-3.5-16K seems to outperform GPT-4-32K in this task, as evidenced by comparing the baseline results under each model, which suggests that better performance may be obtained by modifying the indirect strategy so that GPT-3.5-16K is used to generate summaries in regular prose and GPT-4-32K is used to rewrite them using symbolic references.In many cases, we find that poor symbolic generations arise from rendering errors. To this end, we also report the percentage of outputs whose symbolic form has at least one error (a specific reference in a response failed to render locally and was instead rendered as "undefined"; ER) and with at least one global error (where the Jinja parser simply failed to run, causing the whole response to fail and be replaced with "The text is not available."; GER). We find that (i) GPT-3.5 tends to commit more errors than GPT-4 and (ii) providing few-shot examples tends to reduce errors, both of which are expected, though we also find that the indirect SymGen strategy leads to more errors than the direct strategy. We believe this to be because adapting regular, non-symbolic text to have symbolic references can sometimes be hard if the JSON is incomplete or the original text is not written in a way that is amenable to the insertion of references.There is evidence that LLMs are capable of memorizing their training data (Carlini et al., 2019; 2023) and that this leads to their struggling to generate counterfactual data that goes against their learnt priors (Hernandez et al., 2023) . In this section, we explore whether SymGen retains the same performance as the baseline when some of the conditioning data is counterfactual in nature.Dataset. We collect a dataset comprised of 167 famous scientists who lived between 1800 CE and 2000 CE (e.g., Albert Einstein, Carl Sagan, Louis Pasteur, etc.) and further generate counterfactual variants of each entity. The counterfactual variant is designed to test for the extent to which an LLM may ignore data that contradicts the information an LLM has seen during training, which has been noted to be a common failure mode of smaller language models (Hernandez et al., 2023) . For more details refer to App. I.Experimental setup. We use GPT-3.5-4K to generate obituaries for each of these (possibly counterfactual) entities. For the few-shot experiments, we provide two examples (see App. I.2.3 for our prompts and some example generations). Unlike SynthBio, we have no reference biographies for these entities, so we devise a new evaluation procedure that tries to measure the factuality of the summaries. Specifically, we wrote questions for each property in the schema of the data, and then prompted GPT-3.5-4K to answer them using only the rendered text (see App. B for details). If the answer was not present in the text, we asked the model to answer with "Unknown." (the percentage of questions answered in this way is reported by the unknown rate; UR). We then computed both exact match accuracy and ROUGE of the provided responses against the response specified in the JSON; we include the latter as it is provides more leeway in the exact phrasing of the response than the exact match metric. Similar to §3.1, we do not report indirect SymGen results since it does not function properly using GPT-3.5-4K.Results. The counterfactual obituary results are shown in Tab. 2. We find that in the zero-shot case, SymGen slightly outperforms our baseline, whereas in the few-shot case we find that it slightly underperforms the baseline; regardless, these differences are small, which again indicates that SymGen likely does not cause any meaningful degradation in the textual quality of the final generation. However, when we condition on whether the model gave a response versus stating it did not know the answer (Tab. 6), we find that performance is further improved in the zero-shot case and comparable in the few-shot setting. One possible explanation for this is that symbolic generation includes slightly less information than regular generation (especially in the few-shot case, as seen by the higher unknown rate), which in turn leads to more incorrect answers, since more questions were left unanswered. That is, SymGen seems to favor precision at the expense of recall, which may be desirable in some applications.5 4 Verifiability Study 
assessing symbolic reference accuracy: 
 We first aim to determine whether the fields attributed to different spans of text are correct given their context. This is important since, in principle, symbolic references may be incorrect even when the final text is accurate; for example if two fields in our data have the same value, but a symbolic reference is made to the wrong field, then the rendered text would be correct but not the reference.Metric. For a given generation ỹ, we measure the accuracy of the generated symbolic references. The accuracy P is defined by comparing whether a generated field fj ∈ F is the same as the intended f j ∈ F given the context:1 m ∑ j 1[ fj = f j ],where m is the number of symbolic references in a given generation.Besides SymGen, we also use a simple regular expression-based baseline to generate symbolic references. In short, for each field f i in the data, we search for its corresponding value v i in the text and attribute any of its occurrences to f i .Evaluation. We sample 20 test examples from the Rotowire (Wiseman et al., 2017) dataset, which is a challenging testbed for this study due to the lengthy data associated with every generation. For each example, we compare the direct SymGen generation to the regex baseline, using either GPT-3.5-16K or GPT-4-32K as the base LLM. Three of the authors of this paper independently annotated the symbolic references in each example according to whether it was judged to be contextually correct or not, resulting in in 9068 annotations in total, with an inter-annotator agreement of 97.8%. Overall, we find that when the accuracy of SymGen is 99.77% and 99.52% with GPT-3.5-16K and GPT-4-32K as the base LLMs, respectively, whereas the one the baseline is 35.40% and 46.10%. This highlights that not only SymGen is extremely precise when generating symbolic references, but also that such accuracy cannot be obtained with simple, post-hoc methods.Having established that textual quality is mostly unaffected by SymGen ( §3) and that the symbolic references are correct and non-trivial ( §4.1), we now turn to whether our symbolically grounded generations actually aid in verifiability. To do so, we conduct a human study to ascertain whether the annotations enabled by SymGen actually aid users in verifying LLM generations. We once again focus on Rotowire since it is a challenging testbed for verification: summaries contain many numbers referring to a wide range of fields, and slight errors might be hard to spot.Annotation data. We picked five SymGen-generated (Indirect, GPT-4-32K) summaries of different games in the Rotowire dataset and manually verified them for correctness. We then generated three version of each document that were inconsistent with the data by picking a random symbolic reference and replacing it with another symbolic reference with a different value that was within 2 units of the original value of the field. We prevent the resulting value from being nonsensical, e.g., we restrict percentages to be within 0 and 100. For each of these four documents, we created two versions: a version with annotations, and one without any annotations (i.e., as if it were generated by a regular LLM).Published as a conference paper at COLM 2024 Table 3 : For financial QA, we report the acceptability of the answers in the zero-and 3-shot settings. Refer to App. C for details. For GSM8K, we compare SymGen reasoning with other reasoning methods on GSM8K and GSM-hard; all approaches were evaluated using GPT-4-8K. Refer to §5.2 for a discussion.Survey overview. We ask annotators to annotate four summaries: two of them contain SymGen annotations, allowing them to inspect the provenance of different numbers in the text when hovering over a number using their cursor, and two containing no annotations (i.e., the output of a regular LLM). Each summary is equally likely to come from a pool of correct or incorrect summaries, and the first step of each annotation is for the participant to determine whether the summary is correct (i.e., there are no inconsistencies between the summary and the source table) or incorrect (i.e., there is an inconsistency between the summary and the table). Crucially, this first step is timed. Answering this question reveals two more questions, asking the annotators to rate their confidence in their answer, and how easy it was for them to reach a decision, on a Likert scale. We ask these questions in order to measure whether SymGen annotations meaningfully impact (i) human accuracy at finding errors and (ii) how easy it is to verify a summary, where both objective ease (i.e., how long did it take to reach a decision) and subjective ease (i.e., how hard did it feel to go through and verify the text). At the end of the study, annotators are provided an exit survey were they are asked to rate whether they prefer annotations (over no annotations) with respect to both (i) the confidence in their decisions and (ii) their ease in reaching a decision. We also reward annotators for each question answered correctly to ensure that they are spending adequate effort on the task. More details on the study design, exact questions, and interface are given in App. F.Enrollment. We recruited 60 annotators for the study via Prolific. See App. F for more details, including selection criteria, quality filters, etc.Results. We find that annotators were equally likely to identify errors regardless of whether SymGen annotations were shown. However, when annotations were displayed, they took on average 20% less time to reach a decision about whether an error was present or not. This makes sense, since the annotations do not change whether the text is correct or not, they should only facilitate the process of verifying it. We further find that annotators feel 5% more confident of their final answers when using our approach and perceive the verification task to be 14% easier. Finally, from exit survey, we have that 71.67% of participants agree that annotations made them more confident in their answers, and 83.33% agree that annotations made the verification task easier. In all, the results suggest that SymGen annotations enable a faster and more pleasant verification experience, with some annotators reporting "The annotations help tremendously", "[t]he annotations were nice and definitely helped", and "[...] I could still compare the data without annotations it just took longer to find each piece of data". For more details, refer to Tab. 7 in App. H. 
extensions to other use-cases: 
 In the preceding sections, we established that the textual quality of SymGen is comparable to a regular prompted LLM ( §3), that its annotations are accurate and non-trivial ( §4.1) and that SymGen indeed aids in verifiability ( §4.2). Now, we turn to some extensions of SymGen to question-answering (QA) and mathematical reasoning use-cases.Another possible application of symbolically grounded generation is to enhance verifiability in QA over structured data. To evaluate this setting, we construct a dataset of 32 finance-related questions about particular companies (e.g., "How does the book value of NFLX compare to that of ASML?"), coupled with structured company information. The results in Tab. 3a suggest that with GPT-4, all models offer reasonably comparable text quality across generation strategies, though SymGen underperforms when using GPT-3.5. Refer to App. C for more details.Figure 3 : Illustration of SymGen reasoning on GSM8K, on an example generated by GPT-4. Given a math question (1), the LLM answers via direct symbolic generation, creating variables as needed (2), which can be rendered in a user-friendly manner (3). The syntax we use (Jinja) allows the creation of variables based on the source text (e.g., setting total_people to 90, A ), and performing computation by referencing existing variables (e.g., calculating total_groups based on total_people and group_size, B ). We can moreover explain how a computation step relates to previous ones ( C ).Besides providing symbolic references to fields in the source data, SymGen can also be used to express symbolic computations over the variables, e.g., computing the halftime points of a basketball game based on the first two quarter scores (Fig. 2 ). By chaining a series of such operations, it opens up the possibility of interleaving arithmetic operations within languagebased chain-of-thought reasoning. We explore whether this new capability comes without an overall textual quality penalty.Experimental setup. Fig. 3 illustrates one approach for performing reasoning via symbolic generation for a math problem in GSM8K (Cobbe et al., 2021) . Each generated computation step is coupled with an assignment statement in Jinja, which relates the natural language explanation of the computation with a symbolic expression. Compared to chain-of-thought reasoning (CoT; Wei et al., 2022) , explicit use of symbolic computations should lead to more easily verifiable computational results of each step; compared to programaided language models (PAL; Gao et al., 2022) and program of thoughts prompting (PoT; Chen et al., 2023) , which recasts problems into programs and executes it to obtain a response, SymGen relies more on natural language as a scaffold, embedding symbolic computation within regular text.Dataset. We compare the direct SymGen strategy against CoT and PAL on two datasets: GSM8K (Cobbe et al., 2021) and GSM-hard (Gao et al., 2022) . GSM8K are grade school math problems like the one illustrated in Fig. 3 that typically require multiple steps of reasoning to solve. To create a more challenging testbed for LLMs, Gao et al. (2022) construct GSM-hard by replacing, for each problem in GSM8K, a randomly selected number with a large random number of up to seven digits. We use a random subset of 200 problems in the test set of GSM8K and GSM-hard for evaluation, as recent work find that it yields similar results to testing on the full 1.3K test set (Wang et al., 2023b) .Results. Tab. 3b compares the performance on GSM8K and GSM-hard using CoT, PAL, and our approach with GPT-3.5-4K and GPT-4-8K. Notably, it seems symbolic reasoning might not be necessary for GSM8K, since both our method and PAL perform similarly to CoT. However, when the computations are more complex as in GSM-hard, symbolic generation outperforms CoT by a clear margin when using both GPT-4-8K and GPT-3.5-4K.Our method slightly underperforms PAL on GPT-4-8K, with the margin being larger using GPT-3.5-4K. This is somewhat expected, given that PAL is explicitly geared towards solving such arithmetic problems and moreover makes use of richer programming elements.Inspecting our method's failures on this dataset, we found that many errors arose from sensible (but incorrect) attempts to reason symbolically about a math problem using Jinja notation. See App. G for an error analysis. 
related work: 
 Data-to-text generation. Classic approaches for the data-to-text problem used handcrafted templates to generate output sentences that interleave text with placeholder tokens which refer to relevant data fields (Kukich, 1983; McKeown, 1992; McRoy et al., 2000) .Carefully engineered templates can provide strict guarantees against hallucinations, but require much manual work to specify, are domain-specific, and may sound robotic.Data-driven methods for data-to-text initially focused on inducing templates from data Tool-augmented LLMs. Recent work has augmented LLMs with tools/APIs to enhance their capabilities (Schick et al., 2023; Paranjape et al., 2023; Liang et al., 2023; Shen et al., 2023; Khot et al., 2023; Qin et al., 2023; Lu et al., 2023) . These methods enable LLMs to generate string representations of API calls whose results are fed back in as additional context. Our method can be viewed as using a templating language as a tool. Whereas this line of work is usually concerned with enhancing LLM capabilities via external modules, our work instead focuses on using structured data as "tools" to improve verifiability. Our use of arithmetic computations within generations is also closely related to works that generate code snippets along with text to combine the benefits of symbolic computations and language-based reasoning (Gao et al., 2022; Chen et al., 2023; Zhang et al., 2023) .LLM verification. LLM verification is an orthogonal improvement to the reliability of LLMs, where the output of an LLM is automatically verified. Yue et al. (2023) and Gao et al. (2023) take an LLM generated response and a reference document it cites and use a separate module to determine whether the output of the LLM is entailed from the reference document. Verify-and-edit Zhao et al. (2023) uses self-consistency checks to discover potential mistakes, and corrects those mistakes with knowledge retrieval. Poesia et al. (2023) allow an LLM to call a logical backend as a tool, so that it can perform logically sound and certifiable reasoning. To the best of our knowledge, our work is among the first to focus on how LLM generations can be made easier to verify by users in data-to-text settings. 
conclusion: 
 In this paper, we propose symbolically grounded generation (SymGen) as a simple approach to text generation that yields more verifiable text, by effectively linking portions of the output to the provided input data. Our evaluation suggests that symbolic generation increases verifiability without degrading quality. 
 
 Appendix: One limitation of SymGen is that it cannot completely ensure the avoidance of hallucinations. Although it is capable of generating accurate symbolic references, the surrounding context text may still be incorrect, thus leading to verifiable but incorrect generations. Our current studies primarily focuses on close-sourced models; one future work is to extend our method to open-sourced models and even finetune models for templated generation, using the dataset generated by SymGen (to the best of our knowledge, currently there are not available training data for this task).Properties and questions. Tab. 4 lists the Wikidata properties we include in our entities alongside the questions we corresponding question we provide the LLM in the QA evaluation. Another possible application of symbolically grounded generation is to enhance verifiability in question-answering (QA) over structured data. This is especially motivated by recent work on tool-augmented LLMs (Schick et al., 2023; Karpas et al., 2022) , which are able to condition their generation on the results of API calls, which are often given in a structured format.Dataset. To evaluate this setting, we construct a dataset of 32 finance-related questions about particular companies (e.g., "How does the book value of NFLX compare to that of ASML?"), coupled with company information from the AlphaVantage company overview API endpoint.6 Details about the questions and postprocessing are shown in App. D.Experimental setup. We prompt the LLMs to answer finance-related questions given some company information. To evaluate the answers, we had one of the authors annotate each answer as acceptable or not; in general, an answer was deemed acceptable if the final answer was correct (see App. D for more details). We considered two LLMs: GPT-3.5-16K and GPT-4-32K, due to the length of the JSON data. Our prompts and some example outputs are given in App. I.3.1; we used three-shot prompting for the in-context learning setting.Results. For the financial dataset, we report the percentage of responses judged as acceptable under each approach in Tab. 3a. The results suggest that GPT-3.5-16K is unsuited for symbolic generation on this task, falling substantially short of the baseline. On the other hand, for GPT-4 all models offer reasonably comparable performance across generation strategies. See App. G for a qualitative analysis of some errors.We had a total of 32 questions in the financial QA evaluation; the questions are shown in Tab. 5. There are two types of question: pairwise-comparison questions (pair) and multiway-comparison questions (multi). For the pairwise comparison questions, we only include information from the two companies in question. For the multiway-comparison questions we show data from seven tickers: ORCL, ASML, TSLA, GOOG, CRM, AVGO, NFLX.The specific structured input provided is the result the company overview endpoint from the AlphaVantage API. 7 We applied some minor postprocessing to the API response to ensure that all fields that are numerical in nature (e.g., SharesOutstanding , MarketCapitalization) are actually numerical (i.e., integers or floats) in the JSON as opposed to strings. Note that all questions are answerable from the data provided data (e.g., there is a field MarketCapitalization in the structured data that allows the pair_market-cap questions to be answered).To evaluate the generations, we had one of the authors in the paper annotate each of the responses according to whether the answer was acceptable or not. We adopted a loose criteria for acceptability:1. If the question had an objective answer (e.g., the answer to "Which company has a largest market capitalization, GOOG os ASML?" is ultimately either GOOG or ASML) then the generation was acceptable as long as the final answer given by the question was acceptable. Note that if the reasoning given for the answer was incorrect but the final answer was correct, the answer was still treated as acceptable. This choice is deliberate, since in certain cases it can be hard to gauge whether Table 6 : GPT-3.5-4K results of the automated question-answering evaluation on the obituary dataset, when we condition of the model not having abstained from giving an answer, i.e., when the answer given by the model was not "Unknown." We report the conditioned exact match accuracy (C-EM (%)) and ROUGE (C-ROU.-1, C-ROU.-2, C-ROU.-L; Lin, 2004) of the inferred answers from the generated text against the corresponding true answers given by the source data. Refer to §3.2 for a discussion.the reasoning is correct despite the answer being correct. To reduce subjectivity as much as possible, we adopted the loosest possible interpretation of acceptability for questions with objective answers. 2. If the answer did not have an objective answer (e.g., there are multiple sensible answers to "How do ORCL and GOOG's EBIDTA multiples compare?"), then we deem an answer acceptable if the reasoning in the answer is sensible and correct. 3. If the model failed to generate an answer (e.g., rendering error, or did not answer the question) then the answer was not acceptable.In Tab. 6, we include the results on the obituary dataset when we condition on the QA model not having abstained from answering.We include further details on the human study below.The following are the different pages the annotators see:1. Instruction page: They first see a page that gives them an overview of the study and the interface, a description of the questions they will answer, the structure of the study (with the approximate times to complete each section, alongside information about compensation), and a section with further notes. We make it clear here that they are being timed, and that the first three annotations will be practice examples and the next four are the actual examples they need to annotate. For simplicity, we use System A to refer to generations without annotations, and System B to refer to the system with annotations. 2. Practice round 1: Gives an example of a document without annotations and without errors. Specifically, we say: "The following example, which could have been generated by system A, contains nothing that directly contradicts the table on the left (we have checked it ourselves by going through the different numbers mentioned in the text, but you will have to do it yourself for future examples). For this reason, you should say that the text is consistent with the source data below (this is an attention check). For these practice questions, it doesn't matter what you write down for confidence and ease, but after the practice rounds are finished, you should start answering those." 3. Practice round 2: Gives an example document without annotation but with an error. Specifically, we say: "The following is an example, that also could have been Quality checks. We request a participant return their submission if they get two of the practice rounds wrong. In our opinion, our instructions for those rounds are clear as to what they should do (i.e., they give the correct answer), so participants that are reading the instructions should get these correct. If they get only one wrong, we allow them to complete the study and compensate them as other participants, but do not use their results in our analysis.When the user passes the practice round, we show them four documents to annotate. Our sampling process obeys the following properties:1. Each of the underlying documents is unique (i.e., we pick 4 out of the 5 documents to show the annotator) 2. Exactly 2 of the documents are shown with annotations, and two are shown without annotations. These may appear in any order.3. Each document has a 50% chance of being consistent with the text. If a document is sampled to be inconsistent, then we sample one of the three possible incorrect variants to show, uniformly at random.For each document, the annotators are asked:1. Is the text consistent or inconsistent with the source data?• Possible answers: Consistent or Inconsistent • Note: Answering this question stops a timer that begins running when the page is loaded. This is the annotation time we report.2. How confident are you in your answer? [1 means least confidence (completely unsure), 5 means most confidence (absolutely certain)]• Possible answers: 1, 2, 3, 4, 5 3. How easy was it reach your decision? [1 is hardest, 5 is easiest]• Possible answers: 1, 2, 3, 4, 5 Table 7 : Results of the human study, comparing a system with SymGen annotations to one without. We report accuracy (Acc.), time taken to determine if an example is correct in minutes (Time), and perceived confidence (Conf.) and effort (Effort) on a Likert scale (i.e., 1-5). For Conf. and Effort, higher scores indicate more confidence and less effort respectively. See §4.2 for details. Error bars correspond to standard error on the mean.Unless otherwise specified, we run all experiments using the Azure API and use the model version 0613. We state the specific version of the model we use in the main text. We use the SacreBLEU, ROUGE and BERTScore implementations in Huggingface evaluate.8 Figure 5 : Annotation interface for a document, as it appears after answering all questions.The second and third questions only appear after the first one is answered, and the submit button is enabled only when everything has been answered. Licensing information. The following resources that were used in our paper are licensed as follows (all are in English):1. SynthBio: Apache 2.0 2. Rotowire: Unable to determine 3. GSM: MITTab. 8 shows the statistics of the datasets we consider. We provide some more details about each dataset and its processing below.Rotowire. We postprocess the JSON to convert it into a nested, key-value data structure that resembles the output of an API. We found this to be a necessary step, and found SymGen to not work well when most of the data is exposed as an array, likely because of implicit chain-of-thought-like behavior when the model specifies a key, e.g., {{ data. box_score.shabazz_napier.fgm }} should be easier for an LLM to reason about than {{ data.box_scores[1][5] }}.Counterfactual obituaries. To obtain the entities, we scraped Wikidata9 and collected all entities whose occupation is a subtype of scientist, additionally filtering for entities with 75 or more sitelinks to ensure relatively well-known scientists were selected. the counterfactual variants of each entity, we take each entity's attribute and progressively corrupt a subset of its properties,10 by sampling a different value from the empirical distribution of that property's values from the collected data. For each entity, we create copies that have 50% and 100% of the selected properties corrupted.We then constructed a dictionary for each entity containing a value for each one of 27 manually selected Wikidata properties, e.g., country of citizenship, place of birth, etc. (see App. B for a complete listing). If an entity did not possess such a property in its Wikidata page, we do not add it to the entity's dictionary; if the entity possessed multiple values associated with that property, we selected the first one that was returned by the Wikidata API. This results in one dictionary of property-value attributes for each scientist. To construct the counterfactual variants of each entity, we take each entity's dictionary and progressively corrupt a subset of its properties,11 by sampling a different value from the empirical distribution of that property's values from the collected data. For each entity, we create copies that have 50% and 100% of the selected properties corrupted. All of these are added back to obtain the final dataset.We provide the prompts we use in the sections below.System prompt: Your task is to write a biography about a person whose description is given in JSON. You must mention and be faithful about every property of the person in your biography.User: JSON:```json { " data ": { " name ": " Hanna Skold ", " gender ": " female " , " nationality ": " Swedish ", " birth_date " : " 14 November 1856 " , " birth_place ": " Gotlandso , Sweden ",Your job is to now rewrite the answer you provided above, but instead of responding directly with the text, you must generate Jinja-style expressions in the text with references to fields in the provided JSON, e.g., given JSON that says:```json { " data ": { " place_of_birth ": " Ohio " } } ``t hen instead of generating "... was born in Ohio" you should generate "... was born in {{ data.place_of_birth }}". Note that you can only reference fields that exist in the JSON. The user will be displayed a version of this message that has the references filled in, and you should ALWAYS try to use such references instead of copying the text directly when possible. Remember, you MUST make sure you ONLY use fields that exist in the JSON. You must NOT make up fields.The {{ data.visitor_line.city }} {{ data.visitor_line.name }} ({{ data.visitor_line.wins }}-{{ data.visitor_line.losses }}) took down the {{ data.home_line.city }} {{ data.home_line.name }} ({{ data.home_line.wins }}-{{ data.home_line.losses }}) {{ data.visitor_line.pts }}-{{ data.home_line.pts }} on Saturday night at the Amway Center in {{ data.home_line.city }}. The Heat were just too much for the Magic when all was said and done, as they made a nice run in the fourth to get a seven-point win. What makes the win even more impressive is that Miami did it without guard Dwyane Wade (hamstring). The Heat got plenty of production from some key players to help get the job done though. They were led in scoring by {{ data.box_score.chris_bosh.player_name }}, who put up {{ data.box_score.chris_bosh.pts }} points ({{ data.box_score.chris_bosh.fgm }}-{{ data.box_score.chris_bosh.fga }} FG, {{ data.box_score.chris_bosh.fg3m }}-{{ data.box_score.chris_bosh.fg3a }} 3Pt, {{ data.box_score.chris_bosh.ftm }}-{{ data.box_score.chris_bosh.fta }} FT) to go with {{ data.box_score.chris_bosh.reb }} rebounds. {{ data.box_score.mario_chalmers.player_name }} had a huge night also, scoring {{ data.box_score.mario_chalmers.pts }} points ({{ data.box_score. mario_chalmers.fgm }}-{{ data.box_score.mario_chalmers.fga }} FG, {{ data.box_score.mario_chalmers.fg3m }}-{{ data.box_score.mario_chalmers. fg3a }} 3Pt, {{ data.box_score.mario_chalmers.ftm }}-{{ data.box_score.mario_chalmers. fta }} FT) to go with {{ data.box_score.mario_chalmers.ast }} assists and {{ data.box_score.mario_chalmers.reb }} rebounds. Miami fans have to be happy to see rookie {{ data.box_score.shabazz_napier.player_name }} stepping up big, as he played extended minutes ({{ data.box_score.shabazz_napier.min }}), and scored {{ data.box_score.shabazz_napier.pts }} points ({{ data.box_score. shabazz_napier.fgm }}-{{ data.box_score.shabazz_napier.fga }} FG, {{ data.box_score.shabazz_napier.fg3m }}-{{ data.box_score.shabazz_napier. fg3a }} 3Pt, {{ data.box_score.shabazz_napier.ftm }}-{{ data.box_score.shabazz_napier. fta }} FT) to go with {{ data.box_score.shabazz_napier.reb }} rebounds, {{ data.box_score.shabazz_napier.stl }} steals and {{ data.box_score.shabazz_napier.ast }} assist. Miami has a quick turnaround, as they take on the Charlotte Hornets at home Sunday night. The Magic just couldn't get enough production to outscore the Heat on this night, as only three players hit double digits, with {{ data.box_score.nikola_vucevic.player_name }} having a monster night, scoring {{ data.box_score.nikola_vucevic.pts }} points ({{ data. Herbert Spencer, a distinguished pharmacist and author of "Social Statics," has passed away at the age of 83 in Vienna. Born in Derby, Spencer was the son of Lord Byron and a citizen of the United Kingdom of Great Britain and Ireland. Although his field of work was primarily in physics, he made significant contributions as a pharmacist and worked for The Economist. Spencer was a member of the Athenaeum Club and was known for his agnostic worldview. He was nominated for the Nobel Prize in Physiology or Medicine for his notable work. Spencer will be laid to rest at Highgate Cemetery. He was fluent in Swedish and will be remembered for his remarkable achievements in the field of pharmacy and his influential writings. QUESTION: Where was Herbert Spencer born?For example, https://jinja.palletsprojects.com/en/3.1.x/extensions/. Using a parser also allows us to gracefully handle syntax errors made by the LLM, e.g., in the event that a Jinja expression that cannot be rendered, one can resolve it to a default value, e.g., "undefined."Specifically, we found that GPT-3.5 would often behave as in the direct SymGen strategy, despite being prompted and given examples of the desired, indirect SymGen behavior; see §3.1.For comparison, TempLM (Zhang et al., 2022)-which finetunes a pretrained LLM on the full training set-attains40.30 BLEU and 54.30 in BERTScore, which are comparable to our GPT-4 results.4 For SynthBio, JSON values are not ideally formatted, meaning that LLMs will either output grammatically incorrect text or have to perform post-processing on-the-fly via more complex templates, which seems to increase the likelihood of errors. Refer to App. I.2.1 for an example of how more complex Jinja templates can mitigate this.Here we characterize the "precision" in a loose sense and leave the formal evaluation of precision/recall for future work.https://www.alphavantage.co/documentation/#company-overviewAn example is shown here: https://www.alphavantage.co/query?function=OVERVIEW&symbol= IBM&apikey=demo.https://github.com/huggingface/evaluatehttps://www.wikidata.org/wiki/Wikidata:Main_PageOther than name, age and gender.Other than name, age and gender. 


Decision: Overall:  This paper suggests an approach for data-to-text generation with symbolic references as an intermediate step that can be presented to humans to make it easier to verify the text. The approach is interesting and the paper is generally well-written with comprehensive experiments.  There was a common confusion amongst reviewers about some of the goals of this paper, especially regarding the comparison of quality in Section 3.  I think that this can mostly be fixed in revisions, but will require some significant rewriting.  I also would suggest that Section 4 should be expanded further since it seems like the main goal of this approach is to help humans with verification which is what’s investigated by the user study.

Strengths:
- Interesting prompting approach
- helping users verify information (annotators took less time, and felt more confident and easier to verify outputs)
- Adding the SymGen annotations doesn’t seem to degrade output quality by much and they show this on three datasets

Weaknesses:
- The goals and contributions of this paper seemed to have been a point of confusion for both XpW4 and oNbF, though they seemed more satisfied after reading the author responses. Authors clarified in the response that “developed SymGen to make it easier for users’ to verify an LLM’s generation and evaluate its performance via multiple human studies”.  Authors also did state this in the paper: that the “main goal is not to improve upon the baseline”.  But I think this needs to be emphasized more clearly in general. Since this is actually the main goal of the work, my suggestion to the authors is that they may want to condense section 3 and instead do more of a deep dive into section 4 with more analysis and visualizations about the human studies.  Note: this seems mostly a writing/clarity issue but may require bigger revisions.
- Some lingering questions about experimental setup, baselines, etc. (see Reviewer XpW4)  that need to be clarified within the paper.  ← Authors have offered to update many of these in their general comments at the top of the discussion section.
- Experimental results seem a bit mixed (brought up by XpW4) without clear conclusions. I think that this may be ok for the intended purpose of this paper, which as I understand it, is to show that these annotations help with verification without degrading the quality by much. But, again, the writing needs to be updated to make the goals of this exploration more clear.

[At least one review was discounted during the decision process due to quality]

Reviews: review: paper_summary: paper_summary: The authors propose SymGen which provides symbolic references to the input structure (JSON) along with the generation. Two variants are proposed, direct and indirect.  The direct approach prompts LLM to generate text along with Jinja-like references in one go. The in-direct approach first prompts LLM to generate a text summary, that is subsequently transformed into text with symbolic references by prompting.
The experiments:  
1. study changes in textual quality due to symbolic reference generation
2. show that the annotations cannot be simply replaced by regex-based replacement.
3. show the system improves the verifiability speed.
4. show that SymGen can also be applied to QA on structured (JSON) data and reasoning setup.
strength_weakness: strength_weakness: In general, there is no clear recommendation by the authors. I see many mixed results, which is fine, but the paper does not map it to clear insights or error analysis. 

Table 1 (a) and (b) have mixed results depending on the dataset. The paper claims:
1. That rotowire is a difficult dataset and requires a lot of exact numbers replicated. However, the baseline results do not support this. 
2. SynthBio has a simpler JSON compared to Rotowire, but the authors suggest that biographical generation in symbolic space is slightly harder. It would be very helpful to have some error analysis to gain an understanding of inherent difficulty.

The authors claim that the indirect strategy does not work for GPT3.5 as it is weaker than GPT-4. Due to a lack of examples/comments, it is difficult to say why is that the case. It could be helpful if there were different and possibly open-source models used as well to be able to helpfully distill when this method works. Although I do acknowledge the GPU requirements issue here.

There are no details on how the parsing and representation would work for representation other than JSON. Hence, it seems that the proposed method is limited to JSONs. Furthermore, there is a limited description of the parsing stage itself apart from seemingly simple regex + replacement.

It is not obvious from the writeup why the authors chose not to use the in-direct method for the experiments in Table 2.

For the QA experiments, the gap between GPT-3.5 baseline vs direct methods is huge compared to GPT4, and experiments in Table 1. My assumption is that it could be due to shorter outputs. But the error rate is missing in this experiment which makes the results unclear.

In the related work section authors talk about LLM-based verification methods, without justifying the differences or why comparisons cannot be made. On a related note, and agreeing with the associated post-processing cost of prompting, regex-based baseline is not a fair comparison. A prompt-based baseline would be more adequate. An approach could be (only to cite possibilities): for each summary sentence, prompt which key-value pairs support the sentence? Or a prompt: where all sentences are passed as a list at once to make it comparable to indirect generation.
questions: questions: In section 3.1 : Why does it say "incomplete JSONS"?
paper_summary: paper_summary: The paper presents a novel approach, symbolically grounded generation (SymGen), which enhances the capabilities of large language models (LLMs) for complex reasoning tasks. The authors demonstrate that SymGen can produce text with accurate symbolic references while maintaining fluency and factuality, which is a significant advancement in the field of natural language processing.

Please note that I doubt whether the font used in this paper aligns with the Call for Papers (CFP) guidelines for COLM.
strength_weakness: strength_weakness: 1. Limited Dataset Scope and Insignificant Superiority: The evaluation is based on a small number of toy datasets, which may not fully capture the diversity of real-world applications. I expect to see the performance of the method on some more realistic and complex datasets, e.g., table reasoning, where the method may be superior.

2. Complexity of Indirect SymGen: The indirect SymGen approach, while maintaining text quality, could be more costly and less reliable with certain LLMs, which might be a concern for practical adoption.

3. Error Analysis: The paper could benefit from a more detailed error analysis, particularly in understanding the types and causes of errors in symbolic generation.

4. Generalizability: It is unclear how well the proposed method would generalize to other types of structured data (e.g., Graph, Table, Databases, etc.) and language models, which is a key consideration for its broader acceptance.

5. More than Verifiability: The authors emphasize the proposed method's verifiability. But what are the benefits? I am curious about future work. Does better verifiability make it easier for the LLMs to receive human feedback and evolve? Do the authors have more in-depth insights?

6. No Training: The paper does not attempt to train LLMs to master the technique of generating symbolic references, which limits its impact.
questions: questions: Please see Reasons to Reject
paper_summary: paper_summary: The authors propose a new prompting technique to generate textual descriptions
grounded in structured data, e.g., a news blurb describing financial data or
sports statistics. The key innovation appears to be the use of Jinja-like syntax
to inline symbol references in the generated text. The authors evaluate this
approach on several data sources: biographies from WikiData, sports data from
Rotowire and financial data from a financial API, where they observe that their
proposed approach generates descriptions that are comparably fluent and grounded
to a baseline approach. The key benefit however are the references which can be
used to show readers links to the source data: through a user study, the authors
demonstrate that these links allow readers to verify the data presented in the
text more quickly and easily.

Finally, the authors show two other ways in which the symbolic references could be useful:
first to help language models override their priors with counterfactual data,
and second as a way to help language models use symbolic expressions for math problems.
Unfortunately, in both of these applications, the results are mixed and are not
consistently better than the baselines.
strength_weakness: strength_weakness: There are several dimensions along which this paper makes contributions, but
unfortunately, I found it hard to find one in which it excels:

- Application: The chief contribution of this paper appears to be generating
  symbolic references along with text to help show those references to users.
  While valuable, the application has been proposed several times in the
  literature, and this paper limits its scope to referencing (near-)exact
  matches from the source data. I think this too narrow, given the state of
  language models today (e.g., the GPT3.5/4 models used in this paper).

- Technique: While the paper provides a clever way to prompt language
  models to generate text with grounded symbolic references, this technique isn't
  particularly effective at improving the groundedness of the generations over
  baselines (which are already very good). Furthermore, given the relatively
  small evaluation set sizes, it is unclear if any gains are statistically
  significant or not. 

- Data: the paper does generate its own synthetic counterfactual obituaries
  dataset, but the authors do not really analyze this dataset or make it public.
questions: questions: - In the discussion of the counterfactual evaluation, you mention that some of
  the difference in performance might be explained as a precision-recall trade
  off. This seems easily quantifiable, have you measured precision/recall of the
  generated answers?
- It is great that you included dataset sizes in the appendix, but I think this
  information belongs in the main paper. It is really hard to understand what's
  a meaningful improvement without that information. Given the relatively small
  sizes of the evaluation datasets, could you do a statistical analysis and
  report which results are actually statistically significant?

Comments: title: Thank you for your comment and clarifications
Overall comment and planned paper updates
Thank you for your response
Thank you for the response
comment: Thank you for your response! 

Firstly in case you haven’t seen the overall review response message (we weren't able to include the following in the response to your review due to character limit, but included it in the response for reviewer oNbF):  

---
We would like to thank reviewers for their effort and constructive feedback! We are encouraged that XpW4 and oNbF acknowledge our contribution and find our experiments comprehensive and convincing.

Given this paper is in the **LMs and interactions track**, we aim to tackle the pressing problem of human verification of LLM generations. We developed **SymGen to make it easier for users’ to verify an LLM’s generation** and evaluate its performance via multiple human studies. To thoroughly understand how SymGen works on different tasks, we also experiment to ensure **SymGen’s generation quality is on par with the baseline** on multiple tasks, and we do not intend to claim that SymGen can improve generations (e.g., better reasoning or grounded generation).

---

Thank you for the detailed questions clarifying the results and model choices. We will implement the following changes to clarify these details in our paper: 
- Describe the parsing pipeline in depth and mention the opportunities for using other formats (e.g., yaml). 
- Clarify why we use specific strategy is adopted in experiments in table 1 and 2, and additional description and examples for the Rotowire and Synthbio dataset. 
- Clarify the point "In the related work section authors talk about LLM-based verification methods, without justifying the differences or why comparisons cannot be made.": While data-to-text generation is well-established, to the best of our knowledge we are the first to focus on how the generation can be made easier to verify by users.

The proposed changes are mostly clarifying experimental details–which can be easily incorporated in this version without major alterations to the text. Most importantly, we don't see this as changing the main claim of our paper: that SymGen can make generations easily verifiable by humans. For this reason, we kindly ask you to reconsider increasing your score and please let us know if you find additional changes are necessary. Thanks!
We would like to thank all reviewers for their time, effort, and constructive feedback! We are encouraged that both reviewer XpW4 and oNbF acknowledge the contribution of our system for providing references in generation and reducing the effort for verification, find our experiments comprehensive and results convincing, and recognize the value and benefits of our methods to the community. 

Most of the reviewers' concern centered around whether SymGen can lead to better text quality: we’ve addressed the concerns in the comments for each reviewer individually. But we want to flag that our work centers on the topic of **LMs and interactions**, and our paper is scoped to tackle the pressing problem of human verification of LLM generations, and both reviewers XpW4 and oNbF appreciate the method we propose and the multiple experiments we conduct to validate the method. 

We will update our paper following their suggestions. Here is the list of the planned updates based on reviewer feedback: 
- Highlight our paper’s key contribution for reducing users’ effort for verifying the outputs. (XpW4, oNbF) 
- Describe the parsing pipeline in depth and mention the opportunities for using other formats (e.g., yaml). (XpW4) 
- Clarify why we use specific strategy is adopted in experiments in table 1 and 2, and additional description and examples for the Rotowire and Synthbio dataset. (XpW4)
- Update the discussion on “precision/recall of generated answers in counterfactual eval“ (oNbF)
- Report statistic significance for table 7  (https://imgur.com/a/5IWhJbn, oNbF)
- Update the related work section to reflect that our work is among the first to focus on how LLM generations can be made easier to verify by users in data-to-text generation settings. (XpW4, oNbF) 

We find the suggested changes for the camera-ready version are not substantial (mostly clarifications), and we can incorporate the changes in the final draft within this review cycle.
Thanks for your detailed response and for clarifying that the scope of the contributions. My concerns mostly related to whether the methods proposed here could improve the factuality of responses, which might be less relevant for the LM and interactions track. I find the prompting method to be quite novel and the user study convincing. I have increased my score to marginally above the acceptance threshold.
Thank you for the response and clarifications. Given the author's reply, it appears that not all concerns about the write-up can be resolved without altering the text significantly; therefore, I will be keeping the scores unchanged.