Pith. sign in

REVIEW 4 major objections 6 minor 45 references

URECA: The Chain of Two Minimum Set Cover Problems exists behind Adaptation to Shifts in Semantic Code Search

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

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

Pith's one-line read Minimum entropy adaptation to shifted code search is a chain of two set-cover problems, and URECA's fragment transport between clusters fixes the resulting initialization cascade.

desk verdict The central set-cover derivation rests on an invalid integral identity, so the paper's main theoretical claim collapses; URECA may be a useful heuristic, but the paper as written is not ready for peer review. read the letter →

arxiv 2502.07494 v1 pith:WCFLNVJF submitted 2025-02-11 cs.AI

Seok-Ung Choi , Joonghyuk Hahn , Yo-Sub Han This is my paper · ORCID
classification cs.AI
keywords semanticcodesearchminimumentropyproblemsetcoverdistributionshiftfew-shotadaptationdisentangledrepresentationsclusteringcontrastivelearning
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

Adaptation to shifted data in semantic code search is usually framed as minimizing entropy, and this paper tries to prove something specific about that framing: the minimum entropy problem decomposes, through a Lebesgue-integral rewriting, into a chain of two minimum set cover problems run by greedy selection. That decomposition is offered as the mechanism behind a failure mode the authors call 'shifted initialization cascade'—entropy minimization lumps disentangled representation fragments (the individually encoded pieces of a code sample) without considering their relationships, so a bad initialization drags the solution down. The paper then proposes URECA, a union-find clustering algorithm that initializes clusters from fragments, transports fragments between clusters using logits and attention-based dynamics, and adds an auxiliary loss that encodes the estimated fragment relationships. If the analysis holds, URECA should give consistent few-shot adaptation gains across task, query, and code shifts, and the authors report state-of-the-art results on CoSQA under query shift. The reason to care: it turns an opaque training heuristic into a structural claim about what entropy minimization is doing, and offers a repair that is cheap enough for every training iteration.

What carries the argument

The central objects are two nested instances of the minimum set cover problem (choose the cheapest collection of sets whose union covers a given universe), and the load-bearing identity is the Lebesgue-integral rewriting $\ln \frac{1}{p(E_\alpha)} = \int p(E_\alpha)\,d\left(\frac{1}{p(E_\alpha)}\right)$, which the paper converts into a supremum over greedy choices that it identifies with the cost of those two set covers; the predecessor problem covers the universe of fragment events, and the successor problem covers the resulting collection of subsets, with weak duality binding the expected cover cost to entropy. The second mechanism is URECA's transport update, a simulation trick in which clusters are treated as measurable sets, so moving a fragment from source to target is simulated by subtracting its logit weight from one cluster and adding it to another, with the dynamics $p(C_{i,i}^{t+1} \mid C_{j,j}^t)$ estimated by attention scores between queries. The Thresholdly-Updatable Stationary Assumption—stationary dynamics until a threshold, then zeroing for clusters judged disjoint by divergence—is what turns the naive replacement of probabilities by logits into an unbiased transport in the limit.

What would settle it

Inspect the proof's base identity with a concrete finite distribution, say an event of probability $1/3$, and compute $\int p(E_\alpha)\,d(1/p(E_\alpha))$ in the standard Lebesgue sense used by the appendix; if the integral is undefined because $d(1/p)$ is not a measure, or if its value differs from $\ln 3$, Theorem 2.1 fails at its first equation.

Watch

Extended reading notes

Core claim

On the paper's own terms, the central discovery is Theorem 2.1: the minimum entropy problem is dual to a chain of two minimum set cover problems with a greedy algorithm, with the duality established through Lebesgue integration. The first, predecessor set cover builds the universe of the second, successor set cover out of disentangled representation fragments, and the second then constructs clusters; Theorem 2.2 states that minimum entropy clustering is exactly the process that clusters these fragments to minimize expected clustering cost. Because the greedy decisions are based only on summed probabilities of fragments, the mechanism ignores relationships between fragments, and the paper identifies this ignorance as the cause of shifted initialization cascade. URECA is the constructive claim: by tracking clusters as transportable sets of fragments, using attention scores as stationary dynamics and logits as evidence weights, it moves fragments from dying clusters to surviving ones under a Thresholdly-Updatable Stationary Assumption, which makes the transported logits an unbiased estimator of the transported probabilities. The paper's claim is that this restores the relationships entropy minimization drops and produces robust few-shot adaptation to shifts.

Load-bearing premise

The load-bearing premise is the first identity of Theorem 2.1, $\ln(1/p(E_\alpha)) = \int p(E_\alpha)\,d(1/p(E_\alpha))$; if the reciprocal probability $1/p$ is not a genuine measure, the Lebesgue-integral step collapses and with it the claimed chain of two minimum set cover problems, even if URECA still works in practice.

Editorial extensions

If this is right

  • According to the paper, entropy minimization—and InfoNCE as its contrastive analogue—is a greedy clusterer that ignores fragment-level relationships, so any model fine-tuned with it inherits the shifted initialization cascade when distributions move.
  • URECA's cluster transport can be added as an auxiliary loss on top of existing contrastive code-search losses, so the gains do not require retraining the underlying code model from scratch.
  • In the reported experiments, URECA improves few-shot adaptation consistently across task shift, query shift, and code shift, with the largest margins in the harshest low-resource settings.
  • The state-of-the-art CoSQA result under query shift indicates that relationship-aware clustering, not just sample-level contrastive learning, is what matters for realistic web-query code search.
  • Because URECA estimates dynamics from attention scores, the paper's own comparison with CoCoSoDA suggests that the size of the gains is tied to how accurately the base model already estimates those dynamics.

Reading between the lines

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

  • If the two-set-cover decomposition is taken seriously, it generalizes beyond code search: every entropy-minimization adaptation method, such as test-time adaptation or semi-supervised learning, could be audited for which fragment relationships it drops, and URECA-style transport is a candidate repair that the paper gestures at but does not test.
  • A direct test of the paper's mechanism would be to compare URECA's cluster assignments against ground-truth functional modules of code; the cascade explanation predicts that URECA's advantage over InfoNCE should grow as the clusters align with true semantic modules.
  • The theorem's mathematical core is not needed for the algorithm's empirical value: URECA's transport update could be evaluated as a standalone clustering regularizer, and if it works while the Lebesgue identity fails, the explanation would still need revising even though the method survives.
  • The hard threshold in the Thresholdly-Updatable Stationary Assumption is a convenience rather than a fundamental requirement; learned or calibrated dynamics could replace it, and the paper's own framing suggests that would be the natural next step.
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 / 6 minor

Summary. The paper analyzes the minimum entropy formulation of adaptation to distribution shift in semantic code search. It claims that via a Lebesgue-integral decomposition, the minimum entropy problem is dual to a chain of two minimum set cover problems (Theorem 2.1) and that this chain reveals why entropy minimization ignores relationships among disentangled representations, leading to a 'shifted initialization cascade.' Based on this analysis, the paper proposes URECA, a union-find based recursive clustering algorithm that transports 'evidences' (logits) between clusters under a 'Thresholdly-Updatable Stationary Assumption,' and reports few-shot adaptation experiments on CodeSearchNet and CoSQA with CodeT5+, UniXCoder, and CoCoSoDA, claiming consistent gains and state-of-the-art performance on CoSQA.

Significance. If the theoretical results were valid, the paper would offer a novel bridge between information-theoretic entropy minimization and combinatorial set cover, with a practical clustering method for adapting code search models to distribution shifts. The experimental task is timely, and the empirical comparisons against InfoNCE on several backbones are a useful starting point. However, the paper does not release code (the provided repository is a placeholder), and the central theoretical claim rests on a flawed integral identity and a circular convergence theorem. The experimental tables also contain internal inconsistencies. Consequently, the claimed explanatory value of the 'chain of two minimum set cover problems' and the 'shifted initialization cascade' is not established, and the paper's significance is currently limited to a heuristic clustering rule whose motivation is unsupported.

major comments (4)
  1. [Section 2, Eq. (2.1); Appendix D.1] The foundational identity in Eq. (2.1), ln(1/p(Eα)) = ∫ p(Eα) d(1/p(Eα)), is not a valid integral identity. For p(Eα)=1/2, the left-hand side is ln 2 ≈ 0.693, while the right-hand side, as the proof in Appendix D.1 interprets it via Eq. (D.7), equals the supremum of Σ_{n=1}^{⌈1/p(Eα)⌉} p(Eα)·1, which evaluates to 1. The function 1/p cannot be used as an integration measure in this way, and the subsequent identification in Eqs. (2.2)-(2.3) of this supremum with the cost of a minimum set cover problem has no basis. Since Theorem 2.1 is the only bridge from entropy minimization to the chain of two minimum set cover problems, the shifted-initialization-cascade explanation and the theoretical motivation for URECA do not follow from the presented mathematics.
  2. [Appendix D.1] The extension from dyadic probabilities p(e)=2^{-k} to arbitrary real probabilities is not established. The text asserts that every real function can be approximated by simple functions with values a/2^n, but this does not imply that the supremum in Eq. (D.7) equals ln(1/p(Eα)), nor that the inequality c_Eα ≤ ln(1/p(Eα)) in Eq. (D.15) survives the limiting argument. The base-case identity is itself false, as noted above, so the approximate extension cannot rescue the claim.
  3. [Section 3.3, Theorem 3.1; Appendix D.4] Theorem 3.1 is circular. The assumption that p(C^t_j,j) converges to 1/|J| already implies, by continuity of the logarithm on the positive reals, that the logits ln(p(C^t_j,j)/p(y)) converge uniformly to each other; the additional Lipschitz condition with constant α·ln((1/|J|+ϵ)/(1/|J|-ϵ)) and α ∈ [0, (1/|J|-ϵ)/(1/|J|+ϵ)) does not constrain the actual function and is not satisfied by any nontrivial family of functions independent of α. Moreover, the proof of Lemma D.1 in Appendix D.4 claims that δ = ln((1/|J|+ϵ)/(1/|J|-ϵ)) can be an arbitrary positive real, but for fixed ϵ it is a specific value; the argument therefore does not establish the uniform Cauchy property. Consequently, the unbiasedness guarantee claimed in Section 3.2 for the logit-based transport (Eq. (3.11)) is not proven.
  4. [Section 4.1, Table 1] Table 1 contains an internal inconsistency in the UniXCoder row at 120 few-shot examples: URECA is reported as 45.1 with a gain of +2.3 over InfoNCE 51.8, but 45.1-51.8 = -6.7. This contradicts the claim in Section 4.1 of 'consistent performance gains' over InfoNCE. Additionally, the statement that URECA achieves state-of-the-art on CoSQA is not substantiated: Table 2 only compares URECA to InfoNCE on the same three backbones, with no comparison to any existing published SOTA systems on the CoSQA benchmark.
minor comments (6)
  1. [Section 4.1 and Appendix E.5] The text repeatedly refers to 'Appendix F.1∼F.4' and 'Appendix F.5', but the manuscript contains no Appendix F; the experimental details are in Appendix E. These dangling references should be corrected.
  2. [Section 4.2, Table 3] The caption 'InfoNCE/URECA(DIFF)' and the main-text sentence 'it is still significant even after 100 epochs for 59.1 % (InfoNCE) and 70.3% (URECA)' are inconsistent with the table entries (42/59.1 for CSN-Go at 120 few-shot examples); the reader cannot tell which number belongs to which method.
  3. [Appendix E.8] The code repository URL is a placeholder ('github_id/ureca'), so no implementation is available for reproducibility checks.
  4. [Throughout] The manuscript contains numerous typos and grammatical errors (e.g., 'Initializatoin', 'esitmates', 'Lebesuge', 'Jenson's Inequality', 'inf ty', 'mathbR'); these should be corrected before any revision.
  5. [Section 3 and Appendix D] The main text refers to Figures 1, 2, 5, 6, 7, and 8, but the figures are not all included in the provided manuscript; the descriptions in the text are insufficient to verify the claimed clustering construction.
  6. [Section 4] The tables report point estimates from three seeds without standard deviations, so no statistical significance can be assessed.

Circularity Check

3 steps flagged · score 8.0 of 10

The set-cover chain is constructed from a miscomputed 'Lebesgue' identity, Theorem 2.2 renames entropy as clustering, and Theorem 3.1 assumes the convergence it claims to establish.

  1. self definitional [Section 2, Eqs. (2.1)-(2.3); Appendix D.1, Eqs. (D.7)-(D.15)]
    "We can rewrite the integral form of equation (2.1) to supremum form of equation (2.2) based on the definition of Lebesgue integral for non-negative measure (Appendix B). With properties of probability as Lebesgue measure, this supremum form hints that self information becomes the tight upper bound for the cost of solution to the chain of minimum set cover problems equation (2.3)."

    Eq. (2.1) writes ln(1/p(Eα)) = ∫ p(Eα) d(1/p(Eα)), but 1/p is a function, not a measure; the claimed 'Lebesgue' supremum in Eq. (2.2) is Σ_{n=1}^{⌈1/p⌉} p(Eα)·1 = p(Eα)·⌈1/p(Eα)⌉ ≈ 1, not ln(1/p(Eα)). For p(Eα)=1/2 the sum is 1 while ln 2 ≈ 0.693. The proof then defines the universe Uα as the collection of ⌈1/p(Eα)⌉ set-cover minimizers u* = arg min ∫ s(e)dχ(e∈u), so the 'cost of the minimum set cover problem' is by construction the same sum as in Eq. (2.2), and the asserted bound c_Eα ≤ ln(1/p(Eα)) in (D.15) is not derived and fails numerically. The chain of two set-cover problems is manufactured to match the computed sum rather than derived from entropy minimization.

  2. renaming known result [Section 2, Theorem 2.2; Appendix D.2-D.3]
    "Minimum entropy problem is equivalent to the problem which clusters the disentangled representations to minimize the expected cost of clustering given the probabilities for each event."

    Entropy is already the expectation of self-information. The proof constructs 'clusters' by selecting one element from the successor set-cover solution for each event and then calls the resulting family 'clusters of disentangled representation by the definition of clustering (Definition D.1)'. The equivalence is therefore true by construction: the clustering cost is defined as the same p ln(1/p) sum that defines entropy, and the clusters are exactly the selected set-cover elements. This restates entropy as a clustering objective rather than providing an independent derivation that minimum entropy forces a particular clustering.

1 more flagged steps
  1. self definitional [Section 3.3, Theorem 3.1; Appendix D.4, Lemma D.1]
    "If the UP-Limit of pt(Ctj,j) converges to 1/|J| and ln pt(Ctj,j)/p(y) is α · ln((1/|J|+ϵ)/(1/|J|-ϵ))-Lipschitz continuous ..., then ln pt(Ctj,j)/p(y) converges uniformly to each other as t → ∞."

    The conclusion is a direct restatement of the assumption: if p_t(C^t_j,j) → 1/|J| for all j, then the logits ln(p_t(C^t_j,j)/p(y)) automatically converge uniformly to the common limit ln(1/(|J|·p(y))). Lemma D.1 only re-derives bounds on evid differences from the assumed p-bounds; no property of the URECA update rule is used. The paper then invokes this theorem to claim that transported logits are unbiased and that the estimation error disappears as update proceeds, but the required uniform convergence is assumed, not produced. The paper later states 'We naively assume that the no negative divergences come from the convergence of the joint probability distribution p(Ctj,j) to uniform distribution as 1/|K|', confirming that the load-bearing convergence is an input rather than an output.

full rationale

Most of the paper's theoretical contribution is not independently derived. Theorem 2.1 rests on Eq. (2.1), which treats the function 1/p as a Lebesgue measure; the resulting supremum in Eq. (2.2) evaluates to p·⌈1/p⌉ ≈ 1, not ln(1/p). The set-cover universe is then defined as the collection of ⌈1/p⌉ minimizers, so the 'cost of the chain of two minimum set cover problems' is identical to the sum in Eq. (2.2) by construction, and the bound c_Eα ≤ ln(1/p) in (D.15) is asserted without proof and fails numerically. Theorem 2.2 then renames the entropy expectation as 'expected cost of clustering' and calls the selected set-cover elements clusters by Definition D.1, so the claimed equivalence is a restatement rather than a derivation. Theorem 3.1 assumes p(C^t_j,j) → 1/|J| and concludes the logits converge uniformly; since logits are monotone functions of the p's, the conclusion follows immediately from the assumption, and the paper later admits the convergence of p to uniform is 'naively assumed.' Thus the chain-of-set-cover explanation, the clustering equivalence, and the uniform-convergence guarantee for URECA's transport each reduce to definitions or assumptions. The empirical comparisons to InfoNCE are genuine experiments and may support URECA as a heuristic, but they do not rescue the theoretical derivation from being circular-by-construction. No load-bearing self-citation chain was found; the circularity is internal to the paper's own equations and assumptions.

Assumptions & free parameters 2 free parameters · 5 assumptions · 2 invented entities

The central claim relies on treating 1/p as a measure, approximating arbitrary probabilities by dyadic simple functions, equating query attention with cluster dynamics, assuming stationary or threshold-bounded transition probabilities, and assuming equal-probability cluster selection. None of these are derived from data or established theory; they are introduced to make the set-cover/clustering story work.

free parameters (2)
  • Threshold T in Thresholdly-Updatable Stationary Assumption = not reported
    Controls how many update steps keep dynamics stationary before probabilities are zeroed; Section 3.3 gives no value or fitting procedure for T.
  • max_recursion_num = not reported
    Recursion depth of URECA in Algorithm 1; no value or stopping criterion is given beyond 'until transport is not possible'.
assumptions (5)
  • ad hoc to paper 1/p(Eα) is an integration measure so that ln(1/p) = ∫ p d(1/p).
    Used in Section 2 Eq. (2.1) and Appendix D.1; 1/p is a function, not a measure, so the integral is not a standard Lebesgue integral.
  • domain assumption Every real probability can be exactly represented by dyadic simple functions in a way that preserves the greedy set-cover cost bound.
    Appendix D.1 extends the dyadic base case to general probabilities by 'simple function approximation' but gives no convergence argument.
  • domain assumption Query q_i is the centroid of cluster C_i,j for all j, so cluster dynamics equal query attention p(q_i|q_j).
    Section 3.2 Eq. (3.9) equates cluster transport with query-query attention, a strong modeling leap with no empirical validation.
  • domain assumption The conditional probability dynamics are stationary for all time steps and only become zero after a threshold.
    Section 3.2 Eq. (3.8) and Section 3.3 introduce the Stationary Assumption and its threshold-bounded release; stationarity is asserted, not tested.
  • ad hoc to paper All elements in the solution of the successor set-cover have equal probability, so weighted self-information selects exactly one cluster per event.
    Appendix D.2 'Combination' step requires this equality and an implicit disjointness assumption to convert set-cover solutions into clusters.
invented entities (2)
  • disentangled representations / fragments (evidence)
    purpose: Postulated atomic units of code and query encodings that URECA clusters and transports; the central object of the analysis and the auxiliary loss.
    No definition, detection method, or independent measurement is provided; the paper asserts that forward propagation and dot product 'do the fragmentization' without evidence.
  • shifted initialization cascade phenomenon
    purpose: Explains why entropy minimization fails under poor initialization and motivates URECA.
    Introduced in the abstract and Section 2; supported only by a hypothetical example and seed-level observations, not by a formal definition or controlled measurement.

how reviews work

0 comments
Cite this review

Pith. "Pith review of URECA: The Chain of Two Minimum Set Cover Problems exists behind Adaptation to Shifts in Semantic Code Search." pith.science (2026). https://pith.science/paper/WCFLNVJF

@misc{pith2026250207494,
  author       = {Pith},
  title        = {Pith review of: URECA: The Chain of Two Minimum Set Cover Problems exists behind Adaptation to Shifts in Semantic Code Search},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/WCFLNVJF}},
  note         = {Machine review of arXiv:2502.07494}
}
read the original abstract

Adaptation is to make model learn the patterns shifted from the training distribution. In general, this adaptation is formulated as the minimum entropy problem. However, the minimum entropy problem has inherent limitation -- shifted initialization cascade phenomenon. We extend the relationship between the minimum entropy problem and the minimum set cover problem via Lebesgue integral. This extension reveals that internal mechanism of the minimum entropy problem ignores the relationship between disentangled representations, which leads to shifted initialization cascade. From the analysis, we introduce a new clustering algorithm, Union-find based Recursive Clustering Algorithm~(URECA). URECA is an efficient clustering algorithm for the leverage of the relationships between disentangled representations. The update rule of URECA depends on Thresholdly-Updatable Stationary Assumption to dynamics as a released version of Stationary Assumption. This assumption helps URECA to transport disentangled representations with no errors based on the relationships between disentangled representations. URECA also utilize simulation trick to efficiently cluster disentangled representations. The wide range of evaluations show that URECA achieves consistent performance gains for the few-shot adaptation to diverse types of shifts along with advancement to State-of-The-Art performance in CoSQA in the scenario of query shift.

Figures

Figures reproduced from arXiv: 2502.07494 by the authors.

Figure 1
Figure 1. Hypothetical Example of Real World Scenario in Figure 2. URECA simulates Real World [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Overview of URECA its position from (1, 2, 3) to (4, 5, 6) with the addition of 3 for each element of (1, 2, 3) [PITH_FULL_IMAGE:figures/full_fig_p007_2.png] view at source ↗
Figure 3
Figure 3. Shifted initialization cascade for CSN-Go and CSN-PHP [PITH_FULL_IMAGE:figures/full_fig_p013_3.png] view at source ↗
Figures from the paper (5 more)
Figure 4
Figure 4. Figure 4: Efficiency of Simulation Trick results demonstrate that URECA mitigates the negative effects of shifted initialization with reflection on the relationships between disentangled representations. Average performance (11.4 %) in CSN￾PHP on [PITH_FULL_IMAGE:figures/full_f…
Figure 5
Figure 5. Figure 5: Clustering behind Minimum Entropy Problem for a [PITH_FULL_IMAGE:figures/full_fig_p029_5.png]
Figure 6
Figure 6. Figure 6: Clustering behind Minimum Entropy Problem for b [PITH_FULL_IMAGE:figures/full_fig_p029_6.png]
Figure 7
Figure 7. Figure 7: Clustering behind Minimum Entropy Problem for c [PITH_FULL_IMAGE:figures/full_fig_p030_7.png]
Figure 8
Figure 8. Figure 8: Cluster Selection for a, b and c 30 [PITH_FULL_IMAGE:figures/full_fig_p030_8.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

45 extracted references · 34 canonical work pages

  1. [1]

    J., Mao, Y., and Ren, X

    Arakelyan, S., Das, R. J., Mao, Y., and Ren, X. Exploring distributional shifts in large language models for code analysis. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, EMNLP 2023, Singapore, December 6-10, 2023 , pp.\ 16298--16314, 2023

    work page 2023

  2. [2]

    L ipschitz continuity in model-based reinforcement learning

    Asadi, K., Misra, D., and Littman, M. L ipschitz continuity in model-based reinforcement learning. In Dy, J. and Krause, A. (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp.\ 264--273. PMLR, 10--15 Jul 2018. URL https://proceedings.mlr.press/v80/asadi18a.html

    work page 2018

  3. [3]

    D., Dhariwal, P., Neelakantan, A., Shyam, P., Sastry, G., Askell, A., et al

    Brown, T., Mann, B., Ryder, N., Subbiah, M., Kaplan, J. D., Dhariwal, P., Neelakantan, A., Shyam, P., Sastry, G., Askell, A., et al. Language models are few-shot learners. Advances in neural information processing systems, 33: 0 1877--1901, 2020

    1901

  4. [4]

    When deep learning met code search

    Cambronero, J., Li, H., Kim, S., Sen, K., and Chandra, S. When deep learning met code search. In Proceedings of the ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering, ESEC/SIGSOFT FSE , pp.\ 964--974, 2019

    work page 2019

  5. [5]

    Minimum entropy combinatorial optimization problems

    Cardinal, J., Fiorini, S., and Joret, G. Minimum entropy combinatorial optimization problems. Theory of Computing Systems, 51: 0 4--21, 2012

    work page 2012

  6. [6]

    In-context sharpness as alerts: An inner representation perspective for hallucination mitigation

    Chen, S., Xiong, M., Liu, J., Wu, Z., Xiao, T., Gao, S., and He, J. In-context sharpness as alerts: An inner representation perspective for hallucination mitigation. In Salakhutdinov, R., Kolter, Z., Heller, K., Weller, A., Oliver, N., Scarlett, J., and Berkenkamp, F. (eds.), Proceedings of the 41st International Conference on Machine Learning, volume 235...

    work page 2024

  7. [7]

    Infogan: Interpretable representation learning by information maximizing generative adversarial nets

    Chen, X., Duan, Y., Houthooft, R., Schulman, J., Sutskever, I., and Abbeel, P. Infogan: Interpretable representation learning by information maximizing generative adversarial nets. Advances in neural information processing systems, 29, 2016

    2016

  8. [8]

    Denton, E. L. Unsupervised learning of disentangled representations from video. Advances in neural information processing systems, 30, 2017

    work page 2017

Show all 45 references
  1. [9]

    Codebert: A pre-trained model for programming and natural languages

    Feng, Z., Guo, D., Tang, D., Duan, N., Feng, X., Gong, M., Shou, L., Qin, B., Liu, T., Jiang, D., and Zhou, M. Codebert: A pre-trained model for programming and natural languages. In Findings of the Association for Computational Linguistics: EMNLP , pp.\ 1536--1547, 2020

    2020

  2. [10]

    and Bengio, Y

    Grandvalet, Y. and Bengio, Y. Semi-supervised learning by entropy minimization. Advances in neural information processing systems, 17, 2004

    2004

  3. [11]

    Greiff, W. R. The use of Exploratory Data Analysis in Information Retrieval Research, pp.\ 37--72. Springer US, Boston, MA, 2000. doi:10.1007/0-306-47019-5_2. URL https://doi.org/10.1007/0-306-47019-5_2

    doi

  4. [12]

    Deep code search

    Gu, X., Zhang, H., and Kim, S. Deep code search. In Proceedings of the 40th International Conference on Software Engineering, ICSE , pp.\ 933--944, 2018

    2018

  5. [13]

    K., Clement, C

    Guo, D., Ren, S., Lu, S., Feng, Z., Tang, D., Liu, S., Zhou, L., Duan, N., Svyatkovskiy, A., Fu, S., Tufano, M., Deng, S. K., Clement, C. B., Drain, D., Sundaresan, N., Yin, J., Jiang, D., and Zhou, M. GraphCodeBERT : Pre-training code representations with data flow. In 9th In...

    2021

  6. [14]

    UniXcoder : Unified cross-modal pre-training for code representation

    Guo, D., Lu, S., Duan, N., Wang, Y., Zhou, M., and Yin, J. UniXcoder : Unified cross-modal pre-training for code representation. In Proceedings of the 60th Annual Meeting of the Association for Computational Linguistics, ACL , pp.\ 7212--7225, 2022

    2022

  7. [15]

    and Gilbert, S

    Halim, S. and Gilbert, S. Min-set-cover, August 2016

    2016

  8. [16]

    and Karp, R

    Halperin, E. and Karp, R. M. The minimum-entropy set cover problem. Theoretical Computer Science, 348: 0 240--250, 2005

    2005

  9. [17]

    CoSQA : 20, 000+ web queries for code search and question answering

    Huang, J., Tang, D., Shou, L., Gong, M., Xu, K., Jiang, D., Zhou, M., and Duan, N. CoSQA : 20, 000+ web queries for code search and question answering. In Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th International Joint C...

    2021

  10. [18]

    A survey on hallucination in large language models: Principles, taxonomy, challenges, and open questions

    Huang, L., Yu, W., Ma, W., Zhong, W., Feng, Z., Wang, H., Chen, Q., Peng, W., Feng, X., Qin, B., and Liu, T. A survey on hallucination in large language models: Principles, taxonomy, challenges, and open questions. ACM Trans. Inf. Syst., 43 0 (2), January 2025. ISSN 1046-8188....

    2025 doi

  11. [19]

    CodeSearchNet Challenge : Evaluating the state of semantic code search

    Husain, H., Wu, H., Gazit, T., Allamanis, M., and Brockschmidt, M. CodeSearchNet Challenge : Evaluating the state of semantic code search. ArXiV CoRR, 1909.09436, 2019

    1909 arXiv

  12. [20]

    Ib-gan: Disentangled representation learning with information bottleneck generative adversarial networks

    Jeon, I., Lee, W., Pyeon, M., and Kim, G. Ib-gan: Disentangled representation learning with information bottleneck generative adversarial networks. In Proceedings of the AAAI conference on artificial intelligence, volume 35, pp.\ 7926--7934, 2021

    2021

  13. [21]

    and Yoon, H

    Kwon, S. and Yoon, H. Lebesgue integral theory, 2012

    2012

  14. [22]

    Entropy is not enough for test-time adaptation: From the perspective of disentangled factors

    Lee, J., Jung, D., Lee, S., Park, J., Shin, J., Hwang, U., and Yoon, S. Entropy is not enough for test-time adaptation: From the perspective of disentangled factors. In The Twelfth International Conference on Learning Representations, ICLR , 2024

    2024

  15. [23]

    u ttler, H., Lewis, M., Yih, W.-t., Rockt \

    Lewis, P., Perez, E., Piktus, A., Petroni, F., Karpukhin, V., Goyal, N., K \"u ttler, H., Lewis, M., Yih, W.-t., Rockt \"a schel, T., et al. Retrieval-augmented generation for knowledge-intensive nlp tasks. Advances in Neural Information Processing Systems, 33: 0 9459--9474, 2020

    2020

  16. [24]

    Rethinking negative pairs in code search

    Li, H., Zhou, X., Luu, A., and Miao, C. Rethinking negative pairs in code search. In Bouamor, H., Pino, J., and Bali, K. (eds.), Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, pp.\ 12760--12774, Singapore, December 2023. Association for...

    2023 doi

  17. [25]

    Rewriting the code: A simple method for large language model augmented code search

    Li, H., Zhou, X., and Shen, Z. Rewriting the code: A simple method for large language model augmented code search. In Ku, L.-W., Martins, A., and Srikumar, V. (eds.), Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers...

    2024 doi

  18. [26]

    K., Fanti, G., and Oh, S

    Lin, Z., Thekumparampil, K. K., Fanti, G., and Oh, S. Infogan-cr: Disentangling generative adversarial networks with contrastive regularizers. arXiv preprint arXiv:1906.06034, pp.\ 60, 2019

    1906 arXiv

  19. [27]

    Activity image-to-video retrieval by disentangling appearance and motion

    Liu, L., Li, J., Niu, L., Xu, R., and Zhang, L. Activity image-to-video retrieval by disentangling appearance and motion. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 35, pp.\ 2145--2153, 2021

    2021

  20. [28]

    Madhulatha, T. S. An overview on clustering methods. arXiv preprint arXiv:1205.1117, 2012

    2012 arXiv

  21. [29]

    Cross-entropy loss functions: Theoretical analysis and applications

    Mao, A., Mohri, M., and Zhong, Y. Cross-entropy loss functions: Theoretical analysis and applications. In International conference on Machine learning, pp.\ 23803--23828. PMLR, 2023

    2023

  22. [30]

    RAGT ruth: A hallucination corpus for developing trustworthy retrieval-augmented language models

    Niu, C., Wu, Y., Zhu, J., Xu, S., Shum, K., Zhong, R., Song, J., and Zhang, T. RAGT ruth: A hallucination corpus for developing trustworthy retrieval-augmented language models. In Ku, L.-W., Martins, A., and Srikumar, V. (eds.), Proceedings of the 62nd Annual Meeting of the As...

    2024 doi

  23. [31]

    Oord, A. v. d., Li, Y., and Vinyals, O. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018

    2018 arXiv

  24. [32]

    The entropy enigma: Success and failure of entropy minimization

    Press, O., Shwartz-Ziv, R., LeCun, Y., and Bethge, M. The entropy enigma: Success and failure of entropy minimization. In Salakhutdinov, R., Kolter, Z., Heller, K., Weller, A., Oliver, N., Scarlett, J., and Berkenkamp, F. (eds.), Proceedings of the 41st International Conferenc...

    2024

  25. [33]

    Shannon, C. E. A mathematical theory of communication. Bell System Technical Journal, 27: 0 379--423, 1948

    1948

  26. [34]

    Cocosoda: Effective contrastive learning for code search

    Shi, E., Wang, Y., Gu, W., Du, L., Zhang, H., Han, S., Zhang, D., and Sun, H. Cocosoda: Effective contrastive learning for code search. In Proceedings of the 45th International Conference on Software Engineering, ICSE '23, pp.\ 2198–2210. IEEE Press, 2023. ISBN 9781665457019. ...

  27. [35]

    Disentangled representation learning gan for pose-invariant face recognition

    Tran, L., Yin, X., and Liu, X. Disentangled representation learning gan for pose-invariant face recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp.\ 1415--1424, 2017

    2017

  28. [36]

    Tent: Fully test-time adaptation by entropy minimization

    Wang, D., Shelhamer, E., Liu, S., Olshausen, B., and Darrell, T. Tent: Fully test-time adaptation by entropy minimization. In International Conference on Learning Representations, 2021 a . URL https://openreview.net/forum?id=uXl3bZLkr3c

    2021

  29. [37]

    Disentangled representation learning

    Wang, X., Chen, H., Tang, S., Wu, Z., and Zhu, W. Disentangled representation learning. arXiv preprint arXiv:2211.11695, 2022

    2022 arXiv

  30. [38]

    R., and Hoi, S

    Wang, Y., Wang, W., Joty, S. R., and Hoi, S. C. H. CodeT5 : Identifier-aware unified pre-trained encoder-decoder models for code understanding and generation. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing, EMNLP , pp.\ 8696--8708, 2021 b

    2021

  31. [39]

    Wang, Y., Le, H., Gotmare, A., Bui, N. D. Q., Li, J., and Hoi, S. C. H. CodeT5+ : Open code large language models for code understanding and generation. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, EMNLP , pp.\ 1069--1088, 2023

    2023

  32. [40]

    Wiles, O., Gowal, S., Stimberg, F., Rebuffi, S., Ktena, I., Dvijotham, K., and Cemgil, A. T. A fine-grained analysis on distribution shift. In The Tenth International Conference on Learning Representations, ICLR , 2022

    2022

  33. [41]

    Dna-gan: Learning disentangled representations from multi-attribute images

    Xiao, T., Hong, J., and Ma, J. Dna-gan: Learning disentangled representations from multi-attribute images. arXiv preprint arXiv:1711.05415, 2017

    2017 arXiv

  34. [42]

    Learning to mine aligned code and natural language pairs from stack overflow

    Yin, P., Deng, B., Chen, E., Vasilescu, B., and Neubig, G. Learning to mine aligned code and natural language pairs from stack overflow. In Proceedings of the 15th international conference on mining software repositories, pp.\ 476--486, 2018

    2018

  35. [43]

    Disentangled code representation learning for multiple programming languages

    Zhang, J., Hong, H., Zhang, Y., Wan, Y., Liu, Y., and Sui, Y. Disentangled code representation learning for multiple programming languages. Findings of the Association for Computational Linguistics: ACL-IJCNLP 2021, 2021

    2021

  36. [44]

    F., Jiang, Z., and Neubig, G

    Zhou, S., Alon, U., Xu, F. F., Jiang, Z., and Neubig, G. Docprompting: Generating code by retrieving the docs. In The Eleventh International Conference on Learning Representations, ICLR , 2023

    2023

  37. [45]

    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 8, 2026 · model on record in the stance chip above.