Pith. sign in

REVIEW 4 major objections 5 minor 26 references

Towards Automatic Evaluation of Task-Oriented Dialogue Flows

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

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

Pith's one-line read Automatic evaluation of task-oriented dialogue flows is possible through a fuzzy edit distance between conversations and flow paths, yielding a Flow-F1 score that balances corpus coverage against graph complexity.

desk verdict A useful metric idea for evaluating dialogue flows, but the complexity claim is unsound and the validation is in-sample. read the letter →

arxiv 2411.10416 v1 pith:JJGDTC6B submitted 2024-11-15 cs.CL cs.AI

Mehrnoosh Mirtaheri , Nikhil Varghese , Chandra Khatri , Amol Kelkar This is my paper · ORCID
classification cs.CLcs.AI
keywords dialogueflowevaluationtask-orientedfuzzyeditdistancegraphsentenceembeddingsdiscoveryinformationlossFlow-F1
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

This paper claims that dialogue flows—the directed graphs of user intents and agent actions that task-oriented chatbots follow—can be scored automatically against the conversation corpus they are meant to serve. It introduces FuDGE, a fuzzy edit distance that aligns a single conversation to the closest path in a flow, using Sentence-BERT embeddings to decide when an utterance can substitute for an intent. The paper argues that FuDGE separates conversations belonging to the flow's task from out-of-task conversations, and that combining FuDGE with graph complexity into Flow-F1 (FF1) captures the trade-off between flow compression and information coverage. If true, this gives conversational designers and flow-discovery algorithms a way to rank, tune, and prune flows without manual inspection.

What carries the argument

The load-bearing object is FuDGE, a dynamic-programming fuzzy edit distance between one dialogue and one dialogue-flow path. Its substitution cost is $c_{sub}(B_r,u)=\alpha(d_1(B_r,u)+d_2(B_r,B^*))$, where $d_1$ is the cosine distance in Sentence-BERT embedding space between utterance $u$ and intent bucket $B_r$ (either to the bucket centroid or to its nearest utterance), $B^*$ is the intent closest to $u$, $d_2$ is the intent-intent cosine distance, and a mismatch in actor (user versus agent) makes the cost infinite. To evaluate a whole flow, FuDGE takes the minimum distance over all root-to-leaf paths, and the efficient variant reuses memoized edit-distance arrays along shared DAG prefixes during a depth-first traversal.

What would settle it

Construct a pair of intents with nearly identical Sentence-BERT embeddings but opposite task roles, then compare FuDGE scores for a within-task conversation and an out-of-task conversation whose vocabulary is close to those intents; if the out-of-task conversation scores lower, the substitution cost has failed to capture functional mismatch. The same check can be run quantitatively by swapping the encoder and verifying whether the within-task versus out-of-task separation reported in the paper remains stable.

Watch

Extended reading notes

Core claim

The paper establishes that the quality of a dialogue flow can be quantified by the average, over all conversations, of the minimum fuzzy edit distance between each conversation and any root-to-leaf path in the flow, combined with a normalized measure of graph size. FuDGE generalizes Levenshtein distance to the setting where one sequence is a list of utterances and the other is a list of intent nodes, with substitution costs derived from cosine distances in Sentence-BERT embedding space. FF1 is the harmonic mean of normalized complexity and normalized FuDGE, and the experiments on Finance and STAR data show that within-task conversations receive significantly lower FuDGE scores than out-of-task conversations, while FF1 peaks at an intermediate number of kept paths. This supports the paper's central claim that automatic flow evaluation, comparison, and hyperparameter selection are feasible without human gold-standard flows.

Load-bearing premise

Everything in FuDGE rests on the assumption that cosine distance in Sentence-BERT embedding space between an utterance and an intent bucket measures whether that utterance can functionally play the intent's role in the flow; if that substitutability assumption fails, the FuDGE distances and FF1 rankings do not measure true flow-conversation mismatch.

Editorial extensions

If this is right

  • FuDGE can be used on its own to score individual conversations against any DAG-shaped dialogue scheme, including as a distance signal in zero-shot dialogue generation from predefined flows.
  • FF1 condenses flow quality into a single number, enabling automatic ranking, pruning, and comparison of flows generated from the same corpus.
  • FF1 offers a principled hyperparameter-selection procedure for flow-discovery algorithms, choosing the path count where added complexity no longer reduces average FuDGE distance.
  • Supervised and unsupervised flows can be compared on equal footing, and the experiments show that coarser unsupervised intents can yield higher FF1 than overly fine-grained human labels.
  • The framework supplies a consistent baseline for tracking and versioning dialogue flows over time as corpora and discovery methods evolve.

Reading between the lines

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

  • A natural extension, not pursued in the paper, is making the flow-discovery objective directly optimize FF1 instead of using FF1 only to rank already-built flows.
  • Because the substitution cost depends entirely on embedding similarity, swapping in a task-specific or fine-tuned encoder is a direct test of whether the metric's ceiling is set by the embeddings or by the edit-distance machinery.
  • The same FuDGE distance could be applied to any DAG-structured sequence model, such as word confusion networks or API workflows, wherever a graph represents alternative execution paths.
  • For conversations that touch multiple flow paths, FuDGE's min-over-paths choice may hide coverage breadth; a coverage-weighted variant could expose flows that fit every conversation only by overfitting with many paths.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 5 minor

Summary. The paper proposes FuDGE (Fuzzy Dialogue-Graph Edit Distance), an edit-distance-style metric that aligns a conversation with paths in a dialogue-flow DAG, using Sentence-BERT cosine distances to define substitution costs between utterances and intent buckets. It also defines FF1 (Flow-F1), the harmonic mean of normalized complexity and normalized FuDGE distance, intended to capture the trade-off between flow compression and representational coverage. The authors report three experiments: (i) FuDGE separates within-task from out-of-task conversations for three tasks (Table 1b), (ii) FF1 selects a hyperparameter k for a flow-discovery algorithm (Figure 3), and (iii) FF1 ranks supervised versus unsupervised flows (Table 2). The paper claims an O((|V|+|E|)n) implementation via DAG-aware memoization.

Significance. If the metric works as claimed, it would fill a real gap: automatic, corpus-relative evaluation of dialogue flow quality for flow discovery and design. The problem is well motivated, the metric is clearly specified and interpretable, and FF1 encodes a sensible compression-versus-coverage trade-off. The authors also release the STAR-based data and discovered flows, and the appendix includes worked alignment examples, both of which aid reproducibility. However, the current evidence for the metric's validity is thin and partly confounded, and the complexity claim is unsupported; these issues need to be resolved before the central contributions can be accepted.

major comments (4)
  1. [Complexity Analysis & Efficient Implementation (Algorithm 2)] The claimed O((|V|+|E|)n) complexity is not established and appears to be false. The memoization structure node2dist stores a separate distance array for every distinct path that reaches a node; since a DAG can have exponentially many root-to-node paths, the number of stored arrays can be exponential in |V|. The total work is therefore O(Kn), where K is the number of flow paths—the same order as the naive algorithm when K is the number of paths. Please provide a correct worst-case bound or qualify the claim; as written, the 'efficient implementation' contribution is not supported.
  2. [FuDGE Evaluation (Table 1b)] The within-task versus out-of-task separation experiment is confounded: the flows for each task were generated from the full task corpus, and the 'positive' conversations are a random 50% of that same corpus. Low FuDGE scores for the positives may therefore reflect that the flows were fit to those very conversations, and the result does not demonstrate separation for unseen in-task conversations. Please evaluate on a held-out split (e.g., generate flows on one half and test on the other) and include a non-fuzzy baseline (such as average SBERT similarity to flow nodes or an exact-intent edit distance) to show that FuDGE adds value beyond simple embedding overlap.
  3. [Fuzzy Substitution Cost (Eq. 8-12)] The central assumption—that cosine distance in Sentence-BERT embedding space is a valid proxy for whether an utterance can play the role of an intent in a dialogue flow—is never tested. There is no calibration against human substitutability judgments, no comparison with alternative substitution costs, and no analysis of failure cases. Since every FuDGE and FF1 number inherits this assumption, the paper should provide evidence for it or explicitly frame all results as conditional on this assumption.
  4. [FF1 Evaluation and Parameter Optimization (Figure 3, Table 2)] The experiments do not validate FF1 against an external gold standard. The harmonic mean in Eq. (5) will always exhibit a peak as k increases, so observing a peak near the point where the FuDGE curve flattens does not by itself show that the selected flow is better by any independent criterion. Similarly, Table 2's supervised-versus-unsupervised comparisons are interpreted post hoc after manual inspection in the Appendix. Please add a downstream evaluation (e.g., task success rate) or human judgment, or clearly label the FF1 results as a qualitative demonstration of the trade-off.
minor comments (5)
  1. [Algorithm 2] The pseudocode uses the index `i` in `d[i+1]` and `d[i]` without defining `i` in the loop over utterances, and the initial distance row is initialized to `[1,...,n+1]` rather than the standard `[0,...,n]`, so the recurrence appears off by one.
  2. [Table 1b] The column header 'Positves' should be 'Positives'.
  3. [Datasets and Flow Discovery Methods] The paper relies on two proprietary, unpublished flow discovery algorithms (ALG1 and ALG2) without describing their hyperparameters or providing code; since the main experiments are built on them, this makes the empirical results difficult to reproduce.
  4. [Table 4] The caption says 'Tasks in each datasets with the number of conversation within each task,' but the table actually shows unsupervised/supervised intents and example utterances; the caption should be corrected.
  5. [Complexity Analysis] The cost of computing the intent centroids and all pairwise intent-intent distances is not accounted for in the complexity analysis; a sentence clarifying that these are offline or one-time costs would help.

Circularity Check

1 steps flagged · score 6.0 of 10

FuDGE's within/out-of-task separation experiment uses in-task conversations from the same corpus that generated the flows, so the reported separation is partly a training-fit artifact rather than an independent validation.

  1. fitted input called prediction [Experiments, 'FuDGE Evaluation' section, Table 1b]
    "We generated separate dialogue flows for each of these tasks using ALG1 and ALG2. For each task, we also randomly sampled 50% of the in-task conversations and added the same number of out-of-task conversations. We evaluated each task-flow with the corresponding dialogue corpus and obtained the average FuDGE score for each dialogue corpus."

    The flows are generated from the full task corpus (e.g., all 150 Make Payment conversations), and the positive evaluation conversations are a 50% random sample of that same task corpus. No held-out split is described. FuDGE then measures edit distance between a conversation and a flow whose paths were constructed from those very conversations; consequently, low FuDGE scores for the positives reflect how well the flow discovery algorithm fit its training input, not an independent demonstration that FuDGE captures flow-conversation alignment for unseen conversations. The claimed within-task versus out-of-task separation in Table 1b is therefore substantially forced by the construction of the experiment.

full rationale

The paper's core metric, FuDGE, is defined as a fuzzy edit distance between a conversation and the paths of a flow graph, with substitution costs based on Sentence-BERT embedding distances. That definition is not itself circular: it is a construct with stated assumptions, and the substitution-cost ansatz, while unvalidated, is an external modeling choice rather than a self-referential loop. The FF1 score is an explicit harmonic mean of normalized complexity and normalized average FuDGE; using it to rank flows is a defined objective, not a circular derivation. The main circular step is in the empirical validation of the paper's second contribution, the claim that FuDGE can effectively separate within-task from out-of-task conversations. In the FuDGE Evaluation experiment, the flows are generated from the same task corpus from which the positive evaluation conversations are sampled. The low FuDGE scores for positives are therefore expected as a consequence of the flow discovery algorithm having been fitted to those very conversations, not as an independent prediction. The paper does not compare against a baseline or a held-out split, so the separation shown in Table 1b is partially by construction. The asserted O((|V|+|E|)n) complexity bound is likely unsound because a node may hold multiple distance arrays, but that is a correctness issue, not circularity. Overall, the central measurement framework has independent content, but its headline validation experiment reduces in part to a training-fit effect, warranting a score of 6.

Assumptions & free parameters 3 free parameters · 4 assumptions · 2 invented entities

The central claim rests on the equation of semantic similarity with embedding cosine distance, on the edit-distance formulation for alignment, on the FF1 aggregation design, and on the DAG representation of flows. The paper introduces two new quantities (FuDGE and FF1) but provides only internal validation for them.

free parameters (3)
  • alpha (substitution cost coefficient) = 0.5
    Equation 8 defines the substitution cost as alpha*(d1+d2); alpha is set to 0.5 to keep costs in [0,1], but no sensitivity analysis is provided.
  • Insertion/deletion cost = 1 (implicit)
    Algorithm 2 uses unit costs for inserting an utterance and deleting an intent; the paper does not explore alternatives.
  • Distance variant (Min vs Centroid) = two variants
    The appendix defines Min and Centroid variants for intent-utterance distance; results are reported for both, but no principled selection is given.
assumptions (4)
  • domain assumption Cosine distance in Sentence-BERT embedding space reflects semantic substitutability between an utterance and an intent bucket
    Used throughout the fuzzy substitution cost (Equations 8-12); if embedding proximity does not track functional equivalence in a dialogue flow, FuDGE distances are not meaningful.
  • domain assumption Edit distance with unit insertion/deletion and fuzzy substitution is an appropriate measure of flow-conversation alignment
    The paper adopts Levenshtein-style alignment for the flow-path matching problem (Section 'Fuzzy Dialogue-Graph Edit Distance').
  • ad hoc to paper The harmonic mean of normalized complexity and normalized loss is a valid objective for flow quality
    FF1 in Equation 5 is introduced without derivation; it is a design choice that rewards both coverage and compression.
  • domain assumption The dialogue flow is a DAG with a root node and intent buckets
    This representation is assumed in the problem definition (Section 'Problem Definition').
invented entities (2)
  • FuDGE (Fuzzy Dialogue-Graph Edit Distance)
    purpose: Quantify distance between a single conversation and a dialogue flow path
    Introduced as a new metric; effectiveness is shown only through the paper's own separation experiments, with no external gold standard or independent benchmark.
  • FF1 (Flow-F1 score)
    purpose: Combine flow complexity and FuDGE coverage into a single quality score
    Introduced to balance complexity and information loss; its claim to identify optimal flows is only demonstrated on one task (Make Payment) and not compared with human judgment or downstream performance.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Towards Automatic Evaluation of Task-Oriented Dialogue Flows." pith.science (2026). https://pith.science/paper/JJGDTC6B

@misc{pith2026241110416,
  author       = {Pith},
  title        = {Pith review of: Towards Automatic Evaluation of Task-Oriented Dialogue Flows},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/JJGDTC6B}},
  note         = {Machine review of arXiv:2411.10416}
}
read the original abstract

Task-oriented dialogue systems rely on predefined conversation schemes (dialogue flows) often represented as directed acyclic graphs. These flows can be manually designed or automatically generated from previously recorded conversations. Due to variations in domain expertise or reliance on different sets of prior conversations, these dialogue flows can manifest in significantly different graph structures. Despite their importance, there is no standard method for evaluating the quality of dialogue flows. We introduce FuDGE (Fuzzy Dialogue-Graph Edit Distance), a novel metric that evaluates dialogue flows by assessing their structural complexity and representational coverage of the conversation data. FuDGE measures how well individual conversations align with a flow and, consequently, how well a set of conversations is represented by the flow overall. Through extensive experiments on manually configured flows and flows generated by automated techniques, we demonstrate the effectiveness of FuDGE and its evaluation framework. By standardizing and optimizing dialogue flows, FuDGE enables conversational designers and automated techniques to achieve higher levels of efficiency and automation.

Figures

Figures reproduced from arXiv: 2411.10416 by the authors.

Figure 1
Figure 1. An illustration of a dialogue flow (left) that is used [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Efficient memoization used for FuDGE The intent-intent distance is defined as the cosine distance between the centroids of the two intents. The mathematical formulations are explained in detail in the Appendix. Actor Alignment. An utterance produced by a user should not be matched with an intent associated with an agent and vice versa. Therefore, if actors mismatch, we set the intent￾intent and intent-utterance dist… view at source ↗
Figure 3
Figure 3. Parameter tuning with FF1 for ALG2 and Make Payment task. The left column is the scores from an unsu￾pervised discovered flow, and the right column corresponds to the supervised flow. The optimal k is smaller for the su￾pervised flow, indicating a better compression. the entire discovery pipeline. The simplest clustering algo￾rithms, such as K-means, require k as the number of clusters. While hyperparameter selectio… view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

26 extracted references · 14 canonical work pages

  1. [1]

    , " * write output.state after.block = add.period write newline

    ENTRY address archivePrefix author booktitle chapter edition editor eid eprint howpublished institution isbn journal key month note number organization pages publisher school series title type volume year label extra.label sort.label short.list INTEGERS output.state before.all mid.sentence after.sentence after.block FUNCTION init.state.consts #0 'before.a...

  2. [2]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION word.in bbl.in capitalize " " * FUNCT...

  3. [3]

    M.; and Lemaire, V

    Bouraoui, J.-L.; Le Meitour, S.; Carbou, R.; Rojas Barahona, L. M.; and Lemaire, V. 2019. G raph2 B ots, Unsupervised Assistance for Designing Chatbots. In Proceedings of the 20th Annual SIGdial Meeting on Discourse and Dialogue, 114--117. Stockholm, Sweden: Association for Computational Linguistics

    work page 2019

  4. [4]

    S.; Constant, N.; Guajardo-Cespedes, M.; Yuan, S.; Tar, C.; et al

    Cer, D.; Yang, Y.; Kong, S.-y.; Hua, N.; Limtiaco, N.; John, R. S.; Constant, N.; Guajardo-Cespedes, M.; Yuan, S.; Tar, C.; et al. 2018. Universal sentence encoder. arXiv preprint arXiv:1803.11175

    arXiv 2018

  5. [5]

    Devlin, J.; Chang, M.-W.; Lee, K.; and Toutanova, K. 2018. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805

    arXiv 2018

  6. [6]

    Ester, M.; Kriegel, H.-P.; Sander, J.; Xu, X.; et al. 1996. A density-based algorithm for discovering clusters in large spatial databases with noise. In kdd, volume 96, 226--231

    1996

  7. [7]

    Forman, G.; Nachlieli, H.; and Keshet, R. 2015. Clustering by intent: a semi-supervised method to discover relevant clusters incrementally. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, 20--36. Springer

    work page 2015

  8. [8]

    Ghazarian, S.; Weischedel, R.; Galstyan, A.; and Peng, N. 2020. Predictive engagement: An efficient metric for automatic evaluation of open-domain dialogue systems. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, 7789--7796

    work page 2020

Show all 26 references
  1. [9]

    Khalid, B.; and Lee, S. 2022. Explaining Dialogue Evaluation Metrics using Adversarial Behavioral Analysis. In Proceedings of the 2022 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, 5871--5883

    2022

  2. [10]

    Lavi, O.; Rabinovich, E.; Shlomov, S.; Boaz, D.; Ronen, I.; and Anaby-Tavor, A. 2021. We've had this conversation before: A Novel Approach to Measuring Dialog Similarity. arXiv preprint arXiv:2110.05780

    2021 arXiv

  3. [11]

    I.; et al

    Levenshtein, V. I.; et al. 1966. Binary codes capable of correcting deletions, insertions, and reversals. In Soviet physics doklady, volume 10, 707--710. Soviet Union

    1966

  4. [12]

    Lin, T.-E.; Xu, H.; and Zhang, H. 2020. Discovering new intents via constrained deep adaptive clustering with cluster refinement. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, 8360--8367

    2020

  5. [13]

    Mangu, L.; Brill, E.; and Stolcke, A. 2000. Finding consensus in speech recognition: word error minimization and other applications of confusion networks. Computer Speech & Language, 14(4): 373--400

    2000

  6. [14]

    E.; Mehri, S.; and Kober, T

    Mosig, J. E.; Mehri, S.; and Kober, T. 2020. Star: A schema-guided dialog dataset for transfer learning. arXiv preprint arXiv:2010.11853

    2020 arXiv

  7. [15]

    Perkins, H.; and Yang, Y. 2019. Dialog Intent Induction with Deep Multi-View Clustering. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), 4016--40...

    2019

  8. [16]

    Qi, J.; Tang, J.; He, Z.; Wan, X.; Zhou, C.; Wang, X.; Zhang, Q.; and Lin, Z. 2022. RASAT: Integrating Relational Structures into Pretrained Seq2Seq Model for Text-to-SQL. arXiv preprint arXiv:2205.06983

    2022 arXiv

  9. [17]

    Qiu, L.; Zhao, Y.; Shi, W.; Liang, Y.; Shi, F.; Yuan, T.; Yu, Z.; and Zhu, S.-C. 2020. Structured attention for unsupervised dialogue structure induction. arXiv preprint arXiv:2009.08552

    2020 arXiv

  10. [18]

    Reimers, N.; and Gurevych, I. 2019. Sentence-bert: Sentence embeddings using siamese bert-networks. arXiv preprint arXiv:1908.10084

    2019 arXiv

  11. [19]

    Shi, C.; Chen, Q.; Sha, L.; Li, S.; Sun, X.; Wang, H.; and Zhang, L. 2018. Auto-Dialabel: Labeling Dialogue Data with Unsupervised Learning. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, 684--689. Brussels, Belgium: Association for ...

    2018

  12. [20]

    Sun, W.; Zhang, S.; Balog, K.; Ren, Z.; Ren, P.; Chen, Z.; and de Rijke, M. 2021. Simulating user satisfaction for the evaluation of task-oriented dialogue systems. In Proceedings of the 44th International ACM SIGIR Conference on Research and Development in Information Retriev...

    2021

  13. [21]

    Tian, X.; Huang, L.; Lin, Y.; Bao, S.; He, H.; Yang, Y.; Wu, H.; Wang, F.; and Sun, S. 2021. Amendable generation for dialogue state tracking. arXiv preprint arXiv:2110.15659

    2021 arXiv

  14. [22]

    A.; and Fischer, M

    Wagner, R. A.; and Fischer, M. J. 1974. The string-to-string correction problem. Journal of the ACM (JACM), 21(1): 168--173

    1974

  15. [23]

    D.; Henderson, M.; Raux, A.; Thomson, B.; Black, A.; and Ramachandran, D

    Williams, J. D.; Henderson, M.; Raux, A.; Thomson, B.; Black, A.; and Ramachandran, D. 2014. The dialog state tracking challenge series. AI Magazine, 35(4): 121--124

    2014

  16. [24]

    Yeh, Y.-T.; Eskenazi, M.; and Mehri, S. 2021. A comprehensive assessment of dialog evaluation metrics. arXiv preprint arXiv:2106.03706

    2021 arXiv

  17. [25]

    Zhang, H.; Xu, H.; Lin, T.-E.; and Lyu, R. 2021. Discovering new intents with deep aligned clustering. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 35, 14365--14373

    2021

  18. [26]

    Zhang, Y.; Zhang, H.; Zhan, L.-M.; Wu, X.-M.; and Lam, A. 2022. New Intent Discovery with Pre-training and Contrastive Learning. arXiv preprint arXiv:2205.12914

    2022 arXiv

Pith tools

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