acceptodds
Under review as a conference paper at ICLR 2027

Trust Your Targets: Is Target Propagation Block-Diagonal Gauss-Newton?

Abstract

Target propagation (TP) is a backpropagation alternative in which local targets carry the global learning signal. Prior works claim that TP performs Gauss-Newton (GN) optimisation on these targets, but the correspondence has only been established under unrealistic assumptions where hitting them exactly is trivial. Practical variants instead descend on a least-squares problem via a single gradient step. In this paper, we rederive TP from a trust region under an implicit, previously unexamined norm, and introduce CGTP (Conjugate Gradient Target Propagation), which uses conjugate gradients to solve the layer-local subproblems in parallel. A single adaptive parameter jointly controls this trust region and a matching bound on the weight update; KFAC emerges exactly as the special case where the per-sample Jacobians are approximated as identical, giving its factored damping a variational grounding. On MNIST and Fashion-MNIST MLPs, CGTP matches the accuracy of ADAM and KFAC, requiring 10x fewer backward-pass-equivalents than the former, while remaining stable across depth.

Primary area:
learning theory
Keywords:
target propagation, local learning, gauss newton, kfac, trust region

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_itk1OpenReview ↗
Rating
2(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

This paper revisits the connection between target propagation and Gauss-Newton optimization. It formulates TP as a trust-region problem, derives layer-local curvature-aware subproblems, and proposes CGTP, which solves them using conjugate gradients. The paper also shows that a batch-averaged approximation recovers a KFAC-like update. Experiments on MNIST and Fashion-MNIST MLPs suggest faster outer-iteration convergence than several TP baselines and competitive accuracy with Adam and KFAC.

Critical strengths
  • The trust-region interpretation of TP is interesting and provides a more principled view of local target fitting.
  • The connection between the proposed curvature-aware local solver and KFAC is conceptually useful.
Critical weaknesses
  • The paper substantially over-formalizes a relatively limited core idea. Many lemmas and theorems are standard consequences of constrained quadratic optimization, linear algebra, or majorization, and the conceptual contribution is much smaller than the theoretical presentation suggests.
  • The empirical validation is far too limited for the scope of the claims. Experiments are restricted to small MLPs on MNIST/Fashion-MNIST, with no evidence on CNNs, ResNets, CIFAR-scale tasks, or realistic layer-parallel training. Moreover, CGTP has a very high per-step computational cost, while the reported wall-clock advantage is negligible.
Questions for authors
  • Can the authors demonstrate the method on a modern architecture and a non-trivial dataset, e.g. ResNet on CIFAR-10/100 or larger?
  • What practical advantage does CGTP provide when comparing wall-clock time, FLOPs, and memory rather than outer iterations?
  • Can the authors clarify which theoretical results are genuinely new beyond standard KKT, trust-region, and majorization arguments?
  • Does the claimed layer-parallel advantage remain meaningful once the cost of the CG inner loop and Jacobian-vector products is included?
  • For the alternating minimization result, can the authors provide a complete convergence argument to the global minimum rather than only monotonic decrease and lower boundedness?
4 comments
AuthorsOpenReview ↗

Response to Reviewer itk1

We thank the reviewer for their considered review. For the Reviewer's question on modern architectures, we direct them to our response to all reviewers. Instead, we focus on the Reviewer's third question first, because it affects how the rest of the paper should be read.

Q3: Novelty We agree the individual tools (KKT conditions, trust regions, majorisation) are standard in optimisation toolkits. We emphasise that our contribution is not a new derivation of Gauss-Newton. It is an account of how an existing backpropagation alternative (TP) approximates Gauss-Newton, and the extent to which that approximation can be tightened.

Trust-region Gauss-Newton has a large design space, as one must choose an output norm, a trust-region metric across layers, how curvature is shared between layers, and the metric in which the weights realise the targets. Our first contribution is to locate classical TP in this space - namely, it is the low-trust limit under an egalitarian layer metric (Theorem 2, Remark 3), with targets realised by a single Euclidean gradient step (Remark 6). This gives us a more rigorous understanding of what TP's targets are, and therefore, when we should trust them by taking larger steps.

The other major contribution concerns the measurement of the step sizes, which ends up being a critical choice in fitting the targets. As soon as targets are not exactly realisable (which is any batch size above one) fitting them in the Euclidean metric (the natural extension of classical TP) is not a Gauss-Newton step. However, fitting them in the curvature metric is (Theorem 8). Our EucTP ablation demonstrates this gap.

The trust-region formalism also enables us to close another gap in the literature. Benzing (2022) observes the resemblance between KFAC and updates on neurons, and Ishikawa et al. (2025) note that the Gauss-Newton-target gradient is a special case of KFAC with preconditioning on the backward signals only. To the best of our knowledge, we are the first to make this correspondence exact, recovering the factored damping of KFAC (Theorem 10, Corollary 12), while exposing potential extensions (e.g. the adoption of non-uniform simplex schemes).

Q5: Convergence of alternating minimisation. The reviewer is correct: our original proof established only monotone decrease and convergence of the objective value. We have restated the claim: Theorem 9 now says that the alternating scheme minimises the regularised majoriser, not the subproblem itself. Lemma 23 (Supp. C.6) now proves that, from any interior starting point, the scheme decreases the majoriser monotonically and converges to its unique minimiser. The proof covers the case the original argument could not, namely, when the majoriser is not differentiable (ie where the α\alpha is zero), and the minimiser can lie there. In practice, since we only take a single α\alpha-step (Supp. D.3), our algorithm only needs the majorisation property.

Q2 / Q4: Cost of the inner loop. We have run a profile for each method on Fashion-MNIST at the hyperparameters used for Table 2 (Supp. D.2). Per step, CGTP uses about 1,000x the FLOPs of KFAC, at 100x the batch size (about 10x per sample processed). To the milestone it uses about 30x the total FLOPs of Adam and about 2.5x those of KFAC, with about 4x fewer epochs of data, and 6.67 synchronisation steps against 25,667 for Adam and 2,700 for KFAC. This extra compute per step is a setting, not a fixed overhead. The number of CG iters TT places known methods on one path: with T=0T = 0 the update is the Euclidean fit to the targets (EucTP); a single preconditioned step from zero is along the KFAC direction; and as TT grows the update converges to the exact layer-local Gauss-Newton step. CG decreases the layer-local model monotonically, so each iteration buys a tighter step. As a data point, halving the budget from 100 to 50 reaches the same milestone in the same number of outer iterations at about 60% of the FLOPs per step (see also Figure 6). We have added this interpolation as Remark 13.

We acknowledge that parallelism does not remove the CG cost. The solves are independent across layers but sequential within one, so it reduces their wall-clock time by at most a factor of the depth. Our implementation is sequential. Even so, on our hardware CGTP reaches the milestone in 26 s, against 86 s for Adam and 205 s for KFAC; this reflects the per-step overhead of the baselines at their small tuned batch sizes, and we do not claim it as a general speed advantage.

Reviewer_itk1OpenReview ↗

Remaining questions on theoretical derivations

Thank you for the detailed rebuttal and the additional cost analysis. I acknowledge that the revised convergence argument and computational profiling address some of my original concerns.

However, I have two remaining questions about the theoretical derivations:

In Theorem 2, Equation (17) introduces an additional factor of 1/(L+1)1/(L+1) in the expression involving Bℓ−1Jℓ⊤B_\ell^{-1}J_\ell^\top, which appears inconsistent with the egalitarian metric condition and Equation (49) in Appendix C.1. Could the authors clarify this discrepancy?

In Theorem 8, Equation (22) requires the inverse of ΠG~−1Π⊤\Pi\widetilde G^{-1}\Pi^\top, although Π\Pi is defined as an orthogonal projector and is generally rank-deficient. How is this inverse well-defined, given the full-row-rank assumption required by Lemma 16?

Clarifying these issues would materially affect my assessment of the paper's theoretical soundness.

AuthorsOpenReview ↗

Corrections to the derivations

We thank the reviewer for their thorough inspection. Both points are errors in our presentation, and we have corrected them in the revision. Neither affect the results.

Theorem 2, Equation 17. We apologise for this oversight, which is a remnant of a previous draft. The reviewer is correct: eq. 49 is the general form, and under the egalitarian condition it reduces to Δzn(ℓ)=−[Bn(ℓ)]−1Jn(ℓ)⊤r~n(λ)\Delta z_n^{(\ell)} = -[B_n^{(\ell)}]^{-1} J_n^{(\ell)\top} \tilde{r}_n(\lambda) The factor 1/(L+1)1/(L+1) is already contained in the metric Bn(ℓ)=(L+1)Jn(ℓ)⊤Jn(ℓ)B_n^{(\ell)} = (L+1) J_n^{(\ell)\top} J_n^{(\ell)} (eq. 51 and 52), which is the egalitarian norm that recovers classical TP; the earlier statement applied it twice. Theorem 2 now states the general form, followed by this choice.

Theorem 8, Equation 22. The reviewer is correct that the Schur complement ΠG~−1Π⊤\Pi \tilde{G}^{-1} \Pi^\top is not invertible, because Π\Pi is rank-deficient. The solution is to decompose Π=QQ⊤\Pi = QQ^\top, with QQ an orthonormal basis of the range of Π\Pi. The feasibility constraint is then equivalent to Q⊤ΔZ=0Q^\top \Delta Z = 0, and the standard result (Lemma 16) may be applied (since Q⊤Q^\top has full row rank). Supp. C.5 contains the updated derivation, and in the main text, eq 22 has been updated to use a pseudoinverse in place of the inverse. The solution itself is unchanged - our algorithm never needed the inverse, as we used conjugate gradients on the weights (which parameterise the null space of Π\Pi).

We hope this resolves your remaining concerns. We would happily clarify anything further.

Thank you for the clarifications and corrections.

I agree that both mathematical issues have been appropriately addressed, and I appreciate the authors' careful revisions. These corrections, together with the improved convergence argument, alleviate my main concerns about theoretical soundness.

However, I still have reservations about the practical significance of the method, particularly its substantial computational and memory overhead and the lack of validation on more realistic architectures.

Given the improvements in theoretical soundness, I am willing to raise my rating from 1to 2, while maintaining my concerns about the paper's overall significance and practical applicability.

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

This paper introduces CGTP, a target propagation method that uses conjugate gradients to solve layer-wise optimization subproblems in parallel. It provides a trust-region interpretation of target propagation and establishes a theoretical connection to KFAC. Experiments on MNIST and Fashion-MNIST demonstrate competitive accuracy with Adam and KFAC, using fewer backward-pass-equivalents than Adam.

This paper made three contributions: a rigorous derivation of TP under the trust-region framework, a conjugate gradient solver, and empirical validation. While the theoretical analysis seem solid, the theory part may be difficult to read, the implications remain unclear, and the empirical validation can be enhanced.

Critical strengths

The author relaxed many assumptions of the TP by the trust-region framework in terms of step size, loss function, layers and batch size. This involve a lot of math works. The experiments show that the proposed TP iterates less than Adam.

Critical weaknesses

This paper may unfortunately suffer from the limited readability, unclear implications and empirical investigation.

  1. It may be difficult to read the paper due to its technical aspects. Heavy jargon ("egalitarian norm-induced layer separation," "simplicial relaxations") with little intuition — a single worked example would help more than ten more theorems. Typos and mangled equations (lines 383–431) make it worse.

  2. Unclear implications of the assumption relaxations. The theory is derived for simple feedforward MLPs, and the paper never says which architectures the relaxations extend to. Realistic deep nets — CNNs with weight sharing, ResNets with skip connections, transformers with attention — break the neat per-sample Jacobian structure the analysis leans on, and the paper doesn't address whether the guarantees survive. Experiments only on 5-layer tanh MLPs, so the claim of a general framework is untested on the very architectures a practitioner would care about.

  3. Thin empirical validation. Only MNIST/Fashion-MNIST on 5-layer tanh MLPs — toy benchmarks that can't support a second-order speed claim. Large datasets such as Imagenet are missing to test scalability, efficiency and memory usages of the proposed methods.

Questions for authors

Given the concerns above — limited readability, unclear implications of the relaxations, and thin empirical validation — I'd like the authors to address:

Q1. Readability and key intuition. Could the authors add a minimal worked example (e.g., a 2-layer linear network) showing how the trust-region norm, the regularized target in Equation 17, and the CG solve play out concretely? It would also help to fix the mangled equations and typos (e.g., around lines 383–431) that currently obscure key derivations.

Q2. Scope of the relaxed assumptions. The theory is developed for simple feedforward MLPs, but the per-sample Jacobian structure and norm constructions seem fragile under weight sharing (CNNs), skip connections (ResNets), and attention (transformers). For which architecture classes do the relaxation guarantees in Sections 3–4 actually hold, and which break down? A brief statement of the architectural boundary conditions would clarify the "general framework" claim.

Q3. Scalability beyond toy benchmarks. All experiments are on MNIST/Fashion-MNIST with 5-layer tanh MLPs. Can the authors test on a larger dataset (e.g., CIFAR-10) with a realistic architecture (e.g., a ResNet) and report wall-clock time, peak memory, and per-iteration cost — not just backward-pass equivalents — to substantiate the efficiency claim? The current headline of "10× fewer backward-pass-equivalents" is hard to interpret when each outer CGTP iteration can run up to 201 CG steps.

3 comments
AuthorsOpenReview ↗

Response to Reviewer 7pZf

We thank the reviewer for their considered review. Our note to all reviewers sets out the scope of the paper. Here we answer their three questions directly.

Q1: Readability and Intuition. We have added a worked example (Figure 1 in Section 4, with details in Supp. F) on a two-layer scalar network with two samples. It follows Algorithm 1 through the targets, the feasibility constraint and the CG system, and compares the resulting update with a gradient step (GDTP), a Euclidean fit (EucTP) and KFAC. The figure shows the central point of the paper geometrically: every method picks a feasible update, but only the curvature-metric fit reaches the lowest level set of the model. We have also corrected the equations and typos around Theorem 10.

Q2: Scope of the Relaxed Assumptions. Sections 3 to 4.2 (the trust-region derivation, the decoupling theorem and the layer-separable majoriser) use only the Jacobians from each layer's pre-activations to the output. To this end, they hold for any differentiable feedforward architecture, including skip connections. What is specific to dense layers is the feasibility constraint of Lemma 5 and the resulting null-space CG operator. Under weight sharing the constraint remains linear in the weights, since convolutions may be expressed as linear operations on an expanded dataset of patches. We expect the batch-mean limit to correspond to convolutional KFAC, but we have not proved this. We have not analysed attention.

Q3: Scalability and Cost. Many of these concerns are addressed in our note to all Reviewers. Re the "201" claim specifically: this is one backward pass plus at most 100 CG iterations of one JVP and one VJP each, not 201 CG steps. We have profiled each method on Fashion-MNIST at the hyperparameters used for Table 2 (Supp. D.2). CGTP takes far fewer steps, but each costs more: it reaches the milestone in 6.67 synchronisation steps, against 25,667 for Adam and 2,700 for KFAC, using about 30x the total FLOPs of Adam and about 2.5x those of KFAC, about 31x the peak memory, and about 4x fewer epochs of data. In wall-clock time on our hardware it reaches the milestone in 26 s, against 86 s for Adam and 205 s for KFAC. This reflects the per-step overhead of the baselines at their small tuned batch sizes, and we do not claim it as a general speed advantage. At matched batch size CGTP reaches the milestone in 7 batches against 50 for Adam (Figure 2). We have reworded the abstract accordingly.

On scale: recent theoretical work on TP (Ishikawa et al., ICLR 2025) also tests its claims on Fashion-MNIST MLPs, and three of the TP baselines (TPRI, GDTP and EucTP) do not reach the milestone even in this setting. A CIFAR/ResNet study requires the convolutional extension described under Q2 and a matrix-free Jacobian pass. That engineering is worthwhile future work, but as a foundational result (what TP's targets are, and which single choice separates it from Gauss-Newton) we believe the paper stands on its own merits.

Reviewer_7pZfOpenReview ↗

Thank for the response

Thank you for the rebuttal and the revision. The worked example and corrected equations address my readability concern, the clarification of the architecture scope is helpful, and I appreciate the transparent cost profiling and the reworded efficiency claim. I maintain my rating.

AuthorsOpenReview ↗

Response to 7pZf

Thank you for taking the time to read the revision. We are glad the worked example, the scope clarification and the cost profiling address your three questions. Since these were the concerns raised in the review, could you tell us what keeps the paper below the acceptance threshold?

If it is a lingering concern about the scale of the experiments, our position is set out in the note to all reviewers: the contributions of this work are primarily theoretical. Even at the scale we examine, which matches that of recent ICLR papers on TP, the other TP methods either fail to match backpropagation or need an order of magnitude more iterations than ours. This challenges the conventional presentation of TP as approximate Gauss-Newton, which is the question our work investigates.

If it is something else, we would be glad to address it in the time remaining.

Reviewer_Vv2vOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
3(+1)
Read review
Paper summary

This paper provides an interesting extension to the target propagation (TP) family of methods. Particularly, it extends the theoretical connection between TP and Gauss-Newton with more realistic assumptions and a curvature-weighted norm. The resultant CGTP method shows promising compute savings w.r.t. standard KFAC, Adam and other baseline TP methods, which makes it a potentially useful optimiser alternative.

Critical strengths
  1. The trust region generalisation with curvature-weighted norm of TP is a meaningful extension to the existing literature.
  2. The proposed CGTP algorithm with adaptive weight decay, which demonstrates competitive performance against strong TP/non-TP baseline is an interesting algorithmic contribution.
Critical weaknesses
  1. The listed algorithm (algorithm 1, line 4 and 11) uses a different g_n and G_n formulation from the provided derivation in line 324 of the paper. The missing curvature term H in the applied algorithm weakens the theoretical contribution/motivation of the paper.
  2. The gain of CGTP from the TJML baseline is modest (TJML outperforms CGTP on MNIST), and the reported advantage in computational cost is hard to interpret. This weakens the algorithmic contribution of the proposed method.
  3. The authors do not provide code, which makes weakness 1 harder to resolve.
Questions for authors
  1. Please can the authors check the inconsistency in their derivation and algorithm (as mentioned in weakness 1) and provide a justification. This would change my view on the soundness and theoretical contribution of the paper.
  2. Can the authors provide stronger justification that CGTP is superior to TJML? A more detailed FLOPs comparison between CGTP and TJML, or more benchmark results, can be useful. This would change my view on the algorithmic contribution of the paper.
2 comments
AuthorsOpenReview ↗

Response to Reviewer Vv2v

We thank the reviewer for their considered review. We address their concerns as follows:

W1 / Q1: Algorithm versus derivation. The inconsistency is due to an omitted pre-processing step. Our implementation applies the metric once at the output, forming r~=M1/2r\tilde{r} = M^{1/2} r and J~=M1/2HJ\tilde{J} = M^{1/2} H J. It then computes g=J~⊤r~g = \tilde{J}^{\top} \tilde{r} and G=J~⊤J~G = \tilde{J}^{\top}\tilde{J}. Under the Newton norm M=H−1M = H^{-1} used in all experiments, these reduce to the true gradient J⊤rJ^{\top}r and the GGN block J⊤HJJ^{\top}HJ. The listing has been updated: the whitening is now Stages 2 and 3 of Algorithm 1 (Supp. E).

W3: Code. We have added a minimal implementation to the supplementary material (cgtp_minimal.py). It is a single file of under 200 lines that depends only on PyTorch, and it is CGTP restricted to the settings used in the paper: Newton norm, diagonal scalings, warm start, and unpreconditioned CG. It follows Algorithms 1–3 (Supp. E) line by line, with comments giving the corresponding line numbers. Running the file first checks that the whitened quantities reproduce the autograd gradient for every layer, which is the point raised in W1, and then trains a small network for ten outer iterations.

The full library will be released with the camera-ready version. It additionally contains an efficient Jacobian pass, the corresponding passes for each baseline, internal logging, and CUDA-graph compilation, none of which changes the algorithm but all of which make the code harder to read. We therefore chose to share the minimal version for review.

W2 / Q2: CGTP versus TJML. On MNIST the two are within noise (.018 ± .001 against .019 ± .001); on Fashion-MNIST CGTP is ahead (.109 against .114). TJML is a first-order method, computing targets using a Jacobian matching condition following the (Ernoult et al., 2022) strategy of learning backprop targets. The experiments test a prediction of our theory: fitting targets in the curvature metric gives Gauss-Newton-like convergence in outer steps. To that end the comparison we intend is in outer iterations (6.67 against 1468 on Fashion-MNIST), each of which is a global synchronisation step, with all CG work between them local to a layer. CGTP is not cheaper in compute: profiled at the settings of Table 2, TJML uses 674 MFLOP per step and 0.99 ± 0.49 TFLOP to the milestone, against 1.17 TFLOP per step and 7.77 ± 0.55 TFLOP for CGTP. We have reworded the abstract and expanded the compute benchmark so that the cost claim is not read as one about compute.

I thank the authors for their detailed response. The response addresses the soundness concern. While I appreciate the paper’s theoretical focus, I remain unconvinced that the theoretical contribution and the demonstrated performance against the baselines are sufficient to justify a positive recommendation.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Note to all reviewers

We thank all of the reviewers for their time. Before our individual replies, we want to address some common themes.

Scope. This is a theory paper. Target propagation (TP) is routinely motivated as approximate Gauss-Newton, but the correspondence is established only for invertible networks and a single datapoint; recent work (Ishikawa et al., ICLR 2025) notes that for general networks TP need not yield Gauss-Newton targets. We ask under which choices, within the design space of trust-region Gauss-Newton methods, classical TP is recovered. The answer shows what TP’s targets are, when they can be trusted with large steps, and the one choice that must change for TP to behave as Gauss-Newton: the target-space metric. The same framework yields KFAC’s factored damping as a limiting case.

Experiments. The motivation for TP is that it approximates Gauss-Newton, yet no existing TP method shows Gauss-Newton-like convergence even in the simplest setting: on MLPs, the strongest TP baseline (TJML) needs about 1,400 outer iterations to reach the milestone and three others (TPRI, GDTP and EucTP) do not reach it on either dataset, where CGTP needs 4 to 7 (Table 2). Our theory predicts this gap and attributes it to one choice, the metric in which targets are realised. The progression from classical TP (GDTP) to a Euclidean fit (EucTP) to CGTP changes only that choice and closes the gap. The experiments are therefore proof of concept by design, and their scale is consistent with recent theoretical work on local learning (Ishikawa et al., ICLR 2025; Innocenti et al., NeurIPS 2024).

On larger architectures. We make no claim about scalability. Because the gap already appears on MLPs, that is the right place to establish the result; extending a method is only justified once it works in the simplest case, and showing that is the contribution of this paper. Target inference needs only the Jacobians of the forward map, so it applies to any differentiable architecture; only the feasibility constraint (Lemma 5) and the conjugate-gradient (CG) operator are specific to dense layers. We expect both to carry over to convolutional layers but have not proved it, and we have not analysed attention. Scaling would further require a matrix-free treatment of the per-sample Jacobians and an analysis of the small-batch regime.

Why we count outer iterations. Predictive coding and other local algorithms need no global pass, but neighbouring layers exchange messages at every inference step. Classical TP needs a global pass for every weight update. CGTP makes one global Jacobian pass, and a forward pass for the trust-region test, after which all remaining work is done inside a layer, with no communication between layers. Thus outer iterations count global synchronisation steps. The inner iterations are not hidden: their cost is reported in Supp. D.2, and we are transparent that CGTP uses more total compute (on Fashion-MNIST, about 30x the FLOPs of Adam and about 2.5x those of KFAC). The claim is how rarely layers must synchronise to match backpropagation and KFAC in accuracy.

Our new revision incorporates several points of feedback (changes are highlighted for ease of review):

  • Several reviewers found the cost comparison hard to interpret, and on reflection we agree. We have updated the abstract and added more detail to the resource analysis (Supp D.2).
  • The original CG listing was included for completeness, and is a general CG solver. Adapting it to our use case requires pre-processing with the output Hessian HH, and this step was previously omitted. The updated listings (Algorithms 1 to 3, Supp. E) now match the derivation and the implementation.
  • We restate the convergence claim for the alternating minimisation scheme (Theorem 9) and replace its proof (Lemma 23, Supp. C.6).
  • We include a worked example on a two-layer scalar network (Figure 1 in Section 4, with details in Supp. F).
  • We have cleared up many typos, and addressed notation inconsistencies throughout.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.