d4-conf-aaai-2023-2057

· ? (d4-conf-aaai-2023-2057)

mirror foundnew result: P → P — proved & adversarially reviewed →
paperd4-conf-aaai-2023-2057
authors—
venue?
filed underunclassified
judged bygpt-6-luna / xhigh (triple__luna__xhigh__c6r1)
judge confidencehigh
authors would recognise ityes

The new result

P→P discrete result → its continuous mirror

Answer: \(\text{polynomial-time solvable}\) · discrete side: polynomial · adjudication: proved

full proof & adversarial review →

The anchor — algorithmic

Theorem 6

PDF text-layer excerpt — equations and symbol order may be approximateLet λ ≥0, and D = (dii′)i,i′∈N be an arbi- trary symmetric nonnegative matrix. Then argmin ¨ f X i,i′∈N:i̸=i′ ( ˆfi+ ˆfi′−dii′)2+λ∥¨f∥2 2 = 2(n −1)⃗π−8n(n−1) 4n+λ−4 ¯µ 2n + λ −4 . 2In the AWG model the equal-difficulty assumption is a nor- mative decision, since we can always scale the data. Essentially, it means that we measure errors in standard deviations, giving the same importance to all questions. 3We use ¨f instead of hat+arrow accent.

statement extracted from the paper’s text layer

Every anchor argued

The continuous mirror question

Given a finite set of complete worker-noise types \(\Theta\), positive rational masses \(\mu_t\) summing to one, and a symmetric rational matrix \(D\) of mean report distances between distinct agents of each type pair, compute a minimizer \(\hat f\) of \(\sum_{t,u\in\Theta}\mu_t\mu_u(\hat f_t+\hat f_u-D_{tu})^2\). For \(t=u\), \(D_{tt}\) is the mean distance between distinct agents of that type.

The model it lives in

A society with finite support \(\Theta\) over complete worker-noise types, rational type masses \(\mu_t>0\), and known type-pair mean distances \(D_{tu}\); choose one fault estimate \(\hat f_t\) per type to minimize \(\sum_{t,u\in\Theta}\mu_t\mu_u(\hat f_t+\hat f_u-D_{tu})^2\).

What the mirror covers

The mirror covers Theorem 6's fault-estimation objective and its use in the paper's proximity-based estimation pipeline; it leaves latent type recovery, empirical aggregation comparisons, and other truth-discovery models outside its scope.

Open questions for a prover

The case FOR (proponent)

The best positive case is a type-level version of the paper’s fault-estimation problem. It is a tractability case, not a hardness-dissolution case: the paper gives no named NP-hardness result to carry into a continuum.

My anchor is Theorem 6, proved in this paper. It gives an exact solution to a regularized least-squares problem: for a symmetric nonnegative pairwise-distance matrix \(D=(d_{ii'})\) on \(n\) workers and \(\lambda\ge 0\), it minimizes
\[ \sum_{i\ne i'}(\hat f_i+\hat f_{i'}-d_{ii'})^2+\lambda\|\hat{\mathbf f}\|_2^2. \]
Writing \(\pi_i=\frac{1}{n-1}\sum_{i'\ne i}d_{ii'}\) and \(\bar\mu=\frac{1}{2n}\sum_i\pi_i\), the minimizer is
\[ \hat{\mathbf f} = \frac{2(n-1)\boldsymbol\pi-\frac{8n(n-1)}{4n+\lambda-4}\bar\mu\,\mathbf 1} {2n+\lambda-4}. \]
The theorem does not label this problem “in P,” but its closed-form solution gives a polynomial-time algorithm for rational input. This is a genuine computational anchor: the paper computes the estimator, rather than merely proposing a formulation.

Here is the continuous problem I would put to a prover: Type-Aggregated Proximity Fault Recovery. The instance is a finite set \(\Theta\) of \(\tau\) worker types, rational masses \(\mu_t>0\) summing to one, and a symmetric rational matrix \(D\). A type is a complete report-noise law for the task; its fault is \(f_t=\mathbb E[d(s,z)\mid t]\). The entry \(D_{tu}\) is the mean distance between reports from two distinct workers of types \(t\) and \(u\); for \(t=u\), it is the within-type mean over distinct workers. The question is to output the type-fault estimates \(\hat f_t\) minimizing
\[ \sum_{t,u\in\Theta}\mu_t\mu_u \bigl(\hat f_t+\hat f_u-D_{tu}\bigr)^2. \]
The masses weight each type pair by its share of the population. Under the paper’s unbiased pairwise additive model, expected pairwise distance has the form \(f_t+f_u\), which is exactly the relation this estimator fits. In the continuum, same-type pairs are pairs of different agents; self-pairs have zero mass.

This is a plausible high-multiplicity regime for a large, repeated crowdsourcing task with relatively few stable worker cohorts—for example, cohorts with shared training or language profiles and hence a shared answer-noise law. There may be many workers but only \(\tau\) distinct types. That preserves the paper’s question—estimating competence from proximity to other workers—while replacing the finite worker vector with a type-level fault profile. The authors already define a proto-population distribution over worker types, so this population interpretation is close to their model.

I expect this continuous problem to be tractable. Its objective is a rational convex quadratic in \(\tau\) variables. Because every \(\mu_t\) is positive, the \(t=u\) terms contribute positive curvature in each coordinate, making the objective strictly convex. Solving its normal equations gives the unique minimizer in polynomial time in \(\tau\) and the input bit length \(L\). Theorem 6 supplies the finite-worker least-squares template; the mass-weighted system is its natural type-aggregated extension. This covers the paper’s fault estimation in Sections 3 and 4, and the fault estimates used by P-TD, not its empirical comparison of aggregation algorithms or every truth-discovery model.

The mirror’s weakest point is that this version takes the type partition and type-pair distance summaries as input. In the paper, worker types are latent and the algorithm works from individual reports. A reviewer could reasonably ask whether cohort labels are available, or whether estimating them is part of the real problem. My answer is that type-labelled cohorts are a plausible instance regime, and the mirror keeps the central proximity-based fault-recovery question. But this does not establish tractability when types are hidden, and it should not be sold as a complexity result already proved by the paper. The paper’s own proto-population distribution supports the modeling choice; it does not solve that latent-mixture question.

The case AGAINST (opponent, writing after the proponent)

Theorem 6 is a real computational anchor: it gives a closed-form algorithm for estimating worker faults from pairwise distances. The strongest objection is that the proposed continuous version changes what is being estimated and what data the algorithm receives. The theorem estimates one fault per observed worker from an individual distance matrix. The proposed problem estimates one fault per type from type labels and type-pair distance summaries supplied as input. That is a sensible type-level question, but it is not simply the theorem with \(n\) replaced by masses.

A closer mirror would leave types latent and ask for the distribution of fault levels from the observed reports or pairwise distances. That raises genuine issues: different mixtures of noise laws can produce the same distance summaries, and shared bias or correlated errors can confound proximity with competence. The paper itself flags these complications. But they do not rule out a useful mirror; they define a harder one. With stated symmetry or identifiability assumptions, recovering a population-level fault profile remains a coherent computational question.

Nor does the instance regime defeat the mirror. The paper explicitly samples workers from a proto-population of types, and its AWG example allows a continuum of variance levels. Exact finite cohorts may be an additional assumption, but crowdsourcing tasks with repeated worker classes are plausible, and under ChoCo’s definition a type can include the complete noise law. Existing type-distribution analysis supports that modeling choice; it does not already solve the computational problem for a continuous society.

So the objection weakens the proponent’s *particular formulation*: it assumes known types and distance summaries, and its result would not cover latent type recovery. It does not defeat the better mirror. I cannot make the universal negative case honestly: there is a plausible high-multiplicity regime, a computational result to mirror, and a type-level fault-recovery question the paper does not already answer continuously.

The adversarial triple: the proponent anchors on up to three named results; the opponent sees that case and must defeat every anchor; the judge decides which case convinced it. These are the pipeline’s own outputs, generated by tools/triple_run.py — no human edited them. The paper’s own text is not reproduced here beyond the quoted statement above.