# Transpose
The **transpose** of an m×n matrix A is the n×m matrix Aᵀ whose i, j entry is the j, i entry of A, so that rows are exchanged for columns and vice versa.[1](https://nasim.hormozgan.ac.ir/ostad/UploadedFiles/2397/2397-8326571392548891.pdf) Transposition is one of the fundamental operations of matrix algebra: it defines the symmetric, skew-symmetric, and orthogonal matrix classes, and it interacts with determinants, traces, ranks, and inverses in ways that make it indispensable throughout linear algebra and numerical computing.[1](https://nasim.hormozgan.ac.ir/ostad/UploadedFiles/2397/2397-8326571392548891.pdf) • [2](https://math.libretexts.org/Bookshelves/Linear_Algebra/Book%3A_Linear_Algebra_(Schilling_Nachtergaele_and_Lankham)/12%3A_Supplementary_notes_on_matrices_and_linear_systems/12.05%3A_Special_operations_on_matrices)
| Key fact | Detail |
|---|---|
| Definition | For A = [a_ij] in M_{m,n}(F), Aᵀ is the matrix in M_{n,m}(F) with (Aᵀ)_ij = a_ji.[1](https://nasim.hormozgan.ac.ir/ostad/UploadedFiles/2397/2397-8326571392548891.pdf) |
| Reverse-order law | (AB)ᵀ = BᵀAᵀ; also (Aᵀ)ᵀ = A, (A+B)ᵀ = Aᵀ + Bᵀ, (αA)ᵀ = αAᵀ, and (Aᵀ)⁻¹ = (A⁻¹)ᵀ for invertible A.[2](https://math.libretexts.org/Bookshelves/Linear_Algebra/Book%3A_Linear_Algebra_(Schilling_Nachtergaele_and_Lankham)/12%3A_Supplementary_notes_on_matrices_and_linear_systems/12.05%3A_Special_operations_on_matrices) |
| Invariants | det(A) = det(Aᵀ), trace(Aᵀ) = trace(A), and rank(A) = rank(Aᵀ).[3](https://understandinglinearalgebra.org/sec-transpose.html) • [2](https://math.libretexts.org/Bookshelves/Linear_Algebra/Book%3A_Linear_Algebra_(Schilling_Nachtergaele_and_Lankham)/12%3A_Supplementary_notes_on_matrices_and_linear_systems/12.05%3A_Special_operations_on_matrices) • [4](https://www.cis.upenn.edu/~cis5150/cis515-20-sl6.pdf) |
| Defining identities | Symmetric: Aᵀ = A; skew-symmetric: Aᵀ = −A; orthogonal: AᵀA = I; Hermitian: A* = A; unitary: A*A = I; normal: A*A = AA*.[1](https://nasim.hormozgan.ac.ir/ostad/UploadedFiles/2397/2397-8326571392548891.pdf) |
| Computational cost | An m×n transpose incurs Θ(1 + mn/B) cache misses for cache-line length B, asymptotically optimal, yet naive implementations run about 5× slower than blocked, prefetching versions on x86.[5](https://dl.acm.org/doi/10.1145/2071379.2071383) • [6](https://gudok.xyz/transpose/) |
| Notation | Aᵀ is most common; A′, A*, Aᴴ, and † appear with field-specific meanings, and "adjoint" ambiguously names two different operations.[7](https://mathworld.wolfram.com/Transpose.html) • [8](https://mathworld.wolfram.com/ConjugateTranspose.html) |
| Recent practice | C++26 adds std::linalg::transposed as a zero-copy view; PyTorch's 2025 tiled CUDA kernel raised uint8 transpose-copy throughput from 47–60 GB/s to 225–227 GB/s.[9](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3222r1.html) • [10](https://github.com/pytorch/pytorch/pull/194310) |
## Definition and notation
Formally, if A = [a_ij] is an m×n matrix over a field F, its transpose Aᵀ is the n×m matrix whose i, j entry is a_ji; equivalently, the rows of Aᵀ are the columns of A.[1](https://nasim.hormozgan.ac.ir/ostad/UploadedFiles/2397/2397-8326571392548891.pdf) • [11](https://people.math.wisc.edu/~angenent/341.2022s/LADW_2017-09-04.pdf) The operation applies to rectangular as well as square matrices.[12](https://royalsocietypublishing.org/rstl/article-pdf/doi/10.1098/rstl.1858.0002/1455279/rstl.1858.0002.pdf)
[Arthur Cayley](https://www.edgepedia.org/arthur-cayley) introduced the notion in his 1858 *A Memoir on the Theory of Matrices*, writing "tr." for the operation that "convert[s] a broad matrix into a deep one and reciprocally."[12](https://royalsocietypublishing.org/rstl/article-pdf/doi/10.1098/rstl.1858.0002/1455279/rstl.1858.0002.pdf) Notation has never settled. MacDuffee's *Theory of Matrices* (1933) reports notations A′, Ā, Ǎ, A*, A₁, and ₜA and prefers Aᵀ, while Wedderburn (1934) wrote A′ for what he called the "transverse."[13](https://mathshistory.st-andrews.ac.uk/Miller/mathsym/matrices/) Today Aᵀ is the most common form, with several alternatives in use across fields.[7](https://mathworld.wolfram.com/Transpose.html)
## Basic algebraic properties
Transposition is linear and an involution: (A + B)ᵀ = Aᵀ + Bᵀ, (αA)ᵀ = αAᵀ, and (Aᵀ)ᵀ = A.[2](https://math.libretexts.org/Bookshelves/Linear_Algebra/Book%3A_Linear_Algebra_(Schilling_Nachtergaele_and_Lankham)/12%3A_Supplementary_notes_on_matrices_and_linear_systems/12.05%3A_Special_operations_on_matrices) The central identity is the reverse-order law,
\[ (AB)^{T} = B^{T} A^{T}, \]
which holds because the i, j entry of (AB)ᵀ is the j, i entry of AB, namely Σ_k a_jk b_ki, and this is exactly the i, j entry of BᵀAᵀ; the proof is a subscript interchange.[14](https://linearalgebra.math.umanitoba.ca/math1220/section-19.html) The same reversal occurs for the conjugate transpose, (AB)* = B*A*, while complex conjugation of a product does not reverse.[1](https://nasim.hormozgan.ac.ir/ostad/UploadedFiles/2397/2397-8326571392548891.pdf)
Transposition preserves the quantities that matter for solving systems: det(A) = det(Aᵀ), trace(Aᵀ) = trace(A), and rank(A) = rank(Aᵀ).[3](https://understandinglinearalgebra.org/sec-transpose.html) • [2](https://math.libretexts.org/Bookshelves/Linear_Algebra/Book%3A_Linear_Algebra_(Schilling_Nachtergaele_and_Lankham)/12%3A_Supplementary_notes_on_matrices_and_linear_systems/12.05%3A_Special_operations_on_matrices) • [4](https://www.cis.upenn.edu/~cis5150/cis515-20-sl6.pdf) If A is invertible, so is Aᵀ, with (Aᵀ)⁻¹ = (A⁻¹)ᵀ.[2](https://math.libretexts.org/Bookshelves/Linear_Algebra/Book%3A_Linear_Algebra_(Schilling_Nachtergaele_and_Lankham)/12%3A_Supplementary_notes_on_matrices_and_linear_systems/12.05%3A_Special_operations_on_matrices)
## The transpose and inner products
The transpose is the computational face of the dot product. The components of the product Aᵀx are the dot products of the columns of A with x, so applying Aᵀ to a vector means pairing that vector against each column of A.[3](https://understandinglinearalgebra.org/sec-transpose.html)
Conceptually, every linear map f : E → F induces a transpose (dual) map fᵀ : F* → E* defined by fᵀ(v*) = v* ∘ f, where F* and E* are the dual spaces of linear functionals; in suitable bases the matrix of fᵀ is the transpose of the matrix of f.[4](https://www.cis.upenn.edu/~cis5150/cis515-20-sl6.pdf) This construction explains transpose phenomena at once, including the reversal of composition,
\[ (g \circ f)^{T} = f^{T} \circ g^{T}, \]
which is the coordinate-free statement of (AB)ᵀ = BᵀAᵀ.[4](https://www.cis.upenn.edu/~cis5150/cis515-20-sl6.pdf)
## Special matrices defined by transposition
Several of the most used matrix classes are defined by a transpose identity: a matrix is **symmetric** if Aᵀ = A, **skew-symmetric** if Aᵀ = −A, and **orthogonal** if AᵀA = I; over the complex numbers, Hermitian (A* = A), unitary (A*A = I), and normal (A*A = AA*) matrices play the corresponding roles.[1](https://nasim.hormozgan.ac.ir/ostad/UploadedFiles/2397/2397-8326571392548891.pdf) Cayley already noted in 1858 that the terms "symmetrical" and "skew symmetrical" apply only to square matrices.[12](https://royalsocietypublishing.org/rstl/article-pdf/doi/10.1098/rstl.1858.0002/1455279/rstl.1858.0002.pdf)
Every square matrix A over a field of characteristic other than 2 decomposes uniquely as A = S(A) + C(A) with S(A) symmetric and C(A) skew-symmetric.[1](https://nasim.hormozgan.ac.ir/ostad/UploadedFiles/2397/2397-8326571392548891.pdf) The symmetric and Hermitian classes carry a spectral guarantee: real symmetric and complex Hermitian matrices always have real eigenvalues, and for any real A the product AAᵀ is symmetric with real, non-negative eigenvalues.[2](https://math.libretexts.org/Bookshelves/Linear_Algebra/Book%3A_Linear_Algebra_(Schilling_Nachtergaele_and_Lankham)/12%3A_Supplementary_notes_on_matrices_and_linear_systems/12.05%3A_Special_operations_on_matrices)
## Transpose, conjugate transpose, and adjugate
Three distinct operations share names and symbols. The transpose (Aᵀ)_ij = a_ji acts on the dual space; the conjugate transpose A* = Āᵀ, also called the adjoint or [Hermitian adjoint](https://www.edgepedia.org/hermitian-adjoint), additionally conjugates each entry, and for real matrices the two coincide.[1](https://nasim.hormozgan.ac.ir/ostad/UploadedFiles/2397/2397-8326571392548891.pdf) • [2](https://math.libretexts.org/Bookshelves/Linear_Algebra/Book%3A_Linear_Algebra_(Schilling_Nachtergaele_and_Lankham)/12%3A_Supplementary_notes_on_matrices_and_linear_systems/12.05%3A_Special_operations_on_matrices) The classical adjoint, or adjugate, is unrelated: it is the transposed matrix of cofactors satisfying A(adj A) = (det A)I.[15](http://www.math.hawaii.edu/~tom/adjoint-transpose.pdf) The phrase "adjoint matrix" is therefore ambiguous, meaning either the conjugate transpose or the adjugate depending on the author.[8](https://mathworld.wolfram.com/ConjugateTranspose.html)
Notation for the conjugate transpose also varies by field: A* is common in numerical linear algebra, Aᴴ in operator theory, and the dagger A† in physics.[8](https://mathworld.wolfram.com/ConjugateTranspose.html) Numerical libraries keep the distinction explicit: the BLAS standard's trans argument takes three values selecting whether A, Aᵀ, or the conjugate transpose Aᴴ is applied, written op(A).[16](https://www.netlib.org/utk/people/JackDongarra/PAPERS/blas-report.pdf)
## By the numbers
Although transposition merely reorders mn elements, its performance is essentially determined by sustained memory bandwidth.[17](http://impact.crhc.illinois.edu/shared/papers/p207-sung.pdf) The permutation it induces on memory locations has poor locality; Gatlin and Carter named such permutations "Murphy permutations."[18](https://csaws.cs.technion.ac.il/~itai/Courses/Cache/matrix-transposition.pdf) For a cache of size M and cache-line length B with M = Ω(B²), an m×n transpose incurs Θ(1 + mn/B) cache misses, which is asymptotically optimal.[5](https://dl.acm.org/doi/10.1145/2071379.2071383)
**Blocking and prefetching deliver large constant-factor gains.** On POWER7, a blocked transpose with explicit prefetching and data alignment reached up to five times the performance of IBM ESSL's dgetmo routine and 2.5 times compiler-inserted prefetching.[19](https://www.dcs.warwick.ac.uk/~sdh/pmbs11/PMBS11/Workshop_Schedule_files/rm-1000.pdf) On x86, a naive transpose cost 6.95 cycles per element (46.5 billion cycles total, 51.6% stalled cycles); blocking alone cut this to 1.64 cycles per element, and adding prefetching reached 1.41 cycles per element (9.4 billion cycles, 9.6% stalled).[6](https://gudok.xyz/transpose/)
**The cache-capacity cliff is sharp.** In the cited example, performance plummets after n ≈ 1000 because holding even one row of the target matrix for spatial locality requires N × L bytes, about 64 KB for N = 1000 with 64-byte cache lines.[20](https://wgropp.cs.illinois.edu/courses/cs598-s16/lectures/lecture07.pdf)
**Theory and practice disagree at large sizes.** The cache-oblivious algorithm, which recursively subdivides the matrix to 2×2 blocks without any tile-size parameter, needs no hardware tuning and is asymptotically optimal.[5](https://dl.acm.org/doi/10.1145/2071379.2071383) • [21](https://www.mdpi.com/2227-7390/8/2/184) But ANU benchmarks measured 131,226 cache misses for the cache-oblivious algorithm at dimension 1024 and 56,158,873 at dimension 8192, while full-copy cache blocking recorded 275,550 and 19,493,808 misses at those sizes, so the cache-oblivious advantage over full-copy blocking reverses at large sizes.[22](https://users.cecs.anu.edu.au/~peter/papers/comtICCS04.pdf)
## Implementation and practice
**Memory layout strongly affects performance.** In row-major storage, element A(i, j) at offset k = i×N + j moves to offset k₀ = j×M + i when transposed, so one direction of access is always strided.[17](http://impact.crhc.illinois.edu/shared/papers/p207-sung.pdf) Libraries therefore expose transposition as a flag rather than a data movement: BLAS level 2 and 3 routines such as sgemm and dgemm take a parameter specifying that an input matrix is transposed before the operation, and Intel MKL has included out-of-place and in-place transposition routines since release 10.1.[17](http://impact.crhc.illinois.edu/shared/papers/p207-sung.pdf) The oneMKL routine mkl_?omatcopy2 performs two-strided scaling and out-of-place transposition or copying, B := alpha·op(A), where trans = 'T' selects transposition and trans = 'C' selects conjugate transposition.[23](https://www.intel.com/content/www/us/en/docs/onemkl/developer-reference-c/2025-1/mkl-omatcopy2.html)
**In-place versus out-of-place.** Out-of-place transposition has at least 100% spatial overhead, motivating in-place methods with zero or at most one bit per element of overhead.[17](http://impact.crhc.illinois.edu/shared/papers/p207-sung.pdf) The price is algorithmic: in-place cycle-following algorithms with auxiliary storage below O(mn) elements have work complexity O(mn log mn), because cycles must be recomputed as the transposition proceeds.[24](https://research.nvidia.com/sites/default/files/pubs/2014-02_A-Decomposition-for/ppopp2014.pdf)
**On GPUs, coalescing is the issue.** In a naive GPU transpose, adjacent threads read row-wise (coalesced) but write column-wise with large strides, so each write typically requires a separate memory transaction; tiling through shared memory is the standard fix.[25](https://rocm-handbook.amd.com/projects/amd-rocm-programming-guide/en/docs-10.1.0/tutorial/hip-performance-optimization/tiling-matrix-transpose.html) In NVIDIA's CuTe layout system, column-major layouts are the default, with row-major or column-major stride conventions selectable when a new tensor's layout is defined.[26](https://research.colfax-intl.com/tutorial-matrix-transpose-in-cutlass/) For distributed memory, the communication structure of a parallel transpose over a P×Q processor template is determined by GCD(P, Q): relatively prime P and Q force a complete exchange, while otherwise processors divide into GCD groups and the matrix transposes in LCM/GCD steps with non-blocking communication to overlap messages.[27](https://www.netlib.org/lapack/lawnspdf/lawn65.pdf)
## Recent developments
**The C++26 working draft includes a zero-copy view.** WG21 voted P1673R13, introducing std::linalg::transposed, into the C++ Working Draft at Kona 2023; it takes a rank-2 mdspan and returns a read-only mdspan representing the transpose without copying or moving elements.[9](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3222r1.html) P2642R6, voted in at Tokyo 2024, added layout_left_padded and layout_right_padded, exactly the two layouts understood by the C BLAS, where the user stride is the BLAS "leading dimension." P3222R1 then proposed that transposed of a padded layout return the opposite padded layout with extents swapped and the padding stride copied, enabling dispatch to optimized BLAS; delaying this past C++26 would be a breaking change.[9](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3222r1.html)
**Library support remains uneven.** In oneMKL 2025.1, in-place and out-of-place dense matrix transpose are supported on CPU but not on Intel GPUs via OpenMP Offload.[28](https://www.intel.com/content/www/us/en/docs/onemkl/developer-reference-c/2025-1/transposition-functionality.html) OpenBLAS extended GEADD to support independent transposition of both the A and C operands, matching cuBLAS's geam and Apple's Accelerate geadd, by adding a transc parameter across the CBLAS interface and generic kernels.[29](https://github.com/OpenMathLib/OpenBLAS/pull/5913) PyTorch merged a tiled CUDA kernel for dense 2D transpose copies that raised throughput from 47–60 GB/s to 225–227 GB/s for uint8 (3.6–4.8×), from 85–144 to 226–236 GB/s for float32 (1.6–2.8×), and from 128–228 to 225–231 GB/s for float64 (1.0–2.2×).[10](https://github.com/pytorch/pytorch/pull/194310)
## References
1. [Horn & Johnson, Matrix Analysis, Chapter 0.2 (excerpt)](https://nasim.hormozgan.ac.ir/ostad/UploadedFiles/2397/2397-8326571392548891.pdf)
2. [Schilling, Nachtergaele & Lankham, Linear Algebra, §12.5: Special operations on matrices, LibreTexts](https://math.libretexts.org/Bookshelves/Linear_Algebra/Book%3A_Linear_Algebra_(Schilling_Nachtergaele_and_Lankham)/12%3A_Supplementary_notes_on_matrices_and_linear_systems/12.05%3A_Special_operations_on_matrices)
3. [David Austin, Understanding Linear Algebra, §6.2](https://understandinglinearalgebra.org/sec-transpose.html)
4. [Chapter 9: The Dual Space, Duality (UPenn CIS 515, after Gallier)](https://www.cis.upenn.edu/~cis5150/cis515-20-sl6.pdf)
5. [Frigo et al., Cache-Oblivious Algorithms, ACM Transactions on Algorithms](https://dl.acm.org/doi/10.1145/2071379.2071383)
6. [What it takes to transpose a matrix (performance-engineering blog)](https://gudok.xyz/transpose/)
7. [Transpose, Wolfram MathWorld](https://mathworld.wolfram.com/Transpose.html)
8. [Conjugate Transpose, Wolfram MathWorld](https://mathworld.wolfram.com/ConjugateTranspose.html)
9. [P3222R1: Fix C++26 by adding transposed special cases for P2642 layouts, WG21](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3222r1.html)
10. [PyTorch PR #194310: Add tiled CUDA kernel for dense 2D transpose copies](https://github.com/pytorch/pytorch/pull/194310)
11. [Linear Algebra Done Wrong (Treil; UW–Madison course copy)](https://people.math.wisc.edu/~angenent/341.2022s/LADW_2017-09-04.pdf)
12. [Arthur Cayley (1858), A Memoir on the Theory of Matrices, Philosophical Transactions of the Royal Society](https://royalsocietypublishing.org/rstl/article-pdf/doi/10.1098/rstl.1858.0002/1455279/rstl.1858.0002.pdf)
13. [Earliest Uses of Symbols for Matrices and Vectors, MacTutor](https://mathshistory.st-andrews.ac.uk/Miller/mathsym/matrices/)
14. [The transpose and trace of a matrix, University of Manitoba MATH 1220](https://linearalgebra.math.umanitoba.ca/math1220/section-19.html)
15. [Notation note: adjoint vs transpose vs adjugate, University of Hawaii](http://www.math.hawaii.edu/~tom/adjoint-transpose.pdf)
16. [BLAS Technical Forum Standard](https://www.netlib.org/utk/people/JackDongarra/PAPERS/blas-report.pdf)
17. [In-Place Transposition of Rectangular Matrices on Accelerators, University of Illinois](http://impact.crhc.illinois.edu/shared/papers/p207-sung.pdf)
18. [Cache-Efficient Matrix Transposition, Technion](https://csaws.cs.technion.ac.il/~itai/Courses/Cache/matrix-transposition.pdf)
19. [Optimizing Matrix Transposes Using a POWER7 Cache Model and Explicit Prefetching](https://www.dcs.warwick.ac.uk/~sdh/pmbs11/PMBS11/Workshop_Schedule_files/rm-1000.pdf)
20. [Lecture 7: Matrix Transpose, William Gropp, UIUC CS 598](https://wgropp.cs.illinois.edu/courses/cs598-s16/lectures/lecture07.pdf)
21. [Ideal and Predictable Hit Ratio for Matrix Transposition in Data Caches, Mathematics (MDPI)](https://www.mdpi.com/2227-7390/8/2/184)
22. [Cache Oblivious Matrix Transposition: Simulation and Experiment, ANU, ICCS 2004](https://users.cecs.anu.edu.au/~peter/papers/comtICCS04.pdf)
23. [mkl_?omatcopy2, Intel oneMKL Developer Reference 2025.1](https://www.intel.com/content/www/us/en/docs/onemkl/developer-reference-c/2025-1/mkl-omatcopy2.html)
24. [A Decomposition for In-place Matrix Transposition, PPoPP 2014, NVIDIA Research](https://research.nvidia.com/sites/default/files/pubs/2014-02_A-Decomposition-for/ppopp2014.pdf)
25. [Tiling and coalescing: matrix transpose, AMD ROCm Programming Guide](https://rocm-handbook.amd.com/projects/amd-rocm-programming-guide/en/docs-10.1.0/tutorial/hip-performance-optimization/tiling-matrix-transpose.html)
26. [Tutorial: Matrix Transpose in CUTLASS, Colfax Research](https://research.colfax-intl.com/tutorial-matrix-transpose-in-cutlass/)
27. [LAPACK Working Note 65: PUMMA](https://www.netlib.org/lapack/lawnspdf/lawn65.pdf)
28. [Transposition Functionality, Intel oneMKL Developer Reference 2025.1](https://www.intel.com/content/www/us/en/docs/onemkl/developer-reference-c/2025-1/transposition-functionality.html)
29. [OpenBLAS PR #5913: Add transpose support for C in GEADD](https://github.com/OpenMathLib/OpenBLAS/pull/5913)
---
*Topic: Encyclopedia › Physical world and mathematics › Mathematics and statistics › Numbers and algebra › Linear and multilinear algebra › Matrix theory › Matrix operations and matrix algebra*
*Initially written Sep 17, 2026 · Reviewed: Oct 15, 2026 · Edited: Oct 15, 2026 · Last review: Oct 15, 2026*
*Copyright 2026 EdgeChat AI, a subsidiary of Biostate AI.*
License: Edgepedia Community License 1.0, https://www.edgepedia.org/edgepedia/license