# Smooth Measure

I'll begin with a deliberately hazy outline of what integration is; which should be recognizable to anyone who has met one or another formalization of it. From there I'll meander in search of the natural way of describing measures on a smooth manifold.

Integration over a domain A is a linear operator which takes any mapping f from A to any linear space, V, and yields integral(:f|A), a member of some linear space, typically resembling V but possibly obtained from V by some application of tensor algebra. Even when the answer is in V its units acquire some contributions from the integration: if A is a three-dimensional space, integral(:f|A)'s units are the units of f's outputs times volume. When V is one-dimensional, the integral of f falls in a one-dimensional space. In general, a linear operator of this kind is described as a measure: we generally call on integration to have some further properties which relate it to differentiation and to notions of length, area, volume, etc.

Various theorems concerning integration (lumped together, in my jumbled memory under the name Stokes' theorem) assert that integrating the derivative of some field, v, over the interior of a region gives the same answer as integrating v itself over the boundary of the region. These generalize the one-dimensional case, where integral(: x' :from a to b) = x(b) −x(a) when x' is the derivative of x. On a smooth manifold, we have some freedom in our choice of differential operator, so one must address issues of how (if at all) integration depends on choice of differential operator.

Integrating the constant scalar function 1 over a region gives its volume; when the region is suitably cuboid, this volume is the result of multiplying the lengths of the sides of the cubes. Lengths are obtained from the metric, so this links integration to the metric. In general relativity, the differential operator we use is the one which annihilates the metric; i.e. the metric (which, in orthodox notation, raises and lowers indices) is constant in the eyes of the chosen differential operator. Integration will thus depend on the metric, possibly via the differential operator which considers the metric constant.

Now, integral(V:f|A) involves adding f's outputs (or some suitably tensor rearrangement thereof, characterizing our integration). When A is a smooth manifold, (at least) some of the things we want to integrate are tensor fields; whose outputs, given different inputs in A, are all of one rank but in different vector spaces, namely the given rank's expression at the given input point. We thus have no proper means of adding such values; this would appear to restrict us to integrating scalar fields, yet Stokes' theorem seems to tell us that we can at least integrate, over an interior, the derivative of anything we can integrate over a boundary. We shall get round this, fear not.

Now, if A is a linear space of finite dimension and V is {scalars}, for simplicity, suppose we have an isomorphism (not necessarily linear) (B|j|A). Then (it is an orthodox truth that) integral(V:f|A) can be re-written as integral(V:g|B) where g∘j = f.J, i.e. for each a in A, g(j(a)) = f(a).J(a), in which J(a) is the determinant of j's derivative at a; J is known as the Jacobian (give or take spelling). This will unravel to reveal what we need to see on a smooth manifold.

## Repeated tensor products, permutations and antisymmetry

See alternating forms for a somewhat more formal treatment of approximately the same material as here, excluding the determinant.

Given any linear space L and natural n, tensor algebra builds for us the space of ({L}:|n)-rank tensors as span(| product :{lists (L:|n)}) where product is the bulk action of the tensor multiplication – when v = [a,…,z], product(v) is a×…×z – and span is the linear completion operator (applied to collections above, but generally defined on relations by):

• span(U:f:V) = (U: sum(h.u) ← sum(h.v); natural n, lists ({scalars}:h|n), (U:u|n), (V:v|n), with f∘v subsuming u :V)

Having f∘v subsume u implies that, for each i in n, f relates u(i) to v(i). When f is a mapping, its span is the minimal linear relation that subsumes it; it is the linear extension of f. When f is an identity (i.e. a sub-collection of V, simplifying the above because u and v must then be equal, so that an atomic relation (: sum(h.u)←sum(h.v) :) is just the collection {sum(h.v)}) we get f = (f: x←x :) and this simplifies to

• span(f: x←x :) = { sum(: h.v |m): m natural, ({scalars}:h|m) and (f:v|m) are lists }

A (natural) permutation is a one-to-one mapping from a natural to itself, i.e. a list (n|s|n), in which each i in n is s(k) for exactly one k in n. For any given natural n, the permutations (n|s|n) form a group – the identity is n itself, construed as the mapping (n| i←i |n), and a permutation's inverse is simply its reverse (as a relation). Any permutation other than the identity must have at least two inputs which aren't fixed points, i.e. which it maps to something other than themselves; a permutation with only two non-fixed values must swap those values; so I'll call it a swap (avoiding orthodoxy's use of transposition, overloaded with other meanings). Any permutation may be factorized as the composite of a sequence of swaps; whether the sequence's length is odd or even depends only on the permutation thus factorized; permutations are thus described as odd or even according as their swap-factorization' sequences' lengths are odd or even. This implies the existence of a natural group homomorphism (i.e. mapping which preserves group structure) from permutations to the group specified to have members −1 and +1, with (−1).(−1) = +1 = (+1).(+1) and (+1).(−1) = −1 = (−1).(+1); odd permutations are mapped to −1, even ones to +1.

For any list (L:v|n) and any permutation (n|s|), the composite v∘s is a list (L:|n). This enables us to define the (universal) antisymmetrization operator:

• wedge = unite({ span(: average(: sign(s).product(v∘s) ←(n|s|n) :{permutations}) ← product(L:v|n) :): natural n, linear space L})

i.e. this gives the action on the typical members of each span(| product :{lists (L:|n)}) and its action on sums of such is obtained by adding its outputs given each of the summands as input. Here average(: g :{permutations (n||n)}) = sum(g)/n! because there are n! permutations (n||n), with n! = product(:successor|n), so 0! = 1 and (1+n)! is n!.(1+n) for each natural n. The choice of scaling (i.e. average) is carefully made so as to ensure that wedge∘wedge = wedge is a projection; it acts as the identity on its outputs (and the name wedge comes from the symbol orthodoxly used, as a binary operator, in denotations for wedge's outputs; the symbol is the bottom half of a letter X but I often use ^ as it).

For each natural n and linear space L, we thus obtain the collection of wholly-antisymmetric ({L}:|n)-tensors,

• (| wedge :span(| product :{lists (L:|n)}))

which I'll slackly refer to as Wedge(n,L). If n exceeds L's dimension, this only has zero (of appropriate rank) as a member. Otherwise, if dim is L's dimension, the dimension of Wedge(n,L) is dim!/n!/(dim−n)!, the number of ways of choosing n distinct members from a collection of dim distinct objects. Note, in particular, the symmetry under dim−n ←n. For any linear map (V:f|L) and any natural n, we can induce a linear map

• span(: product(f∘v) ← product(L:v|n) :)

i.e. by applying f to each of the tensor factors in each product; this is a mapping from {({L}:|n)-rank tensors} = span(| product :{lists (L:|n)}), of which Wedge(n,L) is the antisymmetric sub-space, to the corresponding tensor space with V in place of L. Restricting this mapping to Wedge(n,L) on the right delivers a mapping (Wedge(n,V): |Wedge(n,L)), which I'll write as W(n,f).

### Determinant

Now, when n is the dimension of L, wedge(n,L) is one-dimensional; any non-zero member of wedge(n,L) serves as a basis and enables us to describe Wedge(n,L) as if it were {scalars}, with 1 representing the chosen basis member. W(n,f)'s image of this unit then determines W(n,f) entirely, since its image of anything else is implied by linearity and the representation of the given anything else as a scalar times the unit. This makes W(dimension of (:f|), f) express f as a linear map of rank (at most) one, known as the determinant of f, written det(f).

If V's dimension is less than L's, Wedge(n,V)'s only member is zero so det(f) is itself zero (because its output always is). Otherwise, Wedge(n,V) has some degrees of freedom but det(f)'s outputs still form (at most) a one-dimensional sub-space of Wedge(n,V).

When L is V, and n is their dimension, Wedge(n,V) is Wedge(n,L), which is one-dimensional. Linear maps from a one-dimensional space to itself are all scalings, i.e. effectively scalars, making det(L:f|L) a scalar. When V has the same dimension as L, Wedge(n,V) will again be one-dimensional, so the space of linear maps from Wedge(n,L) to Wedge(n,V) is one-dimensional; but it generally has no natural unit (as which the identity linear map served when V was L).

When V is dual(L) = {linear map ({scalars}:|L)}, it has the same dimension as L; hence Wedge(n,V) is also one-dimensional; furthermore, it is dual to Wedge(n, L) so the space {linear maps (Wedge(n, V): |Wedge(n, L))} is just Wedge(n, V)⊗Wedge(n, V) and det(V: f |L) lies in this space. For any non-zero b in Wedge(n, L) there is a unique q in Wedge(n, V) for which q·b = 1; we can use [b] as a basis of Wedge(n, L) and [q] as a basis of Wedge(n, V), hence [q×q] provides a basis of Wedge(n, V)⊗Wedge(n, V) and we get det(f) = F.q×q for some scalar F. If we replace b with b/h for some real h, we get h.q in place of q and det(f) = (F/h/h).(h.q)×(h.q) so F/h/h replaces F; but h.h is positive, so F hasn't changed sign. Indeed, as long as scalars are real, any non-zero member of Wedge(n, V), multiplied by itself, gives a positive multiple of q×q, there is a natural sign in Wedge(n, V)⊗Wedge(n, V), with q×q positive for all non-zero q in Wedge(n, V). Then det(f) is definitely either positive or negative; by suitably scaling q (and b), we can arrange for det(f) to be ±q×q; I'll be using this q in Wedge(n, V) as square root of ±det(f); it shall play a central rôle in integration.

The other important case is when f is the derivative of some isomorphism (j in the last section) and its determinant is the Jacobian, J. Because it's the derivative of an isomorphism, it should be expressible as a linear map between spaces of equal dimension, so f's determinant will fall in a one-dimensional space; this space will typically have no natural unit, but any choice of unit in it will reduce further discussion of it to as if it were {scalars}.

## On a smooth manifold

In particular, on a smooth manifold M of dimension dim, with gradient bundle G and tangent bundle T, the same tensor algebra (applied at each point of M) gives us Wedge(dim,G) and Wedge(dim,T) as mutually dual one-dimensional ranks of tensor on M. Among linear maps from one to the other there is no natural unit, at least until the metric gets involved, but we can distinguish positive from negative (and, as it happens, space-time's metric's determinant is a negative linear map from Wedge(dim,T) to Wedge(dim,G), but let us ignore that for now).

Suppose we have some tensor field (:f:M) with (:f|) some neighbourhood in M on which we have two charts ({lists ({scalars}:|dim)}: :M), isomorphisms between (:f|) and neighbourhoods in the canonical linear space of dimension dim – the space of lists, of scalars, with length dim. Let x and u be the associated lists of scalar fields ({smooth ({scalars}::M)}: |dim), with x's chart then being (: (: x(i,m) ←i |dim) ←m :M) and likewise for u (in the language of relations, each chart is the transpose of its list of scalar fields). Let X = (|x:(:f|)) and U = (|u:(:f|)) be the neighbourhoods in {lists ({scalars}:|dim)} over which our co-ordinates vary and note that (X| x∘reverse(u) |U) is one-to-one and smooth.

Now, each i in dim = {0,…,dim−1} gives us a scalar field x(i), to which we can apply the canonical structural map from scalar fields to gradient fields, local differentiation: each dx(i) is a gradient field. Because we obtained x and u from charts (by transposition as relations), the list of gradients (G: dx |dim) is a basis of G; as is (G: du |dim). From each basis of G we instantly obtain a basis of Wedge(dim,G), whose single member is wedge(product(dx)) or wedge(product(du)) as appropriate. We can also construct the dual bases of T, namely (T:p|dim) and (T:q|dim) specified by: dx(i)·p(k) = du(i)·q(k) is 0 unless i = k, in which case it's 1. These in turn give us wedge(product(p)) and wedge(product(q)) as the single members of corresponding bases of Wedge(dim,T).

These bases allow us to express the identity on G as sum(: du×q |dim) and as sum(: dx×p |dim), with likewise sum(:q×du:) = T = sum(: p(i)×dx(i) ←i |dim). Composing the last two, we obtain this identity as T = sum(: sum(: q(k)×dx(i).(du(k)·p(i)) ←i |dim) ←k |dim). Applying this to a member of T, each dx(i) extracts the tangent's i-component in x's chart; multiplying by du(k)·p(i) and summing over i gives the co-efficient of q(k) in the above T's image of the tangent, which is the tangent itself; thus du(k)·p(i) provides the matrix with which to convert x's chart's co-ordinates to those of u's chart, for tangents.

From each chart we also obtain differential operators, d/dx and d/du, induced (via the product rule and the requirement that each agree with d on scalar fields) from their actions on G, specified by:

• (: d/dx :G) = (: sum(: dx(i)×d(v·p(i)) ←i |dim) ←v :)

and likewise for d/du, with q in place of p. For v in G, v·p(i) is a scalar field, to which we apply d and then tensor with dx(i), the basis member dual to p(i). When consequences of the product rule and agreement with d on scalar fields are followed through, d/dx and d/du emerge as coordinate differentiation in its orthodox sense. For a scalar field h, the list commonly written dh/dx = ({scalar fields}: dh/dx(i) ←i |dim) gives dh = sum(: dx(i).dh/dx(i) ←i |dim) while, since G = sum(: dx×p :), dh = sum(: dx(i).(p(i)·dh) ←i |dim), so what might orthodoxly have been written as dh/dx(i) becomes p(i)·dh = p(i)·(d/dx)(h). This gives us du(k)/dx(i) as p(i)·du(k), coinciding with the co-ordinate transformation discussed above.

Now, whatever rank (|f:) may be, either chart gives us co-ordinates for it; and allows us to integrate those coordinates over X or U as appropriate. We should get the same answer regardless of which chart we use; we can use x∘reverse(u) as an isomorphism (X|j|U); its derivative is the matrix of coordinates dx(i)/du(k) expressed as above by q(k)·dx(i), with determinant J = wedge(product(q))·wedge(product(dx)) when we go from integrating over (|x:) to over (|u:).

So, with F as some (scalar) co-ordinate of f in x's chart, integral(:F:X) becomes integral(:F.J:U) = integral(: (F.wedge(product(dx)))·wedge(product(q)) :U) and doesn't depend on choice of chart; q and U are characteristic of u but dx and F are mere artifacts of which other chart, x, we involved; whence we may infer that F.wedge(product(dx)) is the tensor quantity the co-ordinate F encoded, i.e. f = F.wedge(product(dx)). Thus integration over U of f·wedge(product(q)) gives the same as integration over X of F = f·wedge(product(p)), with q and p being the bases of tangents dual to the bases du and dx (respectively) induced by the charts.

Thus the rank of tensor field we can integrate over a neighbourhood in a smooth manifold is Wedge(dim,G). The volume of a suitably cuboid region is just the product of the lengths of its sides; if we sheer it to get a rhomboid, effectively adding, to one of the edges, some linear combination of the other edges, we don't change the volume. The antisymmetric product of the tangents pointing along edges also doesn't change when one does such a sheer (because the antisymmetrization causes the change to cancel itself out); so the volume of a suitably rhomboid region is a wholly antisymmetric multilinear function of its edge tangents; i.e. volume is obtained by integrating a linear map from Wedge(dim,T) to some one-dimensional linear domain, V, independent of position on the manifold (effectively scalars, tagged in some way with suitable units of measurement). The tensor field being integrated is thus linear (V:|Wedge(dim,T)) or, equivalently, V⊗Wedge(dim,G) since G and T are dual to one another. This lets us ignore V hereafter; we can replace it with an arbitrary linear space external to the manifold, adding no complications (unless it leads us into extending our scalars to include imaginary values).

It may help, in understanding this, to think of integration in its classical sum over many little boxes form. When integrating f over some region, we partition the region into rhomboid volumes, each small enough that we're happy to ignore f's variation therewithin; this typically means each rhomboid is small. Classically, each box contributes to the integral to an extent proportional to f's (functionally constant) value within the box and proportional to the size of the box. Our f in Wedge(dim,G) formalizes this by being a multi-linear antisymmetric map taking dim tangents, the displacement (tangent) vectors along the edges of the box, and returning a scalar: integration then sums the scalars from all the rhomboids to give a scalar integral of f over the union of the boxes.

The sides of a small enough box are functionally tangent vectors. To be integrable a function has to be able to give us a scalar for each such box; the scalar must vary linearly with each edge tangent (so as to be proportional to the size of the box) and combine the edges antisymmetrically (so as to be unchanged by sheering). Hence the integrable function must be a function from dim tangents to scalars, linear in each tangent and antisymmetric; which is exactly the specification of the members of Wedge(dim,G).

### Sub-Manifolds

Thus the only rank of tensor to be considered for integration over a manifold with dimension dim and gradient bundle G is Wedge(dim,G). Of course, on a sub-manifold of lower dimension, we'll replace G with the gradient bundle of the sub-manifold (which looks like a sub-space of G, at each point on the sub-manifold: though, strictly, the sub-manifold's tangent bundle is a sub-space of T at each point but its gradient bundle is the quotient of G by the members of G which map all the sub-manifold's tangents to zero) and dim with its dimension; which will allow us to integrate Wedge(n,G) fields over a sub-manifold of dimension n, albeit only seeing the sub-manifold's quotient of G in the process.

Consider the action of f in Wedge(dim,G) on {({G}:|n)-rank tensors} with n in {0,…,dim}. Wedge(dim,G) is a sub-space of {({G}:|dim)-rank tensors} which the tensor algebra will readily interpret as the space of linear maps from {({T}:|n)-rank tensors} to {({G}:|dim−n)-rank tensors}; read as such, f's outputs are all in Wedge(dim−n,G) and it consumes its input antisymmetrically, i.e. f = f∘wedge. Now, Wedge(dim−n,G) and Wedge(n,T) have equal dimension; so long as f is non-zero it has an inverse, namely the single member of the basis of Wedge(dim,T) which is dual to [f] as basis of Wedge(dim,G). Thus f, when non-zero, provides an isomorphism (Wedge(n,T)| |Wedge(dim−n,G)) for each n in {0,…,dim}. Any other member of Wedge(dim,G) is just f times (at each point) some scalar field: so choice of f only affects the isomorphism's scale, not its understanding of which direction is which.

So a tensor field we can integrate over a manifold provides an isomorphism between Wedge(n,G), whose fields are integrable over sub-manifolds of dimension n, and Wedge(dim−n,T); indeed, it will equip us with the means to turn any ({T}:|n)-rank tensor field on M, not just the Wedge(n,T) ones, into something we can integrate over sub-manifolds of dimension dim−n, otherwise known as sub-manifolds of co-dimension n.

### The metric's determinant's square root

Now, the metric is linear from T to G, making its rank span({u×v: u, v in G}) or G⊗G. Its determinant is linear (Wedge(dim,G): det(g) |Wedge(dim,T)) with rank Wedge(dim,G)⊗Wedge(dim,G). The metric is symmetric; g(x,y) = g(y,x) for all tangents x, y; g(x) is in G, which is {linear ({scalars}:|T)} = dual(T), so g(x,y) is a scalar, as is g(y,x). We saw above that det(g) = ±m×m for some m in Wedge(dim,G); as such it is inevitably symmetric.

It would appear we are interested in a universe with an odd number of time-like dimensions and an odd number of space-like ones; so, whichever you consider imaginary, det(g) is negative. In particular, I'll assume det(g)'s sign doesn't change; and that we can have a Wedge(dim,G)-rank tensor field m with det(g) = ±m×m and m nowhere zero: this formally expresses the idea that the manifold is orientable, but that's a matter for some other time. [And it turns out that det(g) being negative isn't a problem – phew !^]

Now, m is in Wedge(dim,G); it's an integrable tensor field. The differential operator we use considers g to be constant, hence equally considers det(g) and so m×m to be constant. Since Wedge(dim,G) is one-dimensional, m must thus also be constant (in the eyes of our differential operator). Thus our constant metric begets a constant tensor field to describe integration, albeit with an arbitrary global ± scaling ambiguity (since −m will do in place of m, as only their square is determined; none the less, continuity ensures that once the choice of sign is made anywhere, it's implied everywhere else).

We thus obtain a constant tensor field, m, of rank Wedge(dim,G), begetting a constant tensor field, 1/m, in Wedge(dim,T). These provide us, as above, with an isomorphism between Wedge(n,T) and Wedge(dim−n,G) for each n from 0 to dim; these isomorphisms are constant. We can express any other tensor field of rank Wedge(dim,G), Wedge(dim,T) (or other rank derived solely from these two) in terms of a scalar field and m. In particular, det(g) is a constant (possibly negative) multiple of m×m. I'll describe the tensor field m as our measure on the smooth manifold, M.

## Boundaries and derivatives

Stokes' theorem and its kin integrate the derivative of a tensor field over a region and the field itself over the boundary. For instance, if one integrates the trace of the derivative of a tangent field – the derivative is a G⊗T tensor field, which we can read as a linear map from tangents to tangents, so it's amenable to trace – over the interior of a region, one gets the same answer as integrating the original tangent field over the boundary of the region. The trace of the tangent field's derivative is a scalar field, so scale m by it to get something we can integrate over the region; likewise, we can use m to turn the tangent field itself into a Wedge(dim−1,G) field, which we can integrate over the sub-manifold of co-dimension 1 which constitutes the boundary. [The other familiar case integrates a gradient field along a curve, its derivative over a submanifold of dimension 2 spanning that curve; this is just the prior case applied to a 2-manifold of which the given spanning surface is a region.]

Let D be our differential operator, t our tangent field; Dt is of such a rank that, at least at each point, it may be written as a sum of terms of form w×u with w in G, u in T; trace(Dt) is the sum of the scalars w(u) one obtains by tracing each such term; although one may decompose Dt in many ways as a sum of such terms, all will give the same sum of scalars. We're integrating Dt·m and m is constant, so this is equal to D(t·m); and t·m is what we're integrating over the boundary.

### Antisymmetric differentiation

Now, everything we're going to integrate will be totally antisymmetrized, so what happens to derivatives when one does that ? We only need to look at Wedge(n,G) for n from 0 to dim; and antisymmetrization has no effect on G itself, which is the rank of gradients of scalar fields; so the antisymmetrized derivative will agree with d on {scalar fields} = Wedge(0,G), no matter what differential operator we chose. Furthermore, if we differentiate a scalar field twice and antisymmetrize, we get zero (provided our differential operator is torsion-free).

Any tensor in {({G}:|n)-rank tensors} may be written as a sum of terms of form x(0).product(: dx(1+i) ←i |n) for some list ({scalar fields}: x |1+n) of scalar fields. If we take the derivative of such a term, we get dx(0)×product(:dx(1+i)←i|n), which is just product(dx), and a sum of terms each involving a symmetric Ddx(1+i) for some i in n; when we antisymmetrize, we're left with wedge(product(dx)). Consequently, antisymmetric differentiation doesn't depend on our choice of differential operator and every tensor field it produces is a sum of terms of form wedge(product(dx)); furthermore, if x(0) had been constant the output would have been zero, so whenever the input is a sum of products of gradients of scalar fields, the output is zero; in particular, antisymmetric differentiation annihilates antisymmetric derivatives. We can thus define

• d^ = unite(: span(Wedge(1+n,G): wedge(product(dx)) ← x(0).product(G:dx(1+i)←i|n); ({scalar fields}: x |1+n) is a list :(|product:{lists (G:|n)})) ←n :{naturals})

as the antisymmetric differential operator. The case n = 0 gives d^ acting on scalar fields as d; for n = 1 we have d^(a.du) = wedge(da×du) for any scalar fields u and a; n=2 gives d^(a.dx×dy) = wedge(da×dx×dy) and so on. We know d^∘d^ is zero, albeit a different zero on each rank; (Wedge(2+n,G): d^∘d^ |span(|product:{lists (G:|n)})) is the constant mapping with output the zero of rank Wedge(2+n,G).

Now d^ maps any Wedge(dim−1,G) tensor field to a Wedge(dim,G) tensor field, which is just some scalar field times our constant measure m, since Wedge(dim,G) is one-dimensional (at each point). Furthermore, like m, each of these outputs of d^ is annihilated by d^; so it would be nice to express m as one of these outputs of d^, i.e. m = d^w for some tensor field w of rank Wedge(dim−1,G), whose dimension at each point is dim. There may, of course, be many such w; but d^ maps the differences between them to 0.m; indeed, adding the d^ of any Wedge(dim−2,G) tensor field to w will turn one solution into another.

We thought we wanted to integrate a divergence, trace(Dt) for some tangent field t, which turns out to be really m.trace(Dt); so how does this relate to d^(m·t) ? As before, express m as x(0).wedge(product(: dx(1+i) ←i |dim)) for some list ({scalar fields}: x |1+dim). This yields

• m·t = average(: sign(s).x(0).dx(1+s(dim−1))·t.product(: dx(1+s(i)) ←i |dim−1) ← (dim| s |dim) :{permutations})

To apply d^ to a term in this average we only need to differentiate the scalar field x(0).dx(1+s(dim−1))·t (the results of differentiating the rest will have symmetries). Furthermore, when we express this derivative in terms of the basis (G: dx(1+i) ←i |dim), we can ignore all terms except the multiple of dx(1+s(dim−1)), since each of the others is parallel to dx(1+s(j)) for some j other than dim−1, and this dx(1+s(j)) appears in product(: dx(1+s(i)) ←i :dim−1), so the wedge applied, after D, by d^ will annihilate it. Let (T: p |dim) be the basis dual to (G: dx(1+i) ←i |dim), so p(j)·dx(1+i) is 0 unless j = i, in which case it's 1. Then t = sum(T: p(i).dx(1+i)·t ←i |dim) and we know we're only interested, with j = s(dim−1), in

p(j)·D(x(0).dx(1+j)·t)
= p(j)·dx(0).dx(1+j)·t + x(0).p(j)·D(dx(1+j)·t)

so, at the very least, if we can arrange for x(0) to be constant (in which case we can arrange for it to be 1) we get p(j)·D(dx(1+j)·t), which is the j-component of the D-derivative of the j-component of t: i.e. the j-indexed term in the sum making up trace(Dt).

In the presence of a metric, we can convert any tensor to a pure-G rank, which is amenable to d^. If we then use the metric's inverse to convert back to T those rank factors we had to apply the metric to before, we get a tensor whose rank is just G tensored with the rank we started with; thus we can use d^ and a metric to define something very like a differential operator (i.e. an operator of rank G whose action on scalar fields coincides with d); but this operator isn't a Leibniz operator since d^(u×v) isn't (d^u)×v plus a suitably permuted u×(d^v); instead, it's the result of antisymmetrizing this sum.

Written by Eddy.