Pith. sign in

REVIEW 4 major objections 5 minor 29 references

Self-supervised Analogical Learning using Language Models

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

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

Pith's one-line read Training a language model on symbolic programs it writes for similar, confidently answered questions reduces reasoning inconsistency and improves rare-case accuracy by 2% to 20%.

desk verdict A genuinely self-supervised program-distillation pipeline that improves a 7B model's reasoning, but the supervision labels are the model's own consistent answers, so the accuracy gains are less firmly established than the consistency gains. read the letter →

arxiv 2502.00996 v1 pith:XULWHZHQ submitted 2025-02-03 cs.CL

Ben Zhou , Sarthak Jain , Yi Zhang , Qiang Ning , Shuai Wang , Yassine Benajiba , Dan Roth This is my paper · ORCID
classification cs.CL
keywords analogicallearningself-supervisedreasoningconsistencyprogram-aidedchain-of-thoughtsymbolicprogramsgeneralizationfine-tuning
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

Large language models often fail on questions that are rare variants of common reasoning patterns, even when they know the facts those questions need. This paper tries to fix that inconsistency with SAL, a self-supervised analogical learning scheme: the model generates abstract versions of a question, finds similar questions it can answer with high confidence, writes Python programs that capture the shared reasoning, and then fine-tunes itself on those programs. The authors report that a 7B model trained this way outperforms chain-of-thought and seed-only baselines by 2% to 20% on StrategyQA, GSM8K, HotpotQA, ARC, and CommonsenseQA, while also becoming more interpretable because answers come from executables. If correct, the work suggests that reasoning consistency can be trained directly from the model's own high-confidence successes, without any gold labels on the target questions.

What carries the argument

The machinery is a programmatic solution space: Python programs with an answer() function and an ask_llm() helper for factual subqueries, plus two extraction pipelines that turn those programs into training data. Conceptualization converts a question into an abstract form, samples similar concrete questions, filters them by 9-of-10 chain-of-thought agreement, and keeps only programs that execute to the correct answer according to the model's own high-confidence answers on at least max(3, 75%) of the similar questions, while also dropping programs that merely paraphrase the original question or make too few reasoning queries. Simplification iteratively decomposes a math question into next questions and known conditions, composing the discovered subroutines into a full program. The key idea is that the trained model learns the high-level, transferable reasoning process rather than memorizing a particular arrangement of entities, which is what lets a solution found for a common case be reused on a rare case.

What would settle it

Collect a set of questions whose 9-of-10-agreement chain-of-thought answers are known to be wrong, generate SAL supervision from them, train, and test on held-out rare questions sharing the same reasoning process: if performance on those questions does not drop, the confidence-filter assumption is not load-bearing, and if it drops, the assumption fails. A more direct comparison is to train SAL once with the model's own high-confidence answers and once with gold labels on the same similar questions; if the two accuracies diverge, the reliance on self-generated labels is the deciding factor.

Watch

Extended reading notes

Core claim

The paper's central claim is that a language model's inconsistent performance on rare questions can be reduced by making the model generate, verify, and train on symbolic solutions to questions that share the same underlying reasoning. In SAL, the model first conceptualizes an original question into an abstract form, produces concrete similar questions, keeps only those where 9 of 10 chain-of-thought samples agree, and writes Python programs that solve those similar questions. Those programs are checked against the model's own high-confidence answers, then used as supervision in the form of question-to-program and abstract-question-to-program training. For math, a simplification pipeline decomposes the original question into smaller steps and composes the programs discovered at each step into a complete solution. The paper reports that the resulting model outperforms the base model's chain-of-thought reasoning by 2% to 20% on several benchmarks, and that the self-supervised model relies less on simply re-asking the original question through a language-model helper.

Load-bearing premise

The load-bearing premise is that the model's own high-confidence step-by-step answers are correct enough to serve as the ground truth for checking the programs it will train on, so a set of confidently wrong answers would be baked into the model rather than corrected.

Editorial extensions

If this is right

  • The paper reports accuracy gains of 2% to 20% over chain-of-thought inference across StrategyQA, GSM8K, HotpotQA, ARC, and CommonsenseQA for a 7B model.
  • In conceptual-reasoning evaluations where only the abstract question is shown, the SAL-trained model beats a much larger instruction-tuned model on three of the four datasets.
  • Because SAL inference executes programs, answers become auditable, and the trained model is less likely to delegate the whole question back to a language-model helper: removing programs that paraphrase the original question costs the seed-only baseline 11% accuracy but the SAL model only 3%.
  • The self-supervision loop does not use gold labels for the original questions, so the same pipeline can be applied to new unlabeled question collections to expand supervision beyond the 2,000-to-5,000 question scale used in the paper.

Reading between the lines

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

  • Editorial inference: because conceptualization only handles binary answers, an extension would be to verify programs on free-form answers through executable checks or unit tests, which would remove the binary restriction the paper names as a limitation.
  • Editorial inference: the 9-of-10 agreement filter rewards self-consistency rather than correctness, so an iterative SAL loop could drift toward confidently wrong programs on rare topics; a safeguard would be to audit agreement against a small gold-labeled set during training.
  • Editorial inference: the reported transfer to ARC and CommonsenseQA suggests the learned programs are not dataset-specific, so a testable prediction is that SAL-trained models would also improve on open-domain multi-hop questions whose reasoning paths are common but whose entities are rare.
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 SAL (Self-supervised Analogical Learning), a framework that fine-tunes a base language model on Python programs that the model itself generates from similar or simpler questions. Two extraction pipelines are introduced: conceptualization, which finds analogous questions sharing a high-level solution and distills programs from their chain-of-thought answers, and simplification, which iteratively decomposes math questions into easier sub-questions. The method is evaluated on StrategyQA, GSM8K, HotpotQA, ARC, and CommonsenseQA with Mistral-7B, reporting gains over a seed-only fine-tuned baseline and a chain-of-thought baseline. The paper also includes an analysis of conceptual reasoning and a sanity-check experiment for the simplification pipeline.

Significance. If the reported gains are robust, SAL would be a practical, label-free method for improving reasoning consistency and cross-task generalization in smaller LLMs, while also providing programmatic interpretability. The paper has several strengths: it includes a carefully controlled 'Seed Only' baseline, evaluates on multiple benchmarks, reports both seen and unseen splits, and includes a sanity-check experiment for the simplification pipeline. The code and data are promised for release. The central concern is that the self-supervision signals are filtered by internal consistency rather than verified correctness, which may undermine the claim that SAL trains on 'high-quality symbolic solutions.' This issue is addressable but requires additional validation.

major comments (4)
  1. [Section 3.4.1 and footnote 4] The selection of self-supervision programs in the conceptualization pipeline is based on agreement with 'silver labels' that are the model's own chain-of-thought answers, not gold answers. The 9/10 consensus filter (Section 3.4.1) and the accuracy-based criteria verify agreement with these silver labels, so they measure consistency, not correctness. The paper never evaluates the gold-label accuracy of the selected similar questions or the accepted programs for the conceptualization pipeline. Since the abstract and Section 1 claim that SAL transfers 'high-quality symbolic solutions,' this missing validation is load-bearing. The motivating example in Fig. 1 shows models being confidently wrong on rare entity combinations; a cluster of similar questions sharing such a bias could pass the 9/10 filter and reinforce an error in training. I recommend adding a gold-accuracy audit on a sample of the selected silver labels and programs, or at least a correlation analysis between self-consistency and gold correctness.
  2. [Section 5.2, 'seen' splits] The 'seen' evaluation split contains questions that were used as inputs during self-supervision extraction. Although the paper correctly notes that gold labels are not used, the model is trained on programs derived from these questions (and their abstract or similar variants), so it has seen the question text and related reasoning during training. This may inflate results through memorization of question-to-program mappings. The paper should either report the 'unseen' split as the primary evaluation or include a control that measures the contribution of seeing the question text alone (for example, training on the same seed data with randomized programs). The current Table 2 shows that 'seen' gains are not systematically larger than 'unseen' gains (GSM unseen is actually higher), which mitigates the concern, but the issue should be addressed explicitly to rule out leakage.
  3. [Section 5.2, training details] All experimental results are averaged over only two random seeds, and no variance or significance measures are reported. Several improvements in Table 2 are small (for example, SAL (concept. only) improves over Seed Only by 1.2 points on HotpotQA, and SAL (all) improves by 1.2 points on CommonsenseQA). Without standard deviations or per-seed results, these differences could easily fall within run-to-run noise. The paper should report per-seed results or confidence intervals, and the discussion should focus on effects that are consistent across seeds.
  4. [Section 3.4, conceptualization pipeline] The framework relies on the assumption that the automatically generated similar questions share the same underlying reasoning process as the original question. This assumption is inherited from Zhou et al. (2024), but the paper does not validate it for the current setup. The only filter used in SAL is the 9/10 chain-of-thought agreement, which does not guarantee that the selected questions require the same high-level solution; a question could have the same answer via a different reasoning path and still be selected, leading to a program that is not a valid target for the original question. I suggest a small human evaluation of the similarity between selected questions and the original, or an analysis of program execution agreement on the original question when gold labels are available.
minor comments (5)
  1. [Limitations section] The 'Single Base Model' limitation is duplicated verbatim; one of the two copies should be removed.
  2. [Section 3.4.1, footnote 4] The term 'silver labels' is defined only in a footnote; since it is central to the selection criteria, it should be defined in the main text where the accuracy-based criteria are introduced.
  3. [Table 1] The 'Accuracy' column in Table 1 does not specify what the accuracy is measured against. The text says the accuracy is 'on par with the original generation,' but it is unclear whether this is against gold GSM8K answers or against something else. Please clarify the evaluation reference.
  4. [Section 1, last paragraph] The phrase 'by 2% to 20%' is vague and mixes different benchmarks and baselines. It would be clearer to report per-dataset improvements in the abstract, or to state that the range covers all reported comparisons.
  5. [Appendix A.2] In Table 10, the helper function 'ask_llm' appends 'Answer in {unit}.' even when the unit is None; this may cause malformed prompts for questions without a physical or monetary unit. The implementation should handle the unit=None case explicitly, or the paper should note how this case is handled.

Circularity Check

1 steps flagged · score 3.0 of 10

SAL's supervision selection defines 'high-quality' programs as those that match the model's own CoT silver labels, creating a partially self-definitional loop, but the headline benchmark gains are externally evaluated and controlled.

  1. self definitional [Section 3.4.1, Accuracy-based criteria (and footnote 4)]
    "We execute each of the generated programs with the parameters corresponding to each selected similar question. Let the number of remaining similar questions be M; we set a high threshold of max(3, M∗ 0.75) and select programs that execute to the correct silver labels4 over such a threshold number of questions. 4Here the silver labels refer to the CoT answers of each generated similar questions, as we do not use gold labels of the original questions in any way."

    By construction, a program's 'correctness' is defined as agreement with the base model's own majority-voted CoT answer on the same cluster of generated similar questions. The pipeline keeps only similar questions with 9/10 CoT agreement, then verifies candidate programs against those same silver labels, so the supervision targets are generated and validated by the same model. Hence the 'high-quality symbolic solutions' SAL transfers are high-quality only in the sense of being self-consistent; a confidently wrong cluster would have its error reinforced as training signal. This is a self-definitional loop in the supervision-extraction quality claim.

full rationale

SAL is a self-supervised method, so using model-generated outputs as training targets is by design and not automatically circular. The paper also controls for the borrowed Zhou et al. (2024) seed data with the Seed Only baseline and reports gains on externally labeled StrategyQA, GSM8K, and HotpotQA splits, which keeps the central result independently falsifiable. The one concrete circular reduction is in the Accuracy-based criteria of Section 3.4.1: the quality of candidate programs is defined as executing to the 'correct silver labels,' and footnote 4 defines those silver labels as the CoT answers of the model's own generated similar questions. Thus the 'high-quality symbolic solutions' that SAL claims to transfer are, by construction, solutions that agree with the model's own consistency-filtered outputs; no external correctness check is applied to the accepted programs. This is a partial, internal circularity in the supervision-selection claim, not a collapse of the benchmark results, so the overall score is moderate rather than high.

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

The framework's main free parameters are the hand-set thresholds for data collection. The central assumptions are that self-consistency indicates correctness, that questions generated from the same abstraction share a solution, that programs with ask_llm calls capture the reasoning, and that decomposing math questions reduces errors. No new entities are postulated.

free parameters (9)
  • N = 20
    Number of similar questions generated per abstract question in conceptualization (Section 3.4.1). Hand-set.
  • K = 10
    Number of chain-of-thought samples per similar question (Section 3.4.1).
  • X = 9
    Agreement threshold: keep similar questions where at least 9 of 10 CoT answers agree (Section 3.4.1).
  • accuracy_threshold_high = max(3, M*0.75)
    Programs must execute correct silver labels on this many similar questions to be kept for abstract-question-to-program instances (Section 3.4.1).
  • accuracy_threshold_low = 2
    Threshold for question-to-program instances (Section 3.4.1).
  • similarity_threshold = 0.95
    Paraphrase score threshold to drop programs that ask the original question again (Section 3.4.1).
  • LoRA_r = 32
    LoRA rank used in all fine-tuning (Section 5.2).
  • learning_rate = 2e-4
    Learning rate for fine-tuning (Section 5.2).
  • epochs = 5
    Number of epochs for training (Section 5.2).
assumptions (4)
  • domain assumption High self-consistency (9/10 agreement) of the base model's chain-of-thought answers on generated similar questions is a reliable proxy for correctness.
    Section 3.4.1 selects 'high-confidence questions' solely by self-agreement, without external labels.
  • domain assumption Questions generated from the same abstract question share the same high-level solution as the original question.
    Conceptualization (Section 3.1) relies on this transferability, inherited from Zhou et al. (2024).
  • domain assumption The reasoning for a question can be faithfully and completely encoded as a Python program with ask_llm helper calls.
    Section 3 defines the programmatic solution space and uses it for both supervision and inference.
  • domain assumption Decomposing a math question into smaller sub-questions reduces reasoning errors.
    The simplification pipeline (Section 3.2) assumes cognitive overload is reduced by iterative decomposition.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Self-supervised Analogical Learning using Language Models." pith.science (2026). https://pith.science/paper/XULWHZHQ

@misc{pith2026250200996,
  author       = {Pith},
  title        = {Pith review of: Self-supervised Analogical Learning using Language Models},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/XULWHZHQ}},
  note         = {Machine review of arXiv:2502.00996}
}
read the original abstract

Large language models have been shown to suffer from reasoning inconsistency issues. That is, they fail more in situations unfamiliar to the training data, even though exact or very similar reasoning paths exist in more common cases that they can successfully solve. Such observations motivate us to propose methods that encourage models to understand the high-level and abstract reasoning processes during training instead of only the final answer. This way, models can transfer the exact solution to similar cases, regardless of their relevance to the pre-training data distribution. In this work, we propose SAL, a self-supervised analogical learning framework. SAL mimics the human analogy process and trains models to explicitly transfer high-quality symbolic solutions from cases that they know how to solve to other rare cases in which they tend to fail more. We show that the resulting models after SAL learning outperform base language models on a wide range of reasoning benchmarks, such as StrategyQA, GSM8K, and HotpotQA, by 2% to 20%. At the same time, we show that our model is more generalizable and controllable through analytical studies.

Figures

Figures reproduced from arXiv: 2502.00996 by the authors.

Figure 1
Figure 1. An illustration of models’ (including o1) in [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Overview of the conceptualization pipeline. Functions refer to sub-tasks and prompt templates. [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. An example math question and overview of how our simplification process can acquire more correct [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

29 extracted references · 9 canonical work pages

  1. [1]

    Wenhu Chen, Xueguang Ma, Xinyi Wang, and William W Cohen. 2022. Program of thoughts prompting: Disentangling computation from reasoning for numerical reasoning tasks. arXiv preprint arXiv:2211.12588

    arXiv 2022

  2. [2]

    Peter Clark, Isaac Cowhey, Oren Etzioni, Tushar Khot, Ashish Sabharwal, Carissa Schoenick, and Oyvind Tafjord. 2018. https://api.semanticscholar.org/CorpusID:3922816 Think you have solved question answering? try arc, the ai2 reasoning challenge . ArXiv, abs/1803.05457

    arXiv 2018

  3. [3]

    Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, et al. 2021. Training verifiers to solve math word problems. arXiv preprint arXiv:2110.14168

    arXiv 2021

  4. [4]

    Yu Feng, Ben Zhou, Weidong Lin, and Dan Roth. 2024. Bird: A trustworthy bayesian inference framework for large language models. arXiv preprint arXiv:2404.12494

    arXiv 2024

  5. [5]

    Luyu Gao, Aman Madaan, Shuyan Zhou, Uri Alon, Pengfei Liu, Yiming Yang, Jamie Callan, and Graham Neubig. 2023. Pal: Program-aided language models. In International Conference on Machine Learning, pages 10764--10799. PMLR

    2023

  6. [6]

    Mor Geva, Daniel Khashabi, Elad Segal, Tushar Khot, Dan Roth, and Jonathan Berant. 2021. https://doi.org/10.1162/tacl_a_00370 Did aristotle use a laptop? a question answering benchmark with implicit reasoning strategies . Transactions of the Association for Computational Linguistics, 9:346--361

    doi:10.1162/tacl_a_00370 2021

  7. [7]

    Shibo Hao, Yi Gu, Haodi Ma, Joshua Hong, Zhen Wang, Daisy Wang, and Zhiting Hu. 2023. Reasoning with language model is planning with world model. In EMNLP

    work page 2023

  8. [8]

    Edward J Hu, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, Weizhu Chen, et al. 2021. Lora: Low-rank adaptation of large language models. In ICLR

    work page 2021

Show all 29 references
  1. [9]

    Lewis, and Joyce Yue Chai

    Xiaoyang Hu, Shane Storks, Richard L. Lewis, and Joyce Yue Chai. 2023. In-context analogical reasoning with pre-trained language models. In ACL

    2023

  2. [10]

    Daniel Khashabi, Sewon Min, Tushar Khot, Ashish Sabharwal, Oyvind Tafjord, Peter Clark, and Hannaneh Hajishirzi. 2020. Unifiedqa: Crossing format boundaries with a single qa system. In ACL (findings)

    2020

  3. [11]

    Omar Khattab, Keshav Santhanam, Xiang Lisa Li, David Hall, Percy Liang, Christopher Potts, and Matei Zaharia. 2022. Demonstrate-search-predict: Composing retrieval and language models for knowledge-intensive nlp. arXiv preprint arXiv:2212.14024

    2022 arXiv

  4. [12]

    Bangzheng Li, Ben Zhou, Xingyu Fu, Fei Wang, Dan Roth, and Muhao Chen. 2024. Famicom: Further demystifying prompts for language models with task-agnostic performance estimation. arXiv preprint arXiv:2406.11243

    2024 arXiv

  5. [13]

    Bangzheng Li, Ben Zhou, Fei Wang, Xingyu Fu, Dan Roth, and Muhao Chen. 2023. Deceptive semantic shortcuts on reasoning chains: How far can models go without hallucination? NAACL

    2023

  6. [14]

    Qing Lyu, Shreya Havaldar, Adam Stein, Li Zhang, Delip Rao, Eric Wong, Marianna Apidianaki, and Chris Callison-Burch. 2023. Faithful chain-of-thought reasoning. In Proceedings of the 13th International Joint Conference on Natural Language Processing and the 3rd Conference of t...

    2023

  7. [15]

    Iman Mirzadeh, Keivan Alizadeh, Hooman Shahrokhi, Oncel Tuzel, Samy Bengio, and Mehrdad Farajtabar. 2024. Gsm-symbolic: Understanding the limitations of mathematical reasoning in large language models. arXiv preprint arXiv:2410.05229

    2024 arXiv

  8. [16]

    OpenAI. 2023. Gpt-4 technical report

    2023

  9. [17]

    Alon Talmor, Jonathan Herzig, Nicholas Lourie, and Jonathan Berant. 2018. Commonsenseqa: A question answering challenge targeting commonsense knowledge. arXiv preprint arXiv:1811.00937

    2018 arXiv

  10. [18]

    Xiaojuan Tang, Zilong Zheng, Jiaqi Li, Fanxu Meng, Song-Chun Zhu, Yitao Liang, and Muhan Zhang. 2023. Large language models are in-context semantic reasoners rather than symbolic reasoners. arXiv preprint arXiv:2305.14825

    2023 arXiv

  11. [19]

    Jason Wei, Maarten Bosma, Vincent Zhao, Kelvin Guu, Adams Wei Yu, Brian Lester, Nan Du, Andrew M Dai, and Quoc V Le. 2022. Finetuned language models are zero-shot learners. In International Conference on Learning Representations

    2022

  12. [20]

    Nan Xu, Fei Wang, Ben Zhou, Bang Zheng Li, Chaowei Xiao, and Muhao Chen. 2023. Cognitive overload: Jailbreaking large language models with overloaded logical thinking. arXiv preprint arXiv:2311.09827

    2023 arXiv

  13. [21]

    Zhilin Yang, Peng Qi, Saizheng Zhang, Yoshua Bengio, William Cohen, Ruslan Salakhutdinov, and Christopher D Manning. 2018. Hotpotqa: A dataset for diverse, explainable multi-hop question answering. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language ...

    2018

  14. [22]

    Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik R Narasimhan, and Yuan Cao. 2023. React: Synergizing reasoning and acting in language models. In The Eleventh International Conference on Learning Representations

    2023

  15. [23]

    Michihiro Yasunaga, Xinyun Chen, Yujia Li, Panupong Pasupat, Jure Leskovec, Percy Liang, Ed Huai hsin Chi, and Denny Zhou. 2024. Large language models as analogical reasoners. ICLR

    2024

  16. [24]

    Siyu Yuan, Jiangjie Chen, Changzhi Sun, Jiaqing Liang, Yanghua Xiao, and Deqing Yang. 2024. Analogykb: Unlocking analogical reasoning of language models with a million-scale knowledge base. ACL

    2024

  17. [25]

    Eric Zelikman, Georges Harik, Yijia Shao, Varuna Jayasiri, Nick Haber, and Noah D Goodman. 2024. Quiet-star: Language models can teach themselves to think before speaking. arXiv preprint arXiv:2403.09629

    2024 arXiv

  18. [26]

    Ben Zhou, Hongming Zhang, Sihao Chen, Dian Yu, Hongwei Wang, Baolin Peng, Dan Roth, and Dong Yu. 2024. Conceptual and unbiased reasoning in language models. arXiv preprint arXiv:2404.00205

    2024 arXiv

  19. [27]

    Xuekai Zhu, Biqing Qi, Kaiyan Zhang, Xinwei Long, Zhouhan Lin, and Bowen Zhou. 2024. Pad: Program-aided distillation can teach small models reasoning better than chain-of-thought fine-tuning. In Proceedings of the 2024 Conference of the North American Chapter of the Associatio...

    2024

  20. [28]

    URL: " 'urlintro :=

    ENTRY address author booktitle chapter edition editor howpublished institution journal key month note number organization pages publisher school series title type volume year eprint doi pubmed url lastchecked label extra.label sort.label short.list INTEGERS output.state before...

  21. [29]

    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 gl...

Pith tools

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