(Anti)Symmetrization of Tensors
Levi-Civita Symbol

Permutations

The Function Permutations[list] gives all possible permutations of the elements in the list

Permutations[{1,2,3}]

Permutations[{μ,ν,ρ}]

Signature[list] gives the signature of the permutation needed to place the elements of list in canonical order: (see the function Sort for definition of canonical order)

Print[Signature[{2,3,1}]," ",Signature[{2,1,3}]]

Print[Signature[{μ,ν,ρ}]," ",Signature[{μ,ρ,ν}]]

Signature must be applied to all elements of the list to give their signature.
Use Map[perm3,Signature] or the equivalent Signature /@ perm3

perm3 = Permutations[{1,2,3}]; 
Signature /@ perm3

Show the permutations together with their Signature:

Table[{perm3[[i]], Signature[perm3[[i]]]},{i,Length[perm3]}] //Column

Test whether particular permutations are even:

{Signature[{1,2,3}]==1,Signature[{1,3,2}]==1}

(Signature[#] ==1) &
is an unnamed (pure) function. Like any other function f, which takes an argument x and evaluates to f[x], it takes an argument 
(Signature[#] ==1) & [perm]
The argument perm is substituted at all positions in the expression that has a #, and evaluates to 
(Signature[perm]==1)
which is True, or False:

(Signature[#] ==1)&   [{1,2,3}]

We can map this function on all permutations:

(Signature[#] ==1) &  /@ perm3

Select even permutations:
Select[list,crit] picks out elements of the list for which crit[el] is True.

Then, Select can be used to to apply the pure function  (Signature[#] ==  1)&  to all elements in the list, and select the ones which return True:

Select[perm3,(Signature[#] ==  1)&  ]

Odd permutations:

Select[perm3,(Signature[#] ==-1)&  ]

(Anti)symmetrization

Define a permutation of all indices of a tensor:

perm3 = Permutations[{a1,a2,a3}]

The function Subscript[s,a] returns the object (Subscript[s, a]):

Subscript[s,a1]

We can add more subscripts:

Subscript[s,a1,a2,a3]

Construct all permutations of (Subscript[s, a1,a2,a3]) by applying Subscript[s,#[[1]],#[[2]],#[[3]]]& on a list {a1,a2,a3} of 3 elements. 
#[[1]] is the first element of the argument of the function, and it will be replaced by a1. Similarly for #[[2]] and #[[3]].

Subscript[s,#[[1]],#[[2]],#[[3]]]& [{a1,a2,a3}]

Since perm3 is a list of permuted objects, Subscript must be applied on each member of the list:

(Subscript[s,#[[1]], #[[2]], #[[3]]]) &  /@ perm3

We can multiply with the signature of the permutation:

signed3=(Signature[#] Subscript[s,#[[1]], #[[2]], #[[3]]]) &  /@ perm3

We can obtain the sum of those terms, by applying Plus on the list.
(the function  Apply works by replacing the head List by the head Plus)

Apply[Plus,signed3]

or equivalently:

Plus @@ signed3

Then we can write down the expression that gives the antisymmetrization  (Subscript[s, [a1 a2 a3]])

(1/3!) Plus @@ signed3

or, directly:

Plus @@ ((Signature[#] Subscript[s,#[[1]], #[[2]], #[[3]]]) &  /@ Permutations[{a1,a2,a3}])(1/3!)

Higher order tensor:

perm4 = Permutations[{a1,a2,a3,a4}];
(1/Length[perm4]) Apply[Plus, (Signature[#]Subscript[s,#[[1]], #[[2]], #[[3]],#[[4]]]) &  /@ perm4 ]

We can symmetrize or antisymmetrize tensors using the Symmetrize function. 
This is a (0,2) tensor:

t1=Array[(Subscript[A, ##])&,{2,2}];(*will Array[] explain later...*)
t1 //MatrixForm

Here, we antisymmetrize wrt to the two indices in positions 1 and 2

Symmetrize[t1,Antisymmetric[{1,2}]]//Normal//MatrixForm

Now we symmetrize:

Symmetrize[t1,Symmetric[{1,2}]]//Normal//MatrixForm

A is defined as a (0,3) tensor

t2=Array[(Subscript[A, ##])&,{3,3,3}]; 
t2 //MatrixForm

Here we antisymmetrize only indices at positions 1 and 3 to obtain (Subscript[A, [a|b|c]])

Symmetrize[t2,Antisymmetric[{1,3}]]//Normal//MatrixForm

Now compute (Subscript[A, [abc]]):
Notice that A!=0 is not evaluated to True, so we cannot Select nonzero elements this way.
Instead we use (!MatchQ[A,0]), meaning “A does not match to 0”

at2=Symmetrize[t2,Antisymmetric[{1,2,3}]]//Normal;
Select[Flatten[at2],(!MatchQ[#,0])&]//Column

Antisymmetric[{1,2,3}] gives the same result as Antisymmetric[All]

at2=Symmetrize[t2,Antisymmetric[All]]//Normal;
Select[Flatten[at2],(!MatchQ[#,0])&]//Column

Levi-Civita symbol

The function Array[f,{n1,n2}] generates a nested list of n1×n2 elements f[i1,i2]:

Array[f,{3,3}] //MatrixForm

The array (Subscript[A, ij])=i+j
Plus is applied on {i,j}, giving Plus[i,j]=i+j

Array[Plus,{3,3}] //MatrixForm

Now, define a n1×n2×n3  array:

Array[f,{2,2,2}] //MatrixForm

Array[f,{2,2,2}]

So if f is replaced by the pure function Signature, we can obtain the 3-d Levi-Civita Symbol.
Let’s do it in steps:
This is what the Array function gives: {i,j,k} -> f[i,j,k]

f[1,2,3]

But Signature needs to act on the list {i,j,k}. So we have to take the arguments 1,2,3 and form a list {1,2,3} on which the function will act.
We will use the symbol ##, which represents the sequence of all arguments supplied to a pure function and put it inside {} to form a list:

f[{##}] & [1,2,3]

So, we got what we want: A function that gives the signature of its arguments!

(Signature[{##}])& [1,2,3]

We go ahead and apply this function on the arguments given to it by Array:

Array[Signature[{##}]&,{3,3,3}] //Column

This is important, so Mathematica has already a function LeviCivitaTensor:
It is a sparse array, so we apply the function Normal to obtain an ordinary list

LeviCivitaTensor[3]//Normal  //Column

Or, obtain the same using:

LeviCivitaTensor[3,List] //Column

The cross product:

LeviCivitaTensor[3].{x1,x2,x3}.{y1,y2,y3}

Same as

Cross[{x1,x2,x3},{y1,y2,y3}]

Compute (Subscript[F, ij=])(Subscript[ϵ, ijk])(Subscript[B, k]), the spatial part of the EM tensor (Subscript[F, μν]):
First construct the tensor ϵ⊗ω          (⊗ is [Esc]t*[Esc], different from [Esc]c*[Esc] -> ⊗)

B={B1,B2,B3};
LeviCivitaTensor[3,List] ⊗ B

Same as using the function TensorProduct:

TensorProduct[LeviCivitaTensor[3,List],B]

Now we can use the function TensorContract to obtain (Subscript[ϵ, ijk])(Subscript[B, k])

TensorContract[LeviCivitaTensor[3,List] ⊗ B,{3,4}] //MatrixForm

Compute the magnetic field B=∇×A or (Subscript[B, i])=(Subscript[ϵ, ijk])(∂_j)(Subscript[A, k])       ([Esc]del[Esc]->∇, [Esc]pd[Esc]->∂, [Esc]*[Esc]->×)
Now we contract two pairs of indices:

ϵ=LeviCivitaTensor[3,List];
δ={(Subscript["∂", 1]),(Subscript["∂", 2]),(Subscript["∂", 3])}; (* use ∂ as character, not as partial derivative*)
a={(Subscript[A, 1]),(Subscript[A, 2]),(Subscript[A, 3])};
t1 = TensorProduct[ϵ,δ,a];
TensorContract[t1,{{2,4},{3,5}}]//MatrixForm

Same as:

Cross[δ,a]//MatrixForm

Prove identity (Subscript[ϵ, ijk])(Subscript[ϵ, lmk])=(Subscript[δ, il])(Subscript[δ, jm])-(Subscript[δ, im])(Subscript[δ, jl])

ϵ     =LeviCivitaTensor[3,List];
ϵϵ   =ϵ⊗ϵ;
ϵ2   =TensorContract[ϵϵ,{3,6}];
lhs = Table[ϵ2[[i,j,l,m]] -( KroneckerDelta[i,l]KroneckerDelta[j,m]-KroneckerDelta[i,m]KroneckerDelta[j,l]),{i,3},{j,3},{l,3},{m,3}];
rhs =ConstantArray[0,{3,3,3,3}]; (*a nested list filled with zeroes*)
lhs == rhs