Pith. sign in

REVIEW 3 major objections 4 minor 32 references

A Computational Model for Tensor Core Units

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

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

Pith's one-line read A single hardware primitive—multiplying a tall matrix by a small square one—suffices, under a new cost model, to derive fast algorithms for matrix multiplication, graph problems, the Fourier transform, and integer arithmetic on…

desk verdict A genuinely new formal model for tensor-core accelerators with a solid algorithm suite, but the headline latency bounds lean on an asymmetric streaming rule that the NVIDIA hardware doesn't provide. read the letter →

arxiv 1908.06649 v2 pith:HW7F4KDF submitted 2019-08-19 cs.DS cs.ARcs.DCcs.LG

Rezaul Chowdhury , Francesco Silvestri , Flavio Vella This is my paper · ORCID
classification cs.DScs.ARcs.DCcs.LG
keywords tensorcoreunitscomputationalmodelmatrixmultiplicationsystolicarrayexternalmemorydiscreteFouriertransformgraphalgorithmsinteger
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

This paper tries to establish that tensor-core accelerators can be understood, and programmed, as machines built around one primitive: a single instruction that multiplies a tall matrix by a small square matrix. To that end it defines the $(m,\ell)$-TCU model, with hardware parameters $m$ (the native size of the matrix circuit) and $\ell$ (the per-call latency), and claims that on this model dense $\sqrt{n}\times\sqrt{n}$ multiplication runs in $\Theta(n^{3/2}/m^{1/2} + (n/m)\ell)$ when only semiring operations are used. It then derives concrete bounds for Gaussian elimination, transitive closure, all-pairs shortest distances, the discrete Fourier transform, stencil computations, integer multiplication, and polynomial evaluation. If the model is an honest abstraction of real tensor-core hardware, these bounds are the first rigorous predictions for what such accelerators can do outside deep learning.

What carries the argument

The load-bearing mechanism is the asymmetric tensor-unit operation: a single call multiplies an $n\times\sqrt{m}$ matrix by a $\sqrt{m}\times\sqrt{m}$ matrix in time $O(n\sqrt{m}+\ell)$, because the small right matrix is loaded once and stays resident while the rows of the left matrix stream through the systolic array. This rule lets block algorithms pay the latency $\ell$ once per resident weight matrix instead of once per $\sqrt{m}$-row block, which is exactly what removes the extra latency term in dense multiplication, Gaussian elimination, transitive closure, and integer multiplication. The model parameters are $m$, the native product size, and $\ell$, the per-call setup cost; when fast recursive multiplication is used, $\omega_0$ is the exponent of the base case. The same machinery supports the external-memory link: each tensor call can be simulated with $O(m)$ I/Os in a memory of size $3m$.

What would settle it

Measure wall-clock time on a tensor-core accelerator for multiplying a fixed $\sqrt{m}\times\sqrt{m}$ weight matrix by a left matrix with $\sqrt{m}$ rows and then with $10\sqrt{m}$ rows, with precision held constant. The model predicts the second product takes about ten times the arithmetic plus one extra latency, so its average per-row cost is roughly constant; if every streamed block pays a fresh latency $\ell$, the term $(n/m)\ell$ will dominate and the measured time will be far above the model's prediction.

Watch

Extended reading notes

Core claim

The central claim is that a hardware circuit that natively multiplies $\sqrt{m}\times\sqrt{m}$ matrices can be abstracted as a standard RAM with one extra instruction, whose cost is $O(n\sqrt{m}+\ell)$ when the left factor is a tall $n\times\sqrt{m}$ matrix and the right factor is a resident $\sqrt{m}\times\sqrt{m}$ weight matrix. From that asymmetric cost rule the paper derives its headline bounds: dense multiplication in $\Theta(n^{3/2}/m^{1/2}+(n/m)\ell)$, Gaussian elimination in $\Theta(n^{3/2}/m^{1/2}+(n/m)\ell+n\sqrt{m})$, transitive closure in $\Theta(n^{3}/\sqrt{m}+(n^{2}/m)\ell+n^{2}\sqrt{m})$, all-pairs shortest distances in $O((n^{2}/m)^{\omega_{0}}(m+\ell)\log n)$, DFT in $O((n+\ell)\log_{m} n)$, and integer multiplication in $O(n^{2}/(\kappa^{2}\sqrt{m})+n\ell/(\kappa m))$ for the blocked method. The paper also shows that a weak tensor unit can simulate, and be lower-bounded by, the external memory model. These results are the paper's evidence that tensor cores are a general algorithmic primitive rather than a deep-learning-only circuit.

Load-bearing premise

The load-bearing premise is that on a real tensor unit the small square matrix on the right can stay resident while rows of the left matrix stream through, so multiplying an $n\times\sqrt{m}$ matrix by a $\sqrt{m}\times\sqrt{m}$ matrix costs $O(n\sqrt{m}+\ell)$ rather than $O((n/\sqrt{m})(m+\ell))$.

Editorial extensions

If this is right

  • Any fast recursive matrix multiplication with base-case exponent $\omega_0$ runs on the $(m,\ell)$-TCU in $O((n/m)^{\omega_0}(m+\ell))$, so fast matmul algorithms transfer directly to tensor hardware.
  • The semiring-only dense matmul bound $\Theta(n^{3/2}/m^{1/2}+(n/m)\ell)$ is optimal under the model, settling the cost of ordinary matmul on such a unit.
  • The DFT runs in $O((n+\ell)\log_m n)$, which makes tensor cores a near-linear-time Fourier engine when the latency is small.
  • Gaussian elimination and transitive closure both reach the same leading term as dense multiplication once the matrix is large relative to the tensor unit, tying these graph and linear algebra problems to matmul cost.
  • External-memory I/O lower bounds translate into lower bounds on any weak tensor unit, so known hardness results carry over to this hardware model.

Reading between the lines

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

  • The paper does not run timing experiments, but its asymmetric rule yields a direct test: with a fixed resident weight matrix, the cost of an $n\times\sqrt{m}$ product should grow roughly linearly in $n\sqrt{m}$ with a single added latency, so comparing one-block and many-block products isolates whether the latency term is paid once or per block.
  • The model's single-tensor-unit restriction means the stated bounds are best read as per-unit work; a multi-unit extension would most naturally keep these costs as a floor and add a throughput term, a direction the paper leaves open.
  • The external-memory translation suggests that cache-optimal algorithms designed for a memory of size $m$ could be ported to tensor cores by treating the resident weight matrix as the internal memory, giving a pragmatic route to tuned implementations.
  • Because the model assumes exact arithmetic on full-precision words, an obvious practical stress test is running the blocked integer multiplication at the precision limits of real half-precision units, where overflow behavior could change the constants in the stated bounds.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 4 minor

Summary. The paper proposes the (m,ℓ)-TCU model, a RAM equipped with a circuit that natively multiplies an n×√m matrix by a √m×√m matrix in time O(n√m+ℓ). Under this abstraction it designs and analyzes algorithms for dense and sparse matrix multiplication, Gaussian elimination, transitive closure, all-pairs shortest distances, the discrete Fourier transform, stencil computations, integer multiplication, and batch polynomial evaluation. It also gives a translation of external-memory lower bounds to a weak version of the TCU model. The central claim is that this is the first formal framework for reasoning about algorithms on tensor-core-like accelerators.

Significance. If the technical claims are correct, the paper provides a useful formal abstraction and a broad set of algorithmic upper bounds for matrix-multiply accelerators. The derivations are honest consequences of the model rather than empirical fits: the running times follow from the stated primitives, and the authors explicitly discuss the limitations of the model in Section 3.1. The paper also gives concrete pseudocode, which is a valuable contribution for practitioners trying to port algorithms to such hardware. The main weakness is that the most consequential modeling choice, the asymmetric streaming cost, is not satisfied by one of the two main commercial targets, and this is acknowledged in Section 2.2 but not fully reflected in the scope of the stated theorems.

major comments (3)
  1. [Section 3, item 3; Section 2.2] The load-bearing cost rule is the asymmetric streaming primitive: multiplying an n×√m matrix by a √m×√m matrix costs O(n√m+ℓ) because the right-hand weight matrix is assumed to remain resident in the unit while the left matrix streams through. This rule is what removes a factor of √m from the latency terms in Theorems 2, 4, 5, 6, 9, and 10. However, Section 2.2 explicitly states that in NVIDIA tensor cores matrix B does not reside in the local PE memories but is percolated through the array like matrix A. For such an implementation, re-feeding or re-percolating B for every chunk of rows of A changes the per-operation cost to (n/√m)(m+ℓ), so the latency term in those theorems would gain a factor of roughly √m. The model remains internally consistent, and the theorems remain valid as theorems about the (m,ℓ)-TCU, but the claim that the model captures the main commercial tensor-core targets needs to be restricted to designs with resident weight matrices, such as the Google TPU, or augmented with an explicit separate cost model for non-resident B.
  2. [Section 4.5, Theorem 7] The recurrence given in the proof of Theorem 7, T(n)=√m T(n/√m)+O(n+ℓ) with base case O(m+ℓ) for n≤m, does not solve to the stated O((n+ℓ)log_m n) unless ℓ is assumed to be a constant independent of n. Solving the recurrence as written gives T(n)=O(n log_m n + (n/m)ℓ), where the ℓ term comes from the base-case calls to the tensor unit with latency ℓ. If the authors intend to batch all subproblems at each recursive level into a single tall matrix multiplication so that the recurrence becomes T(n)=T(n/√m)+O(n+ℓ), they should state and prove that batching argument explicitly, because the recurrence in the proof is the standard multi-branch one. Since Lemma 1 and Theorem 8 inherit the DFT time bound, this issue is load-bearing for the stencil results as well.
  3. [Section 5, Theorem 12] The proof of Theorem 12 charges each weak-TCU matrix-multiplication call Θ(m) time and simulates it with O(m) I/Os, concluding that k calls require O(T_t) I/Os. This step requires the latency parameter to satisfy ℓ=O(m); otherwise the time of a call is Θ(m+ℓ), and kℓ can dominate km, so the simulated I/O cost k·O(m) is not O(T_t). The preamble notes that a constant-slowdown simulation of the original TCU model by the weak model holds when ℓ=O(m), but the theorem statement and proof should make this hypothesis explicit. Without it, the claimed translation of external-memory lower bounds is not established.
minor comments (4)
  1. [Theorem 1 proof] The recurrence is written with a base case for m≤n≤mn0, but the preceding text says the recursion stops when n≤m and the tensor unit handles the multiplication in O(m) time. Please make the base-case condition and the meaning of n in that range consistent.
  2. [Sections 4.1 and 4.3] The symbol n means the total number of matrix entries in Theorem 2 but the number of vertices in Theorems 5 and 6. The statement of Theorem 5 that the cost 'reduces to the optimal cost of multiplying two dense n×n matrices' is correct only after re-expressing Theorem 2 with N=n^2; this should be stated explicitly to avoid confusion.
  3. [Section 4.5] The text says the DFT algorithm generalizes an approach implemented on an 'NVIDIA Verdi architecture'; the NVIDIA architecture discussed elsewhere in the paper is Volta, so this appears to be a typo.
  4. [Section 5] The external-memory translation uses block length B=1 and memory size M=3m+O(1); the sentence 'product ... requires O(m) I/Os' should be made precise about which two operands and which output are being loaded and stored, since a careless reader could think only one input matrix is moved.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the running-time claims are analytic consequences of the (m, ℓ)-TCU axioms, and no fitted parameter is later presented as a prediction.

full rationale

The paper's load-bearing claims are upper bounds derived from the model definition, not empirical predictions. The asymmetric operation cost O(n√m + ℓ) in Section 3 is a defining axiom of the (m, ℓ)-TCU model; algorithms then split problems into such operations and sum their costs, so Theorem 2, Theorem 6, and Theorem 7 are standard analytical consequences rather than circular restatements. The lower bound in Theorem 2 is argued within the model from the number of elementary products per tensor call and the number of distinct right matrices that must be loaded; it does not assume its own conclusion. No fitted parameter is renamed as a prediction, and no load-bearing claim rests on a self-citation: citations such as [9], [12], [13], [16], [26], and [28] supply terminology, algorithmic black boxes, or hardware background, but not the model's cost rules. The paper itself notes in Section 2.2 that NVIDIA tensor cores do not keep matrix B resident, and Section 6 explicitly states that the model should be experimentally validated; these are external-validity or modeling-fidelity concerns, not circularity. Accordingly, the honest finding is no significant circularity.

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

The central bounds rest on the paper's own model postulates: a fixed-cost tensor product with latency, the tall-left streaming ability, and a systolic throughput assumption. No numerical constants are fitted to hardware data; m and ℓ are left symbolic. The external-memory transfer theorem adds an unproven simulation cost assumption.

free parameters (2)
  • m (TCU block size) = unspecified in general; examples given: TPU 65536, NVIDIA 256
    Model parameter defining the size of the native matrix multiply. Not fitted to data in the paper; the asymptotic tradeoffs depend on it.
  • ℓ (latency cost) = not quantified
    Model parameter for a single tensor unit call. The paper gives only qualitative discussion of TPU versus NVIDIA latency, and every theorem carries an ℓ-dependent term.
assumptions (5)
  • domain assumption A tensor unit multiplies an n×√m matrix by a √m×√m matrix in O(n√m+ℓ) time.
    Defined as the (m,ℓ)-TCU model in Section 3; every algorithmic theorem in Section 4 builds on this cost rule.
  • domain assumption The tensor unit can keep the right-hand matrix B resident while streaming rows of the left matrix A, called tall-left asymmetric behavior.
    Property 3 in Section 3; used in dense matmul, GE, transitive closure, and integer multiplication to reduce the latency term. Section 2.2 notes NVIDIA TC does not keep B resident.
  • domain assumption Systolic matrix multiplication computes m^{3/2} elementary products in Θ(m) wall-clock time.
    Used in the lower-bound argument of Theorem 2 to claim Ω(n^{3/2}/m^{1/2}); this is machine behavior, not derived from the model definition.
  • ad hoc to paper Simulating one standard RAM operation in the external memory model costs O(1) I/Os.
    Assumed in the proof of Theorem 12 to translate weak-TCU lower bounds into I/O lower bounds; not justified for arbitrary memory access patterns.
  • domain assumption Complex arithmetic and exact integer arithmetic can be simulated on the TCU with at most constant-factor overhead, given κ-bit words.
    Assumed in Section 4.5 for complex DFT and Section 4.7 for integer multiplication; affects the stated bounds only by constants when κ=Ω(log n).

how reviews work

0 comments
Cite this review

Pith. "Pith review of A Computational Model for Tensor Core Units." pith.science (2026). https://pith.science/paper/HW7F4KDF

@misc{pith2026190806649,
  author       = {Pith},
  title        = {Pith review of: A Computational Model for Tensor Core Units},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/HW7F4KDF}},
  note         = {Machine review of arXiv:1908.06649}
}
read the original abstract

To respond to the need of efficient training and inference of deep neural networks, a plethora of domain-specific hardware architectures have been introduced, such as Google Tensor Processing Units and NVIDIA Tensor Cores. A common feature of these architectures is a hardware circuit for efficiently computing a dense matrix multiplication of a given small size. In order to broaden the class of algorithms that exploit these systems, we propose a computational model, named the TCU model, that captures the ability to natively multiply small matrices. We then use the TCU model for designing fast algorithms for several problems, including matrix operations (dense and sparse multiplication, Gaussian Elimination), graph algorithms (transitive closure, all pairs shortest distances), Discrete Fourier Transform, stencil computations, integer multiplication, and polynomial evaluation. We finally highlight a relation between the TCU model and the external memory model.

Figures

Figures reproduced from arXiv: 1908.06649 by the authors.

Figure 1
Figure 1. A 3x3 systolic array after loading matrix [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 2
Figure 2. Forward phase of Gaussian elimination. Corollary 1. A √ n × r matrix can be multiplied by an r × √ n matrix in the (m, `)-TCU model in time T(n, r) = Θ  rn m1/2 + r √ n m `  , assuming n, r2 ≥ m. Proof. It suffices to decompose the problem into products of size s × s where s = min{ √ n, r} and then apply Theorem 2. Sparse matrix multiplication A TCU algorithm to multiply two sparse matrices follows from the work [… view at source ↗
Figure 3
Figure 3. Blocked version of Gaussian elimination. It shows which functions update which blocks in [PITH_FULL_IMAGE:figures/full_fig_p009_3.png] view at source ↗
Figures from the paper (4 more)
Figure 4
Figure 4. Figure 4: TCU algorithm for Gaussian elimination without pivoting which is called as [PITH_FULL_IMAGE:figures/full_fig_p010_4.png]
Figure 5
Figure 5. Figure 5: Iterative algorithm for computing the transitive closure of an [PITH_FULL_IMAGE:figures/full_fig_p011_5.png]
Figure 6
Figure 6. Figure 6: Blocked version of transitive closure. It shows which functions update which blocks in [PITH_FULL_IMAGE:figures/full_fig_p011_6.png]
Figure 7
Figure 7. Figure 7: TCU algorithm for computing transitive closure of an [PITH_FULL_IMAGE:figures/full_fig_p012_7.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

32 extracted references · 32 canonical work pages

  1. [1]

    Afshani and N

    P. Afshani and N. Sitchinava. Sorting and permuting without bank conflicts on gpus. In Proc. European Symposium on Algorithms (ESA) , pages 13–24, 2015

    work page 2015

  2. [2]

    https://www.apple.com/iphone-xr/a12-bionic/

    Apple neural engine. https://www.apple.com/iphone-xr/a12-bionic/

    work page

  3. [3]

    https://developer.arm.com/products/processors/ machine-learning/

    Arm machine learning processor. https://developer.arm.com/products/processors/ machine-learning/

    work page

  4. [4]

    Ballard, J

    G. Ballard, J. Demmel, O. Holtz, and O. Schwartz. Graph expansion and communication costs of fast matrix multiplication. J. ACM, 59(6):32:1–32:23, 2013

    work page 2013

  5. [5]

    Bj¨ orklund, R

    A. Bj¨ orklund, R. Pagh, V. V. Williams, and U. Zwick. Listing triangles. In Proc. 41st International Colloquium on Automata, Languages, and Programming (ICALP) , pages 223–234, 2014

    work page 2014

  6. [6]

    B¨ ohm, R

    C. B¨ ohm, R. Noll, C. Plant, B. Wackersreuther, and A. Zherdin. Data mining using graphics processing units. Trans. Large-Scale Data- and Knowledge-Centered Systems , 1:63–90, 2009

    work page 2009

  7. [7]

    Analyzing GPU Tensor Core Potential for Fast Reductions

    R. Carrasco, R. Vega, and C. A. Navarro. Analyzing GPU tensor core potential for fast reductions, 2019. Arxiv 1903.03640

    work page Pith review arXiv 2019

  8. [8]

    T. H. Cormen, C. E. Leiserson, R. L. Rivest, and C. Stein. Introduction to Algorithms. The MIT Press, 2001

    work page 2001

Show all 32 references
  1. [9]

    Dakkak, C

    A. Dakkak, C. Li, J. Xiong, I. Gelado, and W.-m. Hwu. Accelerating reduction and scan using tensor core units. In Proc. ACM International Conference on Supercomputing (ICS) , pages 46–57, 2019

    2019

  2. [10]

    J. Dean. Large-scale deep learning with tensorflow for building intelligent systems. ACM Webinar, 2016

    2016

  3. [11]

    K. He, X. Zhang, S. Ren, and J. Sun. Identity mappings in deep residual networks. In B. Leibe, J. Matas, N. Sebe, and M. Welling, editors, Proc. of Computer Vision(ECCV) , pages 630–645, 2016

    2016

  4. [12]

    Jacob and M

    R. Jacob and M. St¨ ockel. Fast output-sensitive matrix multiplication. In Proc. European Symposium on Algorithms (ESA) , pages 766–778, 2015

    2015

  5. [13]

    N. P. Jouppi, C. Young, N. Patil, D. Patterson, G. Agrawal, R. Bajwa, S. Bates, S. Bhatia, N. Boden, A. Borchers, et al. In-datacenter performance analysis of a tensor processing unit. In Proc. 44th Annual International Symposium on Computer Architecture (ISCA) , pages 1–12, 2017. 20

    2017

  6. [14]

    Karatsuba and Y

    A. Karatsuba and Y. Ofman. Multiplication of Multidigit Numbers on Automata. Soviet Physics Doklady, 7:595, 1963

    1963

  7. [15]

    Karsin, V

    B. Karsin, V. Weichert, H. Casanova, J. Iacono, and N. Sitchinava. Analysis-driven engineering of comparison-based sorting algorithms on gpus. In Proc. 32nd International Conference on Supercomputing (ICS), pages 86–95, 2018

    2018

  8. [16]

    Kleinberg and E

    J. Kleinberg and E. Tardos. Algorithm Design. Addison Wesley, 2006

    2006

  9. [17]

    F. Le Gall. Powers of tensors and fast matrix multiplication. In Proc. 39th International Symposium on Symbolic and Algebraic Computation (ISAAC) , pages 296–303, 2014

    2014

  10. [18]

    F. T. Leighton. Introduction to Parallel Algorithms and Architectures: Array, Trees, Hypercubes. Morgan Kaufmann Publishers Inc., 1992

    1992

  11. [19]

    Markidis, S

    S. Markidis, S. W. D. Chien, E. Laure, I. B. Peng, and J. S. Vetter. Nvidia tensor core programmability, performance precision. In Proc. IEEE International Parallel and Distributed Processing Symposium Workshops (IPDPSW), pages 522–531, 2018

    2018

  12. [20]

    Nobile, P

    M. Nobile, P. Cazzaniga, A. Tangherloni, and D. Besozzi. Graphics processing units in bioinformatics, computational biology and systems biology. Briefings in Bioinformatics , 18, 2016

    2016

  13. [21]

    http://images.nvidia.com/content/ volta-architecture/pdf/volta-architecture-whitepaper.pdf

    Nvidia Tesla V100 GPU architecture. http://images.nvidia.com/content/ volta-architecture/pdf/volta-architecture-whitepaper.pdf

  14. [22]

    M. A. Raihan, N. Goli, and T. M. Aamodt. Modeling deep learning accelerator enabled GPUs. In Proc. IEEE International Symposium on Performance Analysis of Systems and Software (ISPASS), pages 79–92, 2019

    2019

  15. [23]

    R. Raz. On the complexity of matrix product. SIAM Journal on Computing , 32(5):1356–1369, 2003

    2003

  16. [24]

    Reagen, R

    B. Reagen, R. Adolf, P. N. Whatmough, G. Wei, and D. M. Brooks.Deep Learning for Computer Architects. Synthesis Lectures on Computer Architecture. Morgan & Claypool Publishers, 2017

    2017

  17. [25]

    Rodriguez, E

    A. Rodriguez, E. Segal, E. Meiri, E. Fomenko, Y. J. Kim, H. Shen, and B. Ziv. Lower numerical precision deep learning inference and training. Technical report, Intel, 2018

    2018

  18. [26]

    R. Seidel. On the all-pairs-shortest-path problem in unweighted undirected graphs. J. Comput. Syst. Sci., 51(3):400–403, 1995

    1995

  19. [27]

    S. Shi, Q. Wang, P. Xu, and X. Chu. Benchmarking state-of-the-art deep learning software tools. In Proc. 7th International Conference on Cloud Computing and Big Data (CCBD) , pages 99–104, 2016

    2016

  20. [28]

    Sorna, X

    A. Sorna, X. Cheng, E. D’Azevedo, K. Won, and S. Tomov. Optimizing the fast fourier transform using mixed precision on tensor core hardware. In Proc. IEEE 25th International Conference on High Performance Computing Workshops (HiPCW) , pages 3–7, 2018

    2018

  21. [29]

    Strassen

    V. Strassen. Gaussian elimination is not optimal. Numer. Math., 13(4), 1969

    1969

  22. [30]

    J. S. Vitter. Algorithms and data structures for external memory. Foundations and Trends in Theoretical Computer Science, 2(4):305–474, 2006. 21

    2006

  23. [31]

    V. V. Williams. Multiplying matrices faster than Coppersmith-Winograd. In Proc. 44th Symposium on Theory of Computing Conference (STOC) , pages 887–898, 2012

    2012

  24. [32]

    Y. Zhu, M. Mattina, and P. Whatmough. Mobile machine learning hardware at arm: A systems-on-chip (SoC) perspective, 2018. Arxiv 1801.06274. 22

    2018 arXiv

Pith tools

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