acceptodds
Under review as a conference paper at ICLR 2027

The Token Games: Evaluating Language Model Reasoning with Puzzle Duels

Abstract

Evaluating the reasoning capabilities of Large Language Models is increasingly challenging as models improve. Human curation of hard questions is highly expensive, especially in recent benchmarks using PhD-level domain knowledge to challenge the most capable models. Even then, there is always a concern about whether these questions test genuine reasoning or if similar problems have been seen during training. Here, we take inspiration from 16th-century mathematical duels to design The Token Games (TTG): an evaluation framework where models challenge each other by creating their own puzzles. We leverage the format of Programming Puzzles — given a function that returns a boolean, find inputs that make it return True — to flexibly represent problems and enable verifying solutions. Using results from pairwise duels, we then compute Elo ratings, allowing us to compare models relative to each other. We evaluate 18 models — frontier systems, low-reasoning-effort variants, and open-weights models — on TTG, and closely match the rankings from existing benchmarks such as Humanity's Last Exam, without involving any human effort in creating puzzles and at a total cost of about $2,400 — a small fraction of the cost of sourcing expert-authored questions for comparable benchmarks. We also find that creating good puzzles is still a highly challenging task for current models. Overall, our work suggests new paradigms for evaluating reasoning that avoid saturation by design, and that allow testing models for other skills like creativity and task creation alongside problem solving.

Primary area:
foundation or frontier models, including LLMs
Keywords:
large language models, reasoning, evaluation, programming puzzles

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 4 reviews, above 85% of the others.
Reviewer_jaLgOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

The Token Games (TTG) evaluates language models through pairwise duels in which they alternate between proposing Python puzzles and solving their opponents’ puzzles. Solutions are verified by execution, and duel outcomes yield Elo ratings. Across 918 duels involving 18 models, the study reports positive correlations with established benchmarks and reproducible rankings. Further analyses examine puzzle difficulty, proposer behavior, and the relationship between problem posing and solving.

Critical strengths
  1. The framework automates both challenge generation and solution verification. Evaluating problem posing alongside solving offers a useful alternative to fixed, human-authored question sets. The complete round-robin evaluation, with three repetitions of each ordered pairing, provides substantial evidence beyond a proof of concept (§§3–4).
  2. The validation extends beyond benchmark correlations. Repeated tournaments achieve pairwise Spearman rank correlations of 0.95. Evaluation with a common set of solvers and re-solving self-proposed puzzles without the original context provide complementary evidence about puzzle difficulty and proposer behavior (§§4.3–4.6).
Critical weaknesses
  1. The statistical significance claim conflicts with the reported results. Section 4.1 states that all 15 correlations survive Bonferroni correction, yet Table 8 reports adjusted p-values of 0.0981 for match Elo–HLE and 0.0567 for match Elo–SWE-Bench Pro. Table 2 also uses role-specific win rates, whereas Table 8 uses role-specific Elo ratings, so the latter does not directly establish the robustness of the former’s correlations. These discrepancies require correction but do not negate the positive associations.
  2. The effect of formatting-only failures on rankings remains unquantified. Appendix D.12 shows a solver deriving the intended solution but losing because of Markdown backticks. Format compliance is a legitimate evaluation target, but such failures are distinct from reasoning errors. Their frequency and model-specific impact should be quantified to clarify what TTG rankings measure.
Questions for authors
  1. Statistical reporting: Please reconcile §4.1 with Tables 2 and 8, clarify the metrics used, and report adjusted p-values for a consistent set of correlations. Which conclusions hold under Bonferroni correction, and which under Benjamini–Hochberg correction? The existing scores should suffice for this analysis.
  2. Formatting sensitivity: Using saved solver outputs, could the authors quantify failures recoverable by removing only unambiguous formatting wrappers? Please report recovered solutions by model and any changes in offline duel scores or Elo rankings. Retain the original protocol as the primary result and present normalization as a sensitivity analysis; no new tournament is requested.
2 comments

Thank you for the very careful reading. Both requests were feasible with existing data, and we have done both.

Statistical reporting. You are right, and we thank you for catching this. The claim in §4.1 that all 15 correlations survive Bonferroni correction is incorrect; this was an error in our text. Using a consistent family of 15 tests per table:

  • Table 2 (match Elo, Solver Win Rate, and Proposer Win Rate against the five benchmarks): 11 of 15 correlations survive Bonferroni. The four that do not are Elo–HLE (adjusted p = 0.098), Elo–SWE-Bench Pro (0.057), Solver Win Rate–HLE (0.078), and Proposer Win Rate–SWE-Bench Pro (0.504). All 15 survive Benjamini–Hochberg at FDR 0.05 (largest adjusted p = 0.034).
  • Table 8 (match, proposer, and solver Elo): 10 of 15 survive Bonferroni. The five that do not are match and proposer Elo against HLE (0.098) and SWE-Bench Pro (0.057), and solver Elo against SWE-Bench Pro (0.106). All 15 survive Benjamini–Hochberg (largest adjusted p = 0.007).

All failures under Bonferroni involve HLE or SWE-Bench Pro. We will report raw, Bonferroni-adjusted, and BH-adjusted p-values for Table 2, state that the leave-one-out analysis uses unadjusted p-values, and revise §4.1 to claim only what these results support. As you note, the positive associations remain.

Formatting sensitivity. Following your protocol, we re-verified the saved solver outputs after removing only unambiguous formatting wrappers: enclosing backticks, a stray trailing backtick (from wrapping the whole SOLUTION: x line in backticks), and Markdown bold markers. A wrapper is removed only if the original answer is not valid Python and the stripped answer is, so no valid answer is ever changed.

  • 131 solver answers (1.4% of 9,231 attempts on valid puzzles) failed because of such a wrapper. After stripping, 59 of them are correct; the rest are wrong answers in a wrapper.
  • The recovered solutions are concentrated in four models: Grok 4.20 (18), Claude Opus 4.8 (14), GLM-5.2 (11), and Grok 4 Fast (7). Six other models gain between 1 and 3, and the rest none. (Per-model table in the new appendix.)
  • Duel scores change in 51 of 918 duels and the match result in 19, almost always between a win and a draw.
  • Rankings barely move. Kendall τ with the original is 0.980 for match Elo (five models move by one or two ranks; the largest shift is +67 Elo for Grok 4.20), 0.987 for proposer Elo, and 1.000 for solver Elo. The benchmark correlations change by at most 0.03.
  • On the proposer side, only 3 of 3,621 failed reference solutions involve a wrapper.

We keep the original protocol as the primary result and report normalization as a sensitivity analysis in the appendix.

We’ll update the paper shortly.

Thank you to the authors for their response. Most of my concerns have been addressed.

Reviewer_9sDmOpenReview ↗
Rating
3(+1)
Confidence
4
Informativeness
3(+1)
Presentation
3
Soundness
3(+1)
Read review
Paper summary

The Token Games proposed an evaluation framework that let LLMs propose puzzles to each other and create a elo rating out of the results.

Critical strengths
  1. This benchmark resists saturation by design.
  2. The format design enables automatic answer checking.
Critical weaknesses
  1. What does TTG actually measure? It does correlate with some existing benchmarks, but I would request authors to think about the measurement based on the puzzle design. It seems to be targeting a specific set of problems which are limited by the design space of the puzzle. This question is followed by the concern about the diversity of the generated puzzles. Topics tags are not sufficient -- the underlying structure could be the same. TTG may not achieve sufficient coverage of reasoning capability.
Questions for authors
  1. Please compare TTG with MathDuels [1], which seems to work with Mathematical problems and share similar motivation and methodology.

[1] MathDuels: a self-play benchmark that grows. Xu et al. COLM 2026

2 comments

Thank you for the review and for the pointer to MathDuels.

What TTG measures. TTG measures the ability to pose and solve problems with verifiable solutions. Concretely, this means reasoning about programs: simulating code, inverting functions, and searching for inputs that satisfy constraints. The format "find x such that f(x) returns True" can express any problem with a computable verifier, so the space is not a fixed task family; what is actually asked depends on what proposers choose. In practice, the 12,852 puzzles carry 3,607 distinct topic tags (5.6 per puzzle on average); the most common are modular arithmetic (49%), strings (45%), bit manipulation (27%), number theory (25%), and hashing or cryptography (34%). TTG rankings correlate with expert-authored reasoning benchmarks (ρ between 0.69 and 0.84 for Elo) without any human-written questions, and this agreement does not depend on any single puzzle type (response to R8EA). Unlike static benchmarks, TTG also measures the ability to create hard, valid problems.

Diversity beyond topic tags. We agree that tags alone are insufficient, and added a structural analysis. We normalized each puzzle's syntax tree (identifiers and constants abstracted away) and flagged pairs of puzzles with near-identical structure (Jaccard similarity ≥ 0.9 over node sequences). Flagged pairs are typically the same template with different constants.

  • 87% of puzzles have no structural near-duplicate anywhere in the tournament.
  • Repetition is mostly local: 11.1% of puzzles are near-copies of the same proposer's puzzle in the same duel, and 3.9% copy the opponent's earlier puzzle in the same duel. Across different duels, only 1.5% of puzzles repeat the same proposer's structure and 0.9% another proposer's.
  • Repetition is concentrated in a few models: Grok 4.20 (58% of its puzzles), Grok 4 Fast (42%), and Claude Opus 4.8 (38%). For 12 of the 18 models it is at most 10%.

The puzzles are therefore not variations of a few shared templates. Some models do repeat their own templates within a duel despite the instruction not to, which we will report as part of each proposer's profile.

MathDuels. Thank you for the pointer. We consider MathDuels to be concurrent work. Without breaking anonymity, we can say that MathDuels appeared on arXiv after TTG was first made public. The two works share a motivation, which goes back to historical mathematical duels, but differ in key design choices:

  • Verification. Both require the puzzle proposer to supply an answer. In TTG, the reference solution is verified by executing the puzzle; in MathDuels, answers are scalar expressions checked by symbolic equivalence, with an LLM-as-a-judge verifier deciding which problems are ill-posed.
  • Invalid problems. MathDuels discards problems that the LLM-as-a-judge flags as ill-posed. TTG instead penalizes the proposer, which rewards proposers for calibrating difficulty to what they can verify themselves (§4.5).
  • Duel structure. TTG runs interactive pairwise duels in which proposers see the duel history and the opponent's puzzles, whereas MathDuels is a single round in which every author's problems are solved by every other model, rated with a Rasch model.
  • Domain. MathDuels is restricted to mathematics with scalar answers, while TTG covers any computably verifiable problem.

We’ll update the paper shortly.

Thanks authors for their response. I have updated my score.

The generation diversity is an interesting observation that could be discussed more in the paper.

Reviewer_R8EAOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

This paper introduces TTG, a framework for evaluating reasoning capabilities in which large language models generate and solve puzzles for one another. In pairwise duels, models alternate between the roles of proposer and solver. Each puzzle is represented as a Python function that returns a boolean value, and the goal is to find an input that makes the function return True. The proposer must also provide a candidate solution. The system verifies solutions by executing the code, determines the score for each round based on the verification results and whether the opponent solves the puzzle, and computes Elo ratings from the duel outcomes. The approach aims to reduce reliance on human puzzle creation while assessing both problem-solving and problem-posing abilities.

The experiments show that TTG rankings broadly agree with those of several existing reasoning and programming benchmarks and remain relatively stable across repeated runs. Models exhibit different preferences for puzzle topics and proposing strategies, while creating valid puzzles that can stump an opponent remains challenging: models may provide incorrect reference solutions or propose puzzles that are too easy. The authors also observe that puzzles generated later in a duel tend to be harder. Overall, the work explores a dynamic evaluation approach that automatically generates puzzles and verifies solutions through code execution, offering a new perspective on evaluating models' reasoning and task-construction capabilities.

Critical strengths
  1. The evaluation design is simple and highly automated. TTG has models generate puzzles for one another and verifies solutions by executing Python code, reducing the need for human puzzle creation and subjective scoring. Requiring proposers to provide valid solutions and penalizing invalid proposals also places basic constraints on the quality of automatically generated puzzles.

  2. The experimental analysis is reasonably comprehensive. In addition to comparing TTG rankings with existing benchmarks, the paper examines proposing and solving performance separately and analyzes puzzle topics, reasons for failed proposals, and the stability of repeated tournaments. These analyses reveal whether models struggle to create challenging puzzles or fail to solve their own problems correctly, providing more specific information about their capabilities than a single aggregate score.

Critical weaknesses
  1. The contributions of different capabilities to the scores are difficult to disentangle. The paper notes that some harder puzzles involve hashing and cryptography, and also reports failures related to Python semantics and string handling. TTG scores may therefore reflect a mixture of general reasoning ability, domain knowledge, and code implementation details. Although the paper provides puzzle analyses and correlations with other benchmarks, it lacks controlled comparisons that further examine rankings by puzzle type and failure cause, making it difficult to determine the contribution of each factor.

  2. The evidence that models use duel history to increase puzzle difficulty is not sufficiently direct. The main text finds that puzzles become harder in later rounds, but does not present comparisons against settings with no history or with previous puzzles but no duel outcomes. It therefore remains unclear whether the increase in difficulty comes from effective use of feedback about the opponent or from other factors, such as accumulating context or changes in puzzle types.

Questions for authors
  1. Could the authors compare model performance separately across puzzle types, such as mathematics, cryptography, and string manipulation, to examine whether the overall rankings are primarily driven by a small number of puzzle types? Would the main rankings and correlations with existing reasoning benchmarks persist if hashing and cryptography puzzles were given less weight?

  2. Could the authors separately quantify failures caused by answer formatting, misunderstandings of Python semantics, or runtime errors, and analyze their effects on overall scores and model rankings? This would help clarify the extent to which TTG measures general reasoning ability and how sensitive it is to code implementation details.

  3. Could the authors add controlled comparisons between providing no history, only previous puzzles, and the full duel history to test whether the increasing difficulty of later puzzles is indeed due to models using feedback about their opponents?

Questions worth exploring:

  1. The problem format is too limited. Python-based problems are easy to verify, but they assess a relatively narrow range of capabilities. It would be valuable to explore a broader range of evaluation tasks, including multimodal tasks.
1 comment

Thank you for the careful review and the concrete questions.

Rankings by puzzle type. We ran both analyses on the existing logs, using the tags of §4.2 and grouping all hashing, cryptography, cipher, and checksum tags into one family (33.7% of puzzles).

Removing a type. Dropping all hashing and cryptography rounds and recomputing match Elo from the remaining rounds gives Kendall τ = 0.93 with the original ranking. The benchmark correlations stay about the same or rise slightly: HLE 0.69 → 0.71, ARC-AGI 0.84 → 0.87, SWE-Bench Pro 0.72 → 0.69, TextQuests 0.77 → 0.81, GPQA-Diamond 0.77 → 0.81 (all p < 0.01). Removing any other of the ten most frequent types instead gives τ between 0.89 and 1.00. The overall ranking and its agreement with existing benchmarks are therefore not driven by any single type.

Rankings within a type. Rankings computed on one type alone agree less with the overall ranking, especially for solving (Kendall τ between 0.53 and 0.90, versus 0.80 to 0.94 for random subsets of the same size). Solving skill is thus partly type-specific. On hashing and cryptography puzzles, for example, Claude models rank higher as solvers (Claude Haiku 4.5 moves from 15th to 8th) and GPT-5.5 lower (2nd to 7th); on number theory the pattern reverses (GPT-5.5 low from 9th to 2nd, Claude Opus 4.7 from 5th to 12th). This supports your point that TTG scores average over several skills. We will add the per-type rankings to the appendix so readers can see the profile behind the aggregate.

Failure causes. We re-ran every failed check in the sandbox and classified the cause.

Solvers (2,090 failures)Proposers' reference solutions (3,621 failures)
Wrong answer (check returns False)85.5%89.3%
Formatting wrapper (backticks, bold)6.3%0.1%
Other unparseable answer (truncated, prose after the value)5.2%1.2%
Unquoted string or undefined name1.1%2.0%
Puzzle code itself invalid (syntax or runtime error)n/a5.6%
Other runtime error0.8%1.1%
Timeout1.1%0.7%

Wrong answers dominate on both sides. Removing unambiguous formatting wrappers barely changes the rankings (τ = 0.98 for match Elo; details in our response to jaLg). "Misunderstanding Python semantics" is hard to separate automatically from other wrong answers, so we do not report it as a separate category.

History ablation. We tested on the existing logs how a proposer's next puzzle depends on the outcome of its previous one, measuring difficulty with the three uniform solvers of §4.4, which do not see the duel. Compared with the same proposer's typical puzzle against the same opponent at the same turn, the next puzzle is harder after the opponent failed (+6.5 percentage points in uniform-solver failure rate) and slightly easier after the opponent succeeded (−1.9 points); holding the previous puzzle's own difficulty fixed, these become +3.3 and −0.9 points. Together with the per-turn trend, which persists after controlling for the previous outcome (0.16 instead of 0.22 points per turn), this produces the increase in difficulty over a duel that we report in §4.4.

Puzzles that reuse an earlier template show how proposers use the history. Repeating a template that stumped the opponent works: only 26% of such repeats are solved, versus 77% of puzzles overall. But about two-thirds of template repeats reuse one the opponent had already solved, and 89% of those are solved again. Proposers thus exploit what worked, but rarely respond to being solved by escalating. Current models use their opponent's feedback, but not yet effectively in both directions. How models use this information in a competitive setting is a promising direction for future work, for example through an ablation that shows past puzzles without their outcomes.

Format breadth. The format accepts any problem with a computable verifier, which is broad and covers everything from writing code in custom stack machines (Appendix D.14) to factorization (Appendix D.1). We agree, however, that multimodal and open-ended tasks are out of scope, and we will note this as a limitation.

We’ll update the paper shortly.

Reviewer_WMCPOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper "The Token Games" uses the concept of comparing LLMs by having each LLM propose a puzzle and also come up with a solution for the puzzle, and seeing if the proposed puzzle can stump another LLM. The contest compares 2 LLMs by have each take turns being the LLM proposer and the other being the LLM solver. The proposer LLM wins a round if it can propose a puzzle with a satisfying solution, that the other solver LLM is stumped and unable to solve, but if the other solver LLM can solve the proposed puzzle then it wins the round. "The Token Games" computes an ELO score among all the LLMs based on which one wins the most rounds in a multi-round contest, where each LLM takes turns being the proposer of problems, and also the solver of problems.

The LLM puzzles are written as Python test cases "F(x)", and the proposer gives an example solution program "y" such that F(y) returns True. So the question of correctness is deterministic, if F(x) is the puzzle and y is the solution, if F(y) == True it is correct, otherwise it is wrong. The authors showing that scoring LLMs in this manner correlates well with how LLMs do on reasoning benchmarks. The advantage of this approach is each duel is postulated to be a new original problem so not in the training sets of the LLMs. Existing benchmarks suffer from getting sucked up into LLM training sets and not being effective for comparing how well LLMs reason, once a benchmark is in the training set it's more testing how well the LLM can remember, rather than how well it can reason.

Critical strengths

Clever approach for comparing LLMs, well-presented and intuitively appealing.

Using LLM problem proposal as a metric for evaluating LLM is creative, the focus on LLM problem solving is standard practice and this was an interesting twist.

Evaluation across many models was nice to see.

Seems like the kernel of the idea could be expanded on by iterating multiple contests to get even harder problems - for better comparing models and for fine-tuning models.

Critical weaknesses

The problem with traditional reasoning benchmarks is that the benchmark gets sucked up in the training set, or trivial variations get sucked up as training data, and then the benchmark no longer tests reasoning, but tests memorization. How do we know the LLM proposer's puzzle is actually unique and not just regurgitating problems the LLM saw during training? The "Python Programming Puzzle" format seems pretty unique - but for all I know there are 10,000 websites of problems in the at format.

For D.13 "brainfuck" - could you rename to "brainfudge" or "brainfreeze" or something like that. I don't personally have a problem - but it risks being an "ethics: unprofessional behavior" issue for sensitive folks in the community. The community did rename "NIPS" -> "NeurIPS", so some folks might find it offensive with the current naming, even if LLM generated.

The GPU expense is non-trivial, but I would have liked to have seen multiple iterations of the contest and pass@k for solving with k=10 or so, instead of pass@1, see questions below.

Questions for authors

I like the choice of using "Python Programming Puzzles" paradigm for giving a deterministic test case on whether a problem has been solved correctly. But it feels like giving the LLM just one chance to solve is too noisy. In both the LLM proposer scenario of having to solve the puzzle the proposer (itself) created, and in the LLM solver scenario where it is trying to solve a puzzle proposed by another LLM, it feels like Pass@K would be more robust. Or you could prompt the LLM with an explanation of how to use a tool to execute it's solution, and a single/few shot example showing how to propose a solution, test the solution, and if it returns False, propose another solution. Have you tried anything like that? Doing pass@k or explicitly instructing the LLM to do it own multiple attempts and try verifying solutions before returning? Do the models typically do validation checks?

Could you do multiple runs of the "Token Game" competition - with each new run taking say the k best problems (like k=10) that were the "hardest" and stumped the most LLM in the previous run - and use those hardest examples as few shot examples for starting the next run - so all the LLM get bootstrapped/hinted into the types of puzzles that are hardest from the previous contest and see if the LLM relative ordering is stable - or if initializing/biasing them with the hardest puzzles from the previous run changes things where some models are better at pushing the frontier of hardness when given signal of the hardest problems from the previous runs.

In ICLR 2023 a paper for generating training data had some ideas around using LLMs to propose and solve problems with Python Programming Puzzles, https://arxiv.org/abs/2207.14502 that seemed like related work.

2 comments

Thank you for the positive and thoughtful review.

Memorization. We agree this is the core issue for reasoning benchmarks. Without access to training data, no benchmark can rule out memorization, and even with that access, memorization is often not verbatim. TTG's advantage lies in its incentives. A proposer gains nothing from posing a publicly available puzzle, since that puzzle is likely in its opponent's training data as well. Unlike in a static benchmark, the game therefore pushes proposers away from known problems. A solver can still use a memorized solution, exactly as in existing benchmarks, but it only faces puzzles that its opponent chose specifically to be hard for it, and there is no fixed test set that could leak.

To check this directly, we compared all 12,716 parseable TTG puzzles with the 1,714 puzzles of the public Python Programming Puzzles (P3) dataset, the main public source of puzzles in this format. We normalized each puzzle's syntax tree (identifiers and constants abstracted away) and represented it by the set of 4-grams of its syntax-tree node types; we then measure similarity as the Jaccard index of these sets, and we call two puzzles near-duplicates at ≥ 0.9. We found no TTG puzzle that is a structural near-duplicate of a P3 puzzle: the closest match for a TTG puzzle has a median similarity of 0.08 and a maximum of 0.23 (Jaccard), whereas a P3 puzzle rewritten in TTG style scores 1.0. Within TTG, 87% of puzzles have no structural near-duplicate anywhere in the tournament (details in our response to 9sDm). Structural comparison of course cannot rule out conceptual reuse, but our analysis does show models do not reproduce memorized puzzles from P3.

pass@k, tool use, iterated tournaments. These are good suggestions. Pass@1 noise is mitigated by the 14 rounds per duel and the three repetitions of each ordered pairing: the three repetitions form independent tournaments whose rankings agree at Spearman ρ = 0.95 pairwise (§4.6), so the ranking is not dominated by single-attempt noise. Pass@k increases only the solving cost, but iterated, bootstrapped tournaments multiply the full cost (about $2,350 for the current tournament), which is beyond our budget. We will discuss both as natural extensions, together with tool-assisted self-verification. Models deliberately have no code execution, since we evaluate reasoning about code rather than trial and error.

Do models validate their own answers? Mostly yes, where we can see it. Seven of the 18 models return their reasoning text; in those traces, 94% of solver responses and 83% of proposer responses contain explicit checking (for example, tracing the puzzle on the candidate answer). The other providers hide reasoning, so we cannot measure it there. Self-checking is therefore already common without prompting; what models lack is the ability to execute the check.

Haluptzok et al. Thank you. We will add and discuss it together with Absolute Zero, which we already cite. Both use LLM-proposed programming puzzles to generate training data in a self-improvement setting, whereas TTG uses them for evaluation of a pool of models.

Naming in D.13. Thank you for raising this. We will write "Brainf*ck" in section titles and prose, and otherwise keep the model-generated code verbatim.

We’ll update the paper shortly.

Thanks for the answers, I hope to see the paper accepted.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.