---
title: "ArrayExpand"
language: "en"
type: "Symbol"
summary: "ArrayExpand[expr] expands out symbolic array operations in expr. ArrayExpand[expr, assum] expands using assumptions assum."
keywords: 
- symbolic array
- matrix expand
- array algebra
- matrix algebra
- symbolic matrix
- expansion
- distributive property
- distributive law
- expanded array
canonical_url: "https://reference.wolfram.com/language/ref/ArrayExpand.html"
source: "Wolfram Language Documentation"
related_guides: 
  - 
    title: "Symbolic Vectors, Matrices and Arrays"
    link: "https://reference.wolfram.com/language/guide/SymbolicArrays.en.md"
related_functions: 
  - 
    title: "ArraySimplify"
    link: "https://reference.wolfram.com/language/ref/ArraySimplify.en.md"
  - 
    title: "ComponentExpand"
    link: "https://reference.wolfram.com/language/ref/ComponentExpand.en.md"
  - 
    title: "TensorExpand"
    link: "https://reference.wolfram.com/language/ref/TensorExpand.en.md"
  - 
    title: "Expand"
    link: "https://reference.wolfram.com/language/ref/Expand.en.md"
  - 
    title: "TensorReduce"
    link: "https://reference.wolfram.com/language/ref/TensorReduce.en.md"
  - 
    title: "NonCommutativeExpand"
    link: "https://reference.wolfram.com/language/ref/NonCommutativeExpand.en.md"
  - 
    title: "Simplify"
    link: "https://reference.wolfram.com/language/ref/Simplify.en.md"
---
# ArrayExpand

ArrayExpand[expr] expands out symbolic array operations in expr.

ArrayExpand[expr, assum] expands using assumptions assum.

## Details and Options

* ``ArrayExpand`` can be used for expanding out symbolic array operations.

* ``ArrayExpand`` makes use of multilinearity of array operations, as well as of numerous array, matrix and vector operation identities.

* Dimensionality of symbolic arguments can be specified through assumptions or by using ``ArraySymbol``, ``MatrixSymbol`` or ``VectorSymbol``.

* Symbolic arguments of unspecified dimensionality are assumed to be arrays of dimensions appropriate for the functions they are used in. In multi-argument ``Listable`` functions, like ``Plus`` or ``Times``, all arguments are assumed to have the same dimensions unless specified differently.  »

* The following options can be given:

|                     |               |                                              |
| ------------------- | ------------- | -------------------------------------------- |
| Assumptions         | \$Assumptions | default assumptions to be appended to assum  |
| GenerateConditions  | False         | whether to generate conditions on parameters |

* You can specify default assumptions for ``ArrayExpand`` using ``Assuming``.

---

## Examples (52)

### Basic Examples (3)

Expand out ``Dot`` product of sums of arrays:

```wl
In[1]:= ArrayExpand[(a + b).(c + d)]

Out[1]= a.c + a.d + b.c + b.d
```

---

Expand out ``Tr`` of a linear combination of arrays:

```wl
In[1]:= ArrayExpand[Tr[s a + t b], Element[s | t, Complexes]]

Out[1]= s Tr[a] + t Tr[b]
```

---

Expand out ``Inverse`` of ``Dot`` product of matrices:

```wl
In[1]:= ArrayExpand[Inverse[MatrixSymbol["a", {n, n}].MatrixSymbol["b", {n, n}]]]

Out[1]= Inverse[(MatrixSymbol["b", {n, n}])].Inverse[(MatrixSymbol["a", {n, n}])]
```

### Scope (45)

#### Multilinear Operations (12)

Elementwise products of linear combinations:

```wl
In[1]:= ArrayExpand[(2 ArraySymbol["a", {p, q, r}] + 3 ArraySymbol["b", {p, q, r}]) (4 ArraySymbol["c", {p, q, r}] + 5 ArraySymbol["d", {p, q, r}])]

Out[1]= 8 ArraySymbol["a", {p, q, r}] ArraySymbol["c", {p, q, r}] + 12 ArraySymbol["b", {p, q, r}] ArraySymbol["c", {p, q, r}] + 10 ArraySymbol["a", {p, q, r}] ArraySymbol["d", {p, q, r}] + 15 ArraySymbol["b", {p, q, r}] ArraySymbol["d", {p, q, r}]
```

---

``Dot`` products of linear combinations:

```wl
In[1]:= ArrayExpand[(2a + 3b).(4c + 5d)]

Out[1]= 8 a.c + 10 a.d + 12 b.c + 15 b.d
```

---

``ArrayDot`` products of linear combinations:

```wl
In[1]:= ArrayExpand[ArrayDot[2a + 3b, 4c + 5d, 2]]

Out[1]= 8 ArrayDot[a, c, 2] + 10 ArrayDot[a, d, 2] + 12 ArrayDot[b, c, 2] + 15 ArrayDot[b, d, 2]
```

---

``TensorProduct`` of linear combinations:

```wl
In[1]:= ArrayExpand[TensorProduct[2a + 3b, 4c + 5d, 6e]]

Out[1]= 48 a\[TensorProduct]c\[TensorProduct]e + 60 a\[TensorProduct]d\[TensorProduct]e + 72 b\[TensorProduct]c\[TensorProduct]e + 90 b\[TensorProduct]d\[TensorProduct]e
```

---

``KroneckerProduct`` of linear combinations:

```wl
In[1]:= ArrayExpand[KroneckerProduct[2a + 3b, 4c + 5d]]

Out[1]= 8 KroneckerProduct[a, c] + 10 KroneckerProduct[a, d] + 12 KroneckerProduct[b, c] + 15 KroneckerProduct[b, d]
```

---

``TensorWedge`` of linear combinations:

```wl
In[1]:= ArrayExpand[TensorWedge[2a + 3b, 4c + 5d]]

Out[1]= 8 a\[TensorWedge]c + 10 a\[TensorWedge]d + 12 b\[TensorWedge]c + 15 b\[TensorWedge]d
```

---

``Cross`` product of linear combinations:

```wl
In[1]:= ArrayExpand[Cross[2a + 3b, 4c + 5d]]

Out[1]= 8 a\[Cross]c + 10 a\[Cross]d + 12 b\[Cross]c + 15 b\[Cross]d
```

---

``Tr`` of linear combinations:

```wl
In[1]:= ArrayExpand[Tr[2a + 3b + 4c]]

Out[1]= 2 Tr[a] + 3 Tr[b] + 4 Tr[c]
```

---

``TensorContract`` of linear combinations:

```wl
In[1]:= ArrayExpand[TensorContract[2a + 3b + 4c + 5d, {{2, 3}}]]

Out[1]= 2 TensorContract[a, {{2, 3}}] + 3 TensorContract[b, {{2, 3}}] + 4 TensorContract[c, {{2, 3}}] + 5 TensorContract[d, {{2, 3}}]
```

---

``HodgeDual`` of linear combinations:

```wl
In[1]:= ArrayExpand[HodgeDual[s a + t b], Element[s | t, Reals]]

Out[1]= s HodgeDual[a] + t HodgeDual[b]
```

---

``Transpose`` of linear combinations:

```wl
In[1]:= ArrayExpand[Transpose[s a + t b], Element[s | t, Reals]]

Out[1]= s Transpose[a] + t Transpose[b]
```

---

``ConjugateTranspose`` of linear combinations:

```wl
In[1]:= ArrayExpand[ConjugateTranspose[2 a + I b + (3 + 2I)c]]

Out[1]= 2 a^† - I b^† + (3 - 2 I) c^†
```

#### Array Operations (6)

``Tr`` of ``Transpose``, ``Conjugate`` and ``ConjugateTranspose`` :

```wl
In[1]:= ArrayExpand[Tr[Transpose[a]]]

Out[1]= Tr[a]

In[2]:= ArrayExpand[Tr[Conjugate[a]]]

Out[2]= Conjugate[Tr[a]]

In[3]:= ArrayExpand[Tr[ConjugateTranspose[a]]]

Out[3]= Conjugate[Tr[a]]
```

---

``Conjugate`` of array operations:

```wl
In[1]:= ArrayExpand[Conjugate[a.b]]

Out[1]= Conjugate[a].Conjugate[b]

In[2]:= ArrayExpand[Conjugate[ArrayDot[a, b, 2]]]

Out[2]= ArrayDot[Conjugate[a], Conjugate[b], 2]

In[3]:= ArrayExpand[Conjugate[TensorProduct[a, b]]]

Out[3]= Conjugate[a]\[TensorProduct]Conjugate[b]

In[4]:= ArrayExpand[Conjugate[KroneckerProduct[a, b]]]

Out[4]= KroneckerProduct[Conjugate[a], Conjugate[b]]

In[5]:= ArrayExpand[Conjugate[TensorWedge[a, b]]]

Out[5]= Conjugate[a]\[TensorWedge]Conjugate[b]

In[6]:= ArrayExpand[Conjugate[Cross[a, b]]]

Out[6]= Conjugate[a]\[Cross]Conjugate[b]
```

---

``Conjugate`` and ``ConjugateTranspose`` of elementary functions:

```wl
In[1]:= ArrayExpand[Conjugate[Sin[VectorSymbol["v", n]]]]

Out[1]= Sin[Conjugate[VectorSymbol["v", n]]]

In[2]:= ArrayExpand[ConjugateTranspose[ArcTan[a]]]

Out[2]= ArcTan[a^†]

In[3]:= ArrayExpand[Conjugate[(MatrixSymbol["a", {n, n}])^k], k∈ℤ]

Out[3]= Conjugate[MatrixSymbol["a", {n, n}]]^k

In[4]:= ArrayExpand[ConjugateTranspose[t ^ a], t > 0]

Out[4]= t^a^†
```

---

``Transpose`` of ``Listable`` mathematical functions:

```wl
In[1]:= ArrayExpand[Transpose[a ^ b]]

Out[1]= (Transpose[a])^Transpose[b]

In[2]:= ArrayExpand[Transpose[Beta[a, b]]]

Out[2]= Beta[Transpose[a], Transpose[b]]
```

---

``Dot`` product of ``TensorProduct`` :

```wl
In[1]:= ArrayExpand[TensorProduct[a, b, c].TensorProduct[d, e], Element[c | d, Vectors[n]]]

Out[1]= c.d a\[TensorProduct]b\[TensorProduct]e

In[2]:= ArrayExpand[TensorProduct[a, b, c].TensorProduct[d, e], Element[c | d, Matrices[{n, n}]]]

Out[2]= a\[TensorProduct]b\[TensorProduct](c.d)\[TensorProduct]e
```

---

Commutativity of scalar-valued ``ArrayDot`` :

```wl
In[1]:= ArrayExpand[ArrayDot[b, a, 3], Element[a | b, Arrays[{m, n, p}]]]

Out[1]= ArrayDot[a, b, 3]
```

#### Matrix Operations (13)

``Inverse``, ``MatrixPower``, ``PseudoInverse`` and ``Adjugate`` of a scalar multiple:

```wl
In[1]:= ArrayExpand[Inverse[3a]]

Out[1]= (Inverse[a]/3)

In[2]:= ArrayExpand[MatrixPower[3a, n]]

Out[2]= 3^n MatrixPower[a, n]

In[3]:= ArrayExpand[PseudoInverse[3a]]

Out[3]= (PseudoInverse[a]/3)

In[4]:= ArrayExpand[Adjugate[3 a], Element[a, Matrices[{n, n}]]]

Out[4]= 3^-1 + n Adjugate[a]
```

---

``Inverse`` and ``Adjugate`` of ``Dot`` products:

```wl
In[1]:= ArrayExpand[Inverse[a.b.c], Element[a | b | c, Matrices[{n, n}]]]

Out[1]= Inverse[c].Inverse[b].Inverse[a]

In[2]:= ArrayExpand[Adjugate[a.b.c], Element[a | b | c, Matrices[{n, n}]]]

Out[2]= Adjugate[c].Adjugate[b].Adjugate[a]
```

---

``Transpose``, ``Conjugate`` and ``ConjugateTranspose`` of ``Inverse``, ``Adjugate`` and ``PseudoInverse`` :

```wl
In[1]:= ArrayExpand[Transpose[Inverse[a]]]

Out[1]= Inverse[(Transpose[a])]

In[2]:= ArrayExpand[Conjugate[Inverse[a]]]

Out[2]= Inverse[Conjugate[a]]

In[3]:= ArrayExpand[ConjugateTranspose[Inverse[a]]]

Out[3]= Inverse[(a^†)]

In[4]:= ArrayExpand[Transpose[Adjugate[a]]]

Out[4]= Adjugate[Transpose[a]]

In[5]:= ArrayExpand[Conjugate[Adjugate[a]]]

Out[5]= Adjugate[Conjugate[a]]

In[6]:= ArrayExpand[ConjugateTranspose[Adjugate[a]]]

Out[6]= Adjugate[a^†]

In[7]:= ArrayExpand[Transpose[PseudoInverse[a]]]

Out[7]= PseudoInverse[Transpose[a]]

In[8]:= ArrayExpand[Conjugate[PseudoInverse[a]]]

Out[8]= PseudoInverse[Conjugate[a]]

In[9]:= ArrayExpand[ConjugateTranspose[PseudoInverse[a]]]

Out[9]= PseudoInverse[a^†]
```

---

``Transpose``, ``Conjugate`` and ``ConjugateTranspose`` of ``MatrixPower`` :

```wl
In[1]:= ArrayExpand[Transpose[MatrixPower[a, -7]]]

Out[1]= MatrixPower[Transpose[a], -7]

In[2]:= ArrayExpand[Conjugate[MatrixPower[a, 3]]]

Out[2]= MatrixPower[Conjugate[a], 3]

In[3]:= ArrayExpand[ConjugateTranspose[MatrixPower[a, 5]]]

Out[3]= MatrixPower[a^†, 5]
```

---

``Transpose``, ``Conjugate`` and ``ConjugateTranspose`` of ``MatrixExp`` :

```wl
In[1]:= ArrayExpand[Transpose[MatrixExp[a]]]

Out[1]= MatrixExp[Transpose[a]]

In[2]:= ArrayExpand[Conjugate[MatrixExp[a]]]

Out[2]= MatrixExp[Conjugate[a]]

In[3]:= ArrayExpand[ConjugateTranspose[MatrixExp[a]]]

Out[3]= MatrixExp[a^†]
```

---

``Transpose`` and ``ConjugateTranspose`` of ``Dot`` products:

```wl
In[1]:= ArrayExpand[Transpose[a.b.c], Element[a | b | c, Matrices[{n, n}]]]

Out[1]= Transpose[c].Transpose[b].Transpose[a]

In[2]:= ArrayExpand[ConjugateTranspose[a.b.c], Element[a | b | c, Matrices[{n, n}]]]

Out[2]= c^†.b^†.a^†
```

---

``MatrixPower`` of a linear combination:

```wl
In[1]:= ArrayExpand[MatrixPower[2a + 3b, 3]]

Out[1]= 18 a.MatrixPower[b, 2] + 12 b.MatrixPower[a, 2] + 12 MatrixPower[a, 2].b + 18 MatrixPower[b, 2].a + 12 a.b.a + 18 b.a.b + 8 MatrixPower[a, 3] + 27 MatrixPower[b, 3]
```

---

Negative exponent ``MatrixPower`` of a ``Dot`` product:

```wl
In[1]:= ArrayExpand[MatrixPower[a.b, -3], Element[a | b, Matrices[{n, n}]]]

Out[1]= MatrixPower[Inverse[b].Inverse[a], 3]
```

---

``Tr`` of ``Dot`` products:

```wl
In[1]:= ArrayExpand[Tr[b.a.Inverse[b]], Element[a | b, Matrices[{n, n}]]]

Out[1]= Tr[a]

In[2]:= ArrayExpand[Tr[Inverse[b].a.b], Element[a | b, Matrices[{n, n}]]]

Out[2]= Tr[a]

In[3]:= ArrayExpand[Tr[b.c.a], Element[a | b | c, Matrices[{n, n}]]]

Out[3]= Tr[a.b.c]

In[4]:= ArrayExpand[Tr[a.(Transpose[b]c)], Element[a | b | c, Matrices[{n, n}]]]

Out[4]= Tr[(a b).c]
```

---

``Det`` composed with matrix operations:

```wl
In[1]:= ArrayExpand[Det[3a], Element[a, Matrices[{n, n}]]]

Out[1]= 3^n Det[a]

In[2]:= ArrayExpand[Det[Transpose[a]]]

Out[2]= Det[a]

In[3]:= ArrayExpand[Det[Conjugate[a]]]

Out[3]= Conjugate[Det[a]]

In[4]:= ArrayExpand[Det[ConjugateTranspose[a]]]

Out[4]= Conjugate[Det[a]]

In[5]:= ArrayExpand[Det[Inverse[a]]]

Out[5]= (1/Det[a])

In[6]:= ArrayExpand[Det[Adjugate[a]], Element[a, Matrices[{n, n}]]]

Out[6]= Det[a]^-1 + n

In[7]:= ArrayExpand[Det[MatrixPower[a, 7]]]

Out[7]= Det[a]^7
```

---

``Det`` of ``Dot`` products:

```wl
In[1]:= ArrayExpand[Det[b.a.Inverse[b]]]

Out[1]= Det[a]

In[2]:= ArrayExpand[Det[Inverse[b].a.b]]

Out[2]= Det[a]

In[3]:= ArrayExpand[Det[a.b.c], Element[a | b | c, Matrices[{n, n}]]]

Out[3]= Det[a] Det[b] Det[c]
```

---

Matrix operations with ``KroneckerProduct`` arguments:

```wl
In[1]:= ArrayExpand[Transpose[KroneckerProduct[a, b, c]], Element[a | b | c, Matrices[{m, n}]]]

Out[1]= KroneckerProduct[Transpose[a], Transpose[b], Transpose[c]]

In[2]:= ArrayExpand[ConjugateTranspose[KroneckerProduct[a, b, c]], Element[a | b | c, Matrices[{m, n}]]]

Out[2]= KroneckerProduct[a^†, b^†, c^†]

In[3]:= ArrayExpand[Inverse[KroneckerProduct[a, b, c]], Element[a | b | c, Matrices[{n, n}]]]

Out[3]= KroneckerProduct[Inverse[a], Inverse[b], Inverse[c]]

In[4]:= ArrayExpand[PseudoInverse[KroneckerProduct[a, b, c]], Element[a | b | c, Matrices[{m, n}]]]

Out[4]= KroneckerProduct[PseudoInverse[a], PseudoInverse[b], PseudoInverse[c]]

In[5]:= ArrayExpand[Tr[KroneckerProduct[a, b, c]], Element[a | b | c, Matrices[{n, n}]]]

Out[5]= Tr[a] Tr[b] Tr[c]

In[6]:= ArrayExpand[KroneckerProduct[a, b].KroneckerProduct[c, d].KroneckerProduct[e, f], Element[a | b | c | d | e | f, Matrices[{n, n}]]]

Out[6]= KroneckerProduct[a.c.e, b.d.f]

In[7]:= ArrayExpand[Det[KroneckerProduct[a, b, c]], Element[a, Matrices[{k, k}]] && Element[b, Matrices[{m, m}]] && Element[c, Matrices[{n, n}]]]

Out[7]= Det[a]^m n Det[b]^k n Det[c]^k m

In[8]:= ArrayExpand[MatrixPower[KroneckerProduct[a, b, c], k], Element[a | b | c, Matrices[{n, n}]] && Element[k, Integers]]

Out[8]= KroneckerProduct[MatrixPower[a, k], MatrixPower[b, k], MatrixPower[c, k]]

In[9]:= ArrayExpand[KroneckerProduct[a, b, KroneckerProduct[c, d], e], Element[a | b | c | d | e, Matrices[{m, n}]]]

Out[9]= KroneckerProduct[a, b, c, d, e]
```

---

Expressions involving ``MatrixExp`` :

```wl
In[1]:= ArrayExpand[MatrixExp[a.b.Inverse[a]]]

Out[1]= a.MatrixExp[b].Inverse[a]

In[2]:= ArrayExpand[MatrixExp[k a], Element[k, Integers]]

Out[2]= MatrixPower[MatrixExp[a], k]

In[3]:= ArrayExpand[MatrixExp[(s + t)a], Element[s | t, Complexes]]

Out[3]= MatrixExp[a s].MatrixExp[a t]

In[4]:= ArrayExpand[Det[MatrixExp[a]]]

Out[4]= E^Tr[a]
```

#### Vector Operations (4)

``Transpose`` of a vector:

```wl
In[1]:= ArrayExpand[Transpose[v], Element[v, Vectors[n]]]

Out[1]= v
```

---

Canonicalize ``Dot`` products of vectors and matrices:

```wl
In[1]:= ArrayExpand[w.v, Element[v | w, Vectors[n]]]

Out[1]= v.w

In[2]:= ArrayExpand[v.a, Element[v, Vectors[n]] && Element[a, Matrices[{n, m}]]]

Out[2]= Transpose[a].v

In[3]:= ArrayExpand[v.a.w, Element[v | w, Vectors[n]] && Element[a, Matrices[{n, n}]]]

Out[3]= Transpose[a].v.w

In[4]:= ArrayExpand[a.v.b, Element[v, Vectors[n]] && Element[a, Matrices[{m, n}]] && Element[b, Matrices[{m, p}]]]

Out[4]= Transpose[b].a.v

In[5]:= ArrayExpand[a.v.b.w, Element[v, Vectors[n]] && Element[w, Vectors[p]] && Element[a, Matrices[{m, n}]] && Element[b, Matrices[{m, p}]]]

Out[5]= Transpose[b].a.v.w
```

---

``Transpose`` of ``KroneckerProduct`` :

```wl
In[1]:= ArrayExpand[Transpose[KroneckerProduct[u, v]], Element[u, Vectors[m]] && Element[v, Vectors[n]]]

Out[1]= KroneckerProduct[v, u]
```

---

``Cross`` products:

```wl
In[1]:= ArrayExpand[Cross[a, b, c].Cross[d, e, f]]

Out[1]= -a.f b.e c.d + a.e b.f c.d + a.f b.d c.e - a.d b.f c.e - a.e b.d c.f + a.d b.e c.f

In[2]:= ArrayExpand[Cross[a, b, Cross[u, v, w, z], c]]

Out[2]= -z a.w b.v c.u + w a.z b.v c.u + z a.v b.w c.u - v a.z b.w c.u - w a.v b.z c.u + v a.w b.z c.u + z a.w b.u c.v - w a.z b.u c.v - z a.u b.w c.v + u a.z b.w c.v + w a.u b.z c.v - u a.w b.z c.v - z a.v b.u c.w + v a.z b.u c.w + z a.u b.v c.w - u a.z b.v c.w - v a.u b.z c.w + u a.v b.z c.w + w a.v b.u c.z - v a.w b.u c.z - w a.u b.v c.z + u a.w b.v c.z + v a.u b.w c.z - u a.v b.w c.z
```

#### Simplifications (10)

Simplifications of ``Inverse`` :

```wl
In[1]:= ArrayExpand[Inverse[Inverse[a]]]

Out[1]= a

In[2]:= ArrayExpand[a.Inverse[a], Element[a, Matrices[{n, n}]]]

Out[2]= SymbolicIdentityArray[{n}]

In[3]:= ArrayExpand[Inverse[a].a.b]

Out[3]= b

In[4]:= ArrayExpand[b.a.Inverse[a]]

Out[4]= b
```

---

Simplifications of ``PseudoInverse`` :

```wl
In[1]:= ArrayExpand[PseudoInverse[PseudoInverse[a]]]

Out[1]= a

In[2]:= ArrayExpand[a.PseudoInverse[a].a]

Out[2]= a

In[3]:= ArrayExpand[ConjugateTranspose[PseudoInverse[a].a]]

Out[3]= PseudoInverse[a].a

In[4]:= ArrayExpand[ConjugateTranspose[a.PseudoInverse[a]]]

Out[4]= a.PseudoInverse[a]

In[5]:= ArrayExpand[ConjugateTranspose[a].a.PseudoInverse[a]]

Out[5]= a^†

In[6]:= ArrayExpand[PseudoInverse[a].a.ConjugateTranspose[a]]

Out[6]= a^†

In[7]:= ArrayExpand[ConjugateTranspose[a].ConjugateTranspose[PseudoInverse[a]].PseudoInverse[a]]

Out[7]= PseudoInverse[a]

In[8]:= ArrayExpand[PseudoInverse[ConjugateTranspose[a].a]]

Out[8]= PseudoInverse[a].PseudoInverse[a^†]
```

---

Simplifications of ``Adjugate`` :

```wl
In[1]:= ArrayExpand[Adjugate[Adjugate[a]], Element[a, Matrices[{n, n}]]]

Out[1]= a Det[a]^-2 + n

In[2]:= ArrayExpand[Adjugate[Inverse[a]]]

Out[2]= (a/Det[a])

In[3]:= ArrayExpand[Inverse[Adjugate[a]]]

Out[3]= (a/Det[a])

In[4]:= ArrayExpand[a.Adjugate[a], Element[a, Matrices[{n, n}]]]

Out[4]= Det[a] SymbolicIdentityArray[{n}]

In[5]:= ArrayExpand[Adjugate[a].a, Element[a, Matrices[{n, n}]]]

Out[5]= Det[a] SymbolicIdentityArray[{n}]

In[6]:= ArrayExpand[a.Adjugate[a].b]

Out[6]= b Det[a]
```

---

Simplifications of ``MatrixPower`` :

```wl
In[1]:= ArrayExpand[MatrixPower[a, 1]]

Out[1]= a

In[2]:= ArrayExpand[MatrixPower[a, -1]]

Out[2]= Inverse[a]

In[3]:= ArrayExpand[MatrixPower[a, 0], Element[a, Matrices[{n, n}]]]

Out[3]= SymbolicIdentityArray[{n}]

In[4]:= ArrayExpand[MatrixPower[MatrixPower[a, k], m], Element[k | m, Integers]]

Out[4]= MatrixPower[a, k m]

In[5]:= ArrayExpand[MatrixPower[Inverse[a], k], Element[k, Integers]]

Out[5]= MatrixPower[a, -k]

In[6]:= ArrayExpand[Inverse[MatrixPower[a, k]], Element[k, Integers]]

Out[6]= MatrixPower[a, -k]

In[7]:= ArrayExpand[a.MatrixPower[b, k].b]

Out[7]= a.MatrixPower[b, 1 + k]

In[8]:= ArrayExpand[a.MatrixPower[b, k].MatrixPower[b, m].c]

Out[8]= a.MatrixPower[b, k + m].c
```

---

Simplifications of ``Transpose``, ``Conjugate`` and ``ConjugateTranspose`` :

```wl
In[1]:= ArrayExpand[Transpose[a, {1, 2, 3}]]

Out[1]= a

In[2]:= ArrayExpand[Transpose[a, 1 <-> 2]]

Out[2]= Transpose[a]

In[3]:= ArrayExpand[Transpose[a, Cycles[{{2, 1}}]]]

Out[3]= Transpose[a]

In[4]:= ArrayExpand[ConjugateTranspose[a, {2, 1}]]

Out[4]= a^†

In[5]:= ArrayExpand[Transpose[ConjugateTranspose[a]]]

Out[5]= Conjugate[a]

In[6]:= ArrayExpand[Conjugate[Conjugate[a]]]

Out[6]= a

In[7]:= ArrayExpand[Conjugate[Transpose[a]]]

Out[7]= a^†

In[8]:= ArrayExpand[Conjugate[ConjugateTranspose[a]]]

Out[8]= Transpose[a]

In[9]:= ArrayExpand[ConjugateTranspose[Conjugate[a], 7]]

Out[9]= Transpose[a, 7]

In[10]:= ArrayExpand[ConjugateTranspose[Transpose[a, 3], 5]]

Out[10]= ConjugateTranspose[a, 8]

In[11]:= ArrayExpand[Conjugate[a], Element[a, Arrays[{p, q, r}, Reals]]]

Out[11]= a

In[12]:= ArrayExpand[ConjugateTranspose[a], Element[a, Arrays[{p, q, r}, Reals]]]

Out[12]= Transpose[a]
```

---

Simplifications of ``SymbolicIdentityArray`` :

```wl
In[1]:= ArrayExpand[IdentityMatrix[n]]

Out[1]= SymbolicIdentityArray[{n}]

In[2]:= ArrayExpand[a.SymbolicIdentityArray[{n}]]

Out[2]= a

In[3]:= ArrayExpand[ArrayDot[a, SymbolicIdentityArray[{m, n, k}], 3]]

Out[3]= a

In[4]:= ArrayExpand[MatrixPower[SymbolicIdentityArray[{n}], k], Element[k, Integers]]

Out[4]= SymbolicIdentityArray[{n}]
```

---

Simplifications of ``TensorProduct`` :

```wl
In[1]:= ArrayExpand[TensorProduct[a, b, c, d], Element[a | c, Reals]]

Out[1]= a c b\[TensorProduct]d

In[2]:= ArrayExpand[TensorProduct[a, b, TensorContract[c, {{1, 3}, {2, 5}}], d], Element[a, Vectors[n]] && Element[b, Arrays[{p, q, r}]]]

Out[2]= TensorContract[a\[TensorProduct]b\[TensorProduct]c\[TensorProduct]d, {{5, 7}, {6, 9}}]

In[3]:= ArrayExpand[TensorProduct[a, b, Transpose[c], d], Element[a, Vectors[n]] && Element[b, Arrays[{p, q, r}]]]

Out[3]= Transpose[(a\[TensorProduct]b\[TensorProduct]c\[TensorProduct]d), 5 \[TwoWayRule] 6]

In[4]:= ArrayExpand[TensorProduct[a, b, ConjugateTranspose[c, {3, 2, 1}], d], Element[a, Vectors[n]] && Element[b, Arrays[{p, q, r}]]]

Out[4]= Transpose[(a\[TensorProduct]b\[TensorProduct]Conjugate[c]\[TensorProduct]d), {1, 2, 3, 4, 7, 6, 5}]
```

---

Simplifications of ``Cross`` :

```wl
In[1]:= ArrayExpand[v.Cross[v, w]]

Out[1]= 0

In[2]:= ArrayExpand[Cross[a, d, c, b]]

Out[2]= -a\[Cross]b\[Cross]c\[Cross]d
```

---

Simplifications of ``TensorWedge`` :

```wl
In[1]:= ArrayExpand[TensorWedge[a, b, Transpose[c], d]]

Out[1]= -a\[TensorWedge]b\[TensorWedge]c\[TensorWedge]d

In[2]:= ArrayExpand[TensorWedge[a, b, ConjugateTranspose[c, 3 <-> 7], d]]

Out[2]= -a\[TensorWedge]b\[TensorWedge]Conjugate[c]\[TensorWedge]d
```

---

Simplifications of ``MatrixExp`` :

```wl
In[1]:= ArrayExpand[MatrixExp[MatrixLog[a]]]

Out[1]= a

In[2]:= ArrayExpand[MatrixExp[SymbolicZerosArray[{n, n}]]]

Out[2]= SymbolicIdentityArray[{n}]
```

### Options (2)

#### Assumptions (1)

Specify assumptions using the assumptions argument:

```wl
In[1]:= ArrayExpand[Det[7 a], Element[a, Matrices[{n, n}]]]

Out[1]= 7^n Det[a]
```

Use the ``Assumptions`` option:

```wl
In[2]:= ArrayExpand[Det[7a], Assumptions -> Element[a, Matrices[{n, n}]]]

Out[2]= 7^n Det[a]
```

Use ``Assuming`` to specify default assumptions:

```wl
In[3]:= Assuming[Element[a, Matrices[{n, n}]], ArrayExpand[Det[7a]]]

Out[3]= 7^n Det[a]
```

#### GenerateConditions (1)

With the default setting ``GenerateConditions -> False``, argument dimensions are quietly assumed to satisfy equations necessary for the expression to be well defined:

```wl
In[1]:=
u = VectorSymbol["u", k];
v = VectorSymbol["v", m];
w = VectorSymbol["w", n];

In[2]:= ArrayExpand[(u + v).w]

Out[2]= VectorSymbol["u", k].VectorSymbol["w", n] + VectorSymbol["v", m].VectorSymbol["w", n]
```

With ``GenerateConditions -> True``, the necessary conditions are given explicitly:

```wl
In[3]:= ArrayExpand[(u + v).w, GenerateConditions -> True]

Out[3]=
ConditionalExpression[VectorSymbol["u", k] . VectorSymbol["w", n] + 
  VectorSymbol["v", m] . VectorSymbol["w", n], -k + m == 0 && k - n == 0]
```

### Properties & Relations (1)

Use ``NonCommutativeExpand`` to expand general noncommutative polynomials:

```wl
In[1]:= NonCommutativeExpand[(a + 2b)**(3a + 4b)]

Out[1]= 3 GeneralizedPower[NonCommutativeMultiply, a, 2] + 8 GeneralizedPower[NonCommutativeMultiply, b, 2] + 4 a**b + 6 b**a
```

Specify names for addition and multiplication operations:

```wl
In[2]:= alg = NonCommutativeAlgebra[<|"Multiplication" -> mult, "Addition" -> add|>];

In[3]:= NonCommutativeExpand[mult[add[a, 2b], add[3a, 4b]], alg]

Out[3]= add[3 GeneralizedPower[mult, a, 2], 4 mult[a, b], 6 mult[b, a], 8 GeneralizedPower[mult, b, 2]]
```

### Possible Issues (1)

Symbolic arguments of unspecified dimensionality are not assumed to be scalars:

```wl
In[1]:= ArrayExpand[Transpose[c MatrixSymbol["A", {m, n}]]]

Out[1]= Transpose[c] Transpose[(MatrixSymbol["A", {m, n}])]
```

Use assumptions to specify that ``c`` is a scalar:

```wl
In[2]:= ArrayExpand[Transpose[c MatrixSymbol["A", {m, n}]], Element[c, Complexes]]

Out[2]= c Transpose[(MatrixSymbol["A", {m, n}])]
```

## See Also

* [`ArraySimplify`](https://reference.wolfram.com/language/ref/ArraySimplify.en.md)
* [`ComponentExpand`](https://reference.wolfram.com/language/ref/ComponentExpand.en.md)
* [`TensorExpand`](https://reference.wolfram.com/language/ref/TensorExpand.en.md)
* [`Expand`](https://reference.wolfram.com/language/ref/Expand.en.md)
* [`TensorReduce`](https://reference.wolfram.com/language/ref/TensorReduce.en.md)
* [`NonCommutativeExpand`](https://reference.wolfram.com/language/ref/NonCommutativeExpand.en.md)
* [`Simplify`](https://reference.wolfram.com/language/ref/Simplify.en.md)

## Related Guides

* [Symbolic Vectors, Matrices and Arrays](https://reference.wolfram.com/language/guide/SymbolicArrays.en.md)

## History

* [Introduced in 2025 (14.2)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn142.en.md)