diff --git a/Project.toml b/Project.toml
index 1150ba8..acd4093 100644
--- a/Project.toml
+++ b/Project.toml
@@ -1,7 +1,7 @@
 name = "Grassmann"
 uuid = "4df31cd9-4c27-5bea-88d0-e6a7146666d8"
 authors = ["Michael Reed"]
-version = "0.8.19"
+version = "0.8.20"
 
 [deps]
 AbstractTensors = "a8e43f4a-99b7-5565-8bf1-0165161caaea"
diff --git a/src/algebra.jl b/src/algebra.jl
index 4603046..d2db780 100644
--- a/src/algebra.jl
+++ b/src/algebra.jl
@@ -35,7 +35,7 @@ Geometric algebraic product: ω⊖η = (-1)ᵖdet(ω∩η)⊗(Λ(ω⊖η)∪L(ω
 @pure ⟑(a::Submanifold{V},b::Submanifold{V}) where V = mul(a,b)
 *(a::X,b::Y,c::Z...) where {X<:TensorAlgebra,Y<:TensorAlgebra,Z<:TensorAlgebra} = *(a*b,c...)
 
-@pure function mul(a::Submanifold{V},b::Submanifold{V},der=derive_mul(V,UInt(a),UInt(b),1,true)) where V
+@pure function mul(a::Submanifold{V},b::Submanifold{V},der=derive_mul(V,UInt(a),UInt(b),1,true),::Val{field}=Val(false)) where {V,field}
     if isdiag(V)
         ba,bb = UInt(a),UInt(b)
         (diffcheck(V,ba,bb) || iszero(der)) && (return Zero(V))
@@ -938,18 +938,20 @@ adder(a,b,op=:+) = adder(typeof(a),typeof(b),op)
             return AntiSpinor{V}(out)
         end end end
     end
-    @noinline function product(a::Type{S},b::Type{<:Chain{V,G,T}},swap=false) where S<:TensorGraded{V,L} where {V,G,L,T}
+    @noinline function product(a::Type{S},b::Type{<:Chain{V,G,T}},swap=false,field=false) where S<:TensorGraded{V,L} where {V,G,L,T}
         MUL,VEC = mulvecs(a,b)
+        vfield = Val(field)
         anti = isodd(L) ≠ isodd(G)
         type = anti ? :AntiSpinor : :Spinor
+        args = field ? (:g,) : ()
         if G == 0
             return S<:Chain ? :(Chain{V,L}(broadcast($MUL,a.v,Ref(@inbounds b[1])))) : swap ? :(Single(b)⟑a) : :(a⟑Single(b))
         elseif S<:Chain && L == 0
             return :(Chain{V,G}(broadcast($MUL,Ref(@inbounds a[1]),b.v)))
         elseif (swap ? L : G) == mdims(V) && !istangent(V)
-            return swap ? (S<:Single ? :(⋆(~b)*value(a)) : S<:Chain ? :(@inbounds a[1]*⋆(~b)) : :(⋆(~b))) : :(@inbounds ⋆(~a)*b[1])
+            return swap ? (S<:Single ? :(⋆(~b,$(args...))*value(a)) : S<:Chain ? :(@inbounds a[1]*⋆(~b,$(args...))) : :(⋆(~b,$(args...)))) : :(@inbounds ⋆(~a,$(args...))*b[1])
         elseif (swap ? G : L) == mdims(V) && !istangent(V)
-            return swap ? :(b[1]*complementlefthodge(~a)) : S<:Single ? :(value(a)*complementlefthodge(~b)) : S<:Chain ? :(@inbounds a[1]*complementlefthodge(~b)) : :(complementlefthodge(~b))
+            return swap ? :(b[1]*complementlefthodge(~a,$(args...))) : S<:Single ? :(value(a)*complementlefthodge(~b,$(args...))) : S<:Chain ? :(@inbounds a[1]*complementlefthodge(~b,$(args...))) : :(complementlefthodge(~b,$(args...)))
         elseif binomial(mdims(V),G)*(S<:Chain ? binomial(mdims(V),L) : 1)<(1<<cache_limit)
             if S<:Chain
                 $(insert_expr((:N,:t,:bng,:ib,:μ),:mvecs)...)
@@ -958,7 +960,7 @@ adder(a,b,op=:+) = adder(typeof(a),typeof(b),op)
                 for i ∈ list(1,binomial(N,L))
                     @inbounds v,ibi = :(@inbounds a[$i]),B[i]
                     for j ∈ 1:bng
-                        @inbounds (anti ? geomaddanti!_pre : geomaddspin!_pre)(V,out,ibi,ib[j],derive_pre(V,ibi,ib[j],v,:(@inbounds b[$j]),MUL))
+                        @inbounds (anti ? geomaddanti!_pre : geomaddspin!_pre)(V,out,ibi,ib[j],derive_pre(V,ibi,ib[j],v,:(@inbounds b[$j]),MUL),vfield)
                     end
                 end
             else
@@ -968,9 +970,9 @@ adder(a,b,op=:+) = adder(typeof(a),typeof(b),op)
                 for i ∈ list(1,binomial(N,G))
                     A,B = swap ? (@inbounds ib[i],U) : (U,@inbounds ib[i])
                     if S<:Single
-                        @inbounds (anti ? geomaddanti!_pre : geomaddspin!_pre)(V,out,A,B,derive_pre(V,A,B,:(a.v),:(@inbounds b[$i]),MUL))
+                        @inbounds (anti ? geomaddanti!_pre : geomaddspin!_pre)(V,out,A,B,derive_pre(V,A,B,:(a.v),:(@inbounds b[$i]),MUL),vfield)
                     else
-                        @inbounds (anti ? geomaddanti!_pre : geomaddspin!_pre)(V,out,A,B,derive_pre(V,A,B,:(@inbounds b[$i]),false))
+                        @inbounds (anti ? geomaddanti!_pre : geomaddspin!_pre)(V,out,A,B,derive_pre(V,A,B,:(@inbounds b[$i]),false),vfield)
                     end
                 end
             end
@@ -1009,11 +1011,12 @@ adder(a,b,op=:+) = adder(typeof(a),typeof(b),op)
             return $type{V}(out)
         end end
     end
-    @noinline function product_contraction(a::Type{S},b::Type{<:Chain{V,G,T}},swap=false,contr=:contraction) where S<:TensorGraded{V,L} where {V,G,T,L}
+    @noinline function product_contraction(a::Type{S},b::Type{<:Chain{V,G,T}},swap=false,field=false,contr=:contraction) where S<:TensorGraded{V,L} where {V,G,T,L}
         MUL,VEC = mulvec(a,b,contr)
+        vfield = Val(field); args = field ? (:g,) : ()
         (swap ? G<L : L<G) && (!istangent(V)) && (return Zero(V))
         if (G==0 || G==mdims(V)) && (!istangent(V))
-            return swap ? :(contraction(Single(b),a)) : :(contraction(a,Single(b)))
+            return swap ? :(contraction(Single(b),a,$(args...))) : :(contraction(a,Single(b),$(args...)))
         end
         GL = swap ? G-L : L-G
         if binomial(mdims(V),G)*(S<:Chain ? binomial(mdims(V),L) : 1)<(1<<cache_limit)
@@ -1027,9 +1030,9 @@ adder(a,b,op=:+) = adder(typeof(a),typeof(b),op)
                     @inbounds v,iai = :(@inbounds a[$i]),ia[i]
                     for j ∈ list(1,bng)
                         if μ
-                            @inbounds skewaddmulti!_pre(V,out,iai,ib[j],derive_pre(V,iai,ib[j],v,:(@inbounds b[$j]),MUL))
+                            @inbounds skewaddmulti!_pre(V,out,iai,ib[j],derive_pre(V,iai,ib[j],v,:(@inbounds b[$j]),MUL),vfield)
                         else
-                            @inbounds skewaddblade!_pre(V,out,iai,ib[j],derive_pre(V,iai,ib[j],v,:(@inbounds b[$j]),MUL))
+                            @inbounds skewaddblade!_pre(V,out,iai,ib[j],derive_pre(V,iai,ib[j],v,:(@inbounds b[$j]),MUL),vfield)
                         end
                     end
                 end
@@ -1041,15 +1044,15 @@ adder(a,b,op=:+) = adder(typeof(a),typeof(b),op)
                     A,B = swap ? (@inbounds ib[i],U) : (U,@inbounds ib[i])
                     if S<:Single
                         if μ
-                            @inbounds skewaddmulti!_pre(V,out,A,B,derive_pre(V,A,B,:(a.v),:(@inbounds b[$i]),MUL))
+                            @inbounds skewaddmulti!_pre(V,out,A,B,derive_pre(V,A,B,:(a.v),:(@inbounds b[$i]),MUL),vfield)
                         else
-                            @inbounds skewaddblade!_pre(V,out,A,B,derive_pre(V,A,B,:(a.v),:(@inbounds b[$i]),MUL))
+                            @inbounds skewaddblade!_pre(V,out,A,B,derive_pre(V,A,B,:(a.v),:(@inbounds b[$i]),MUL),vfield)
                         end
                     else
                         if μ
-                            @inbounds skewaddmulti!_pre(V,out,A,B,derive_pre(V,A,B,:(@inbounds b[$i]),false))
+                            @inbounds skewaddmulti!_pre(V,out,A,B,derive_pre(V,A,B,:(@inbounds b[$i]),false),vfield)
                         else
-                            @inbounds skewaddblade!_pre(V,out,A,B,derive_pre(V,A,B,:(@inbounds b[$i]),false))
+                            @inbounds skewaddblade!_pre(V,out,A,B,derive_pre(V,A,B,:(@inbounds b[$i]),false),vfield)
                         end
                     end
                 end
@@ -1240,9 +1243,10 @@ for (op,product) ∈ ((:∧,:exteradd),(:*,:geomadd),
     prop = op≠:* ? Symbol(:product_,op) : :product
     outmulti && @eval $prop(a,b,swap=false) = $prop(typeof(a),typeof(b),swap)
     mgrade,nmgrade = op≠:∧ ? (:maxgrade,:nextmaxgrade) : (:mingrade,:nextmingrade)
-    @eval @noinline function $prop(a::Type{S},b::Type{<:$input{V,T}},swap=false) where S<:TensorGraded{V,G} where {V,G,T}
+    @eval @noinline function $prop(a::Type{S},b::Type{<:$input{V,T}},swap=false,field=false) where S<:TensorGraded{V,G} where {V,G,T}
         MUL,VEC = mulvec(a,b,$(QuoteNode(op)))
         VECS = isodd(G) ? VEC : string(VEC)*"s"
+        args = field ? (:g,) : (); vfield = Val(field)
         $(if op ∈ (:∧,:∨); quote
             if $(op≠:∧ ? :(<(G+maxgrade(b),mdims(V))) : :(>(G+mingrade(b),mdims(V)))) && (!istangent(V))
                 return Zero(V)
@@ -1255,18 +1259,18 @@ for (op,product) ∈ ((:∧,:exteradd),(:*,:geomadd),
             if (swap ? maxgrade(b)<G : G<mingrade(b)) && (!istangent(V))
                 return Zero(V)
             elseif (swap ? maxgrade(b)==G : G+maxpseudograde(b)==mdims(V)) && (!istangent(V))
-                return swap ? :($$op(b(Val(maxgrade(b))),a)) : :($$op(a,b(Val(mingrade(b)))))
+                return swap ? :($$op(b(Val(maxgrade(b))),a,$(args...))) : :($$op(a,b(Val(mingrade(b))),$(args...)))
             elseif (swap ? nextmaxgrade(b)==G : G+nextmaxpseudograde(b)==mdims(V)) && (!istangent(V))
-                return swap ? :($$op(b(Val(maxgrade(b))),a)+$$op(b(Val(nextmaxgrade(b))),a)) : :($$op(a,b(Val(mingrade(b))))+$$op(a,b(Val(nextmingrade(b)))))
+                return swap ? :($$op(b(Val(maxgrade(b))),a,$(args...))+$$op(b(Val(nextmaxgrade(b))),a,$(args...))) : :($$op(a,b(Val(mingrade(b))),$(args...))+$$op(a,b(Val(nextmingrade(b))),$(args...)))
             end
         end; elseif op == :*; quote
             if S<:Chain && G == 0
                 return :($input{V,G}(broadcast($MUL,Ref(@inbounds a[1]),b.v)))
             elseif G == mdims(V) && !istangent(V)
                 return if swap
-                    S<:Single ? :(⋆(~b)*value(a)) : S<:Chain ? :(@inbounds a[1]*⋆(~b)) : :(⋆(~b))
+                    S<:Single ? :(⋆(~b,$(args...))*value(a)) : S<:Chain ? :(@inbounds a[1]*⋆(~b,$(args...))) : :(⋆(~b,$(args...)))
                 else
-                    S<:Single ? :(value(a)*complementlefthodge(~b)) : S<:Chain ? :(@inbounds a[1]*complementlefthodge(~b)) : :(complementlefthodge(~b))
+                    S<:Single ? :(value(a)*complementlefthodge(~b,$(args...))) : S<:Chain ? :(@inbounds a[1]*complementlefthodge(~b,$(args...))) : :(complementlefthodge(~b,$(args...)))
                 end
             end
         end; else nothing end)
@@ -1282,15 +1286,15 @@ for (op,product) ∈ ((:∧,:exteradd),(:*,:geomadd),
                         @inbounds for j ∈ 1:bn[G+1]
                             @inbounds A,B = swapper(ib[j],ia[i],swap)
                             X,Y = swapper(:(@inbounds a[$j]),val,swap)
-                            $preproduct!(V,out,A,B,derive_pre(V,A,B,X,Y,MUL))
+                            $preproduct!(V,out,A,B,derive_pre(V,A,B,X,Y,MUL),vfield)
                         end
                     else
                         @inbounds A,B = swapper(UInt(basis(a)),ia[i],swap)
                         if S<:Single
                             X,Y = swapper(:(a.v),:(@inbounds b.v[$(bs[g]+i)]),swap)
-                            $preproduct!(V,out,A,B,derive_pre(V,A,B,X,Y,MUL))
+                            $preproduct!(V,out,A,B,derive_pre(V,A,B,X,Y,MUL),vfield)
                         else
-                            @inbounds $preproduct!(V,out,A,B,derive_pre(V,A,B,:(@inbounds b.v[$(bs[g]+i)]),false))
+                            @inbounds $preproduct!(V,out,A,B,derive_pre(V,A,B,:(@inbounds b.v[$(bs[g]+i)]),false),vfield)
                         end
                     end
                 end
@@ -1346,9 +1350,10 @@ for input ∈ (:Spinor,:AntiSpinor)
     product2! = :(isodd(G) ? geomaddanti! : geomaddspin!)
     preproduct2! = :(isodd(G) ? geomaddanti!_pre : geomaddspin!_pre)
     input≠:Spinor && @eval product_sandwich(a,b,swap=false) = product_sandwich(typeof(a),typeof(b),swap)
-    @eval @noinline function product_sandwich(a::Type{S},b::Type{<:$input{V,T}},swap=false) where S<:TensorGraded{V,G} where {V,G,T}
+    @eval @noinline function product_sandwich(a::Type{S},b::Type{<:$input{V,T}},swap=false,field=false) where S<:TensorGraded{V,G} where {V,G,T}
         MUL,VEC = mulvec(a,b,:*)
         VECS = isodd(G) ? VEC : string(VEC)*"s"
+        args = field ? (:g,) : (); vfield = Val(field)
         if mdims(V)<cache_limit
             $(insert_expr((:N,:t,:ib,:bn,:μ))...)
             bs = $(inspin ? :spinsum_set : :antisum_set)(N)
@@ -1361,14 +1366,14 @@ for input ∈ (:Spinor,:AntiSpinor)
                     if S<:Chain
                         @inbounds for j ∈ 1:bn[G+1]
                             @inbounds A,B = ia[i],ib[j]
-                            $preproduct!(V,out,A,B,derive_pre(V,A,B,val,:(@inbounds a[$j]),MUL))
+                            $preproduct!(V,out,A,B,derive_pre(V,A,B,val,:(@inbounds a[$j]),MUL),vfield)
                         end
                     else
                         @inbounds A,B = ia[i],UInt(basis(a))
                         if S<:Single
-                            $preproduct!(V,out,A,B,derive_pre(V,A,B,val,:(a.v),MUL))
+                            $preproduct!(V,out,A,B,derive_pre(V,A,B,val,:(a.v),MUL),vfield)
                         else
-                            $preproduct!(V,out,A,B,derive_pre(V,A,B,val,false))
+                            $preproduct!(V,out,A,B,derive_pre(V,A,B,val,false),vfield)
                         end
                     end
                 end
@@ -1386,7 +1391,7 @@ for input ∈ (:Spinor,:AntiSpinor)
                             val2 = :(b.v[$(bs[g2]+j)])
                             @inbounds A,B = ia[i],io[j]
                             Y = par ? :(@inbounds -$val2) : :(@inbounds $val2)
-                            $preproduct2!(V,out2,A,B,derive_pre(V,A,B,val,Y,MUL))
+                            $preproduct2!(V,out2,A,B,derive_pre(V,A,B,val,Y,MUL),vfield)
                         end
                     end
                 end
@@ -1440,9 +1445,10 @@ for input ∈ (:Chain,)
     preproduct! = :((iseven(L) ? isodd : iseven)(G) ? geomaddanti!_pre : geomaddspin!_pre)
     product2! = :(isodd(G) ? geomaddanti! : geomaddspin!)
     preproduct2! = :(isodd(G) ? geomaddanti!_pre : geomaddspin!_pre)
-    @eval @noinline function product_sandwich(a::Type{S},b::Type{Q},swap=false) where {S<:TensorGraded{V,G},Q<:TensorGraded{V,L}} where {V,G,L}
+    @eval @noinline function product_sandwich(a::Type{S},b::Type{Q},swap=false,field=false) where {S<:TensorGraded{V,G},Q<:TensorGraded{V,L}} where {V,G,L}
         MUL,VEC = mulvec(a,b,:*)
         VECS = isodd(G) ? VEC : string(VEC)*"s"
+        args = field ? (:g,) : (); vfield = Val(field)
         if mdims(V)<cache_limit
             $(insert_expr((:N,:t,:ib,:bn,:μ))...)
             il = indexbasis(N,L)
@@ -1455,14 +1461,14 @@ for input ∈ (:Chain,)
                     if S<:Chain
                         @inbounds for j ∈ 1:bn[G+1]
                             @inbounds A,B = il[i],ib[j]
-                            $preproduct!(V,out,A,B,derive_pre(V,A,B,val,:(@inbounds a[$j]),MUL))
+                            $preproduct!(V,out,A,B,derive_pre(V,A,B,val,:(@inbounds a[$j]),MUL),vfield)
                         end
                     else
                         @inbounds A,B = il[i],UInt(basis(a))
                         if S<:Single
-                            $preproduct!(V,out,A,B,derive_pre(V,A,B,val,:(a.v),MUL))
+                            $preproduct!(V,out,A,B,derive_pre(V,A,B,val,:(a.v),MUL),vfield)
                         else
-                            $preproduct!(V,out,A,B,derive_pre(V,A,B,val,false))
+                            $preproduct!(V,out,A,B,derive_pre(V,A,B,val,false),vfield)
                         end
                     end
                 end
@@ -1472,14 +1478,14 @@ for input ∈ (:Chain,)
                 if S<:Chain
                     @inbounds for j ∈ 1:bn[G+1]
                         @inbounds B = ib[j]
-                        $preproduct!(V,out,A,B,derive_pre(V,A,B,val,:(@inbounds a[$j]),MUL))
+                        $preproduct!(V,out,A,B,derive_pre(V,A,B,val,:(@inbounds a[$j]),MUL),vfield)
                     end
                 else
                     B = UInt(basis(a))
                     if S<:Single
-                        $preproduct!(V,out,A,B,derive_pre(V,A,B,val,:(a.v),MUL))
+                        $preproduct!(V,out,A,B,derive_pre(V,A,B,val,:(a.v),MUL),vfield)
                     else
-                        $preproduct!(V,out,A,B,derive_pre(V,A,B,val,false))
+                        $preproduct!(V,out,A,B,derive_pre(V,A,B,val,false),vfield)
                     end
                 end
             end
@@ -1493,15 +1499,15 @@ for input ∈ (:Chain,)
                         @inbounds for j ∈ 1:bn[L+1]
                             @inbounds A,B = ia[i],il[j]
                             Y = (swap ? par : false) ? :(@inbounds -b[$j]) : :(@inbounds b[$j])
-                            $preproduct2!(V,out2,A,B,derive_pre(V,A,B,val,Y,MUL))
+                            $preproduct2!(V,out2,A,B,derive_pre(V,A,B,val,Y,MUL),vfield)
                         end
                     else
                         @inbounds A,B = ia[i],UInt(basis(b))
                         if Q<:Single
                             Y = swapper((swap ? par : false) ? :(-value(b)) : :(value(b)),val,true)
-                            $preproduct2!(V,out2,A,B,derive_pre(V,A,B,val,Y,MUL))
+                            $preproduct2!(V,out2,A,B,derive_pre(V,A,B,val,Y,MUL),vfield)
                         else
-                            $preproduct2!(V,out2,A,B,derive_pre(V,A,B,val,false))
+                            $preproduct2!(V,out2,A,B,derive_pre(V,A,B,val,false),vfield)
                         end
                     end
                 end
@@ -1520,13 +1526,14 @@ for input ∈ (:Couple,:PseudoCouple)
     preproduct2! = :(isodd(G) ? geomaddanti!_pre : geomaddspin!_pre)
     calar = input == :Couple ? :scalar : :volume
     pg = input == :Couple ? 0 : :N
-    @eval @noinline function product_sandwich(a::Type{S},b::Type{Q},swap=false) where {S<:TensorGraded{V,G},Q<:$input{V,BB}} where {V,G,BB}
+    @eval @noinline function product_sandwich(a::Type{S},b::Type{Q},swap=false,field=false) where {S<:TensorGraded{V,G},Q<:$input{V,BB}} where {V,G,BB}
         MUL,VEC = mulvec(a,b,:*)
         N = mdims(V)
+        args = field ? (:g,) : (); vfield = Val(field)
         $(if input == :Couple
-            :(isodd(grade(BB)) && return :(a⊘multispin(b)))
+            :(isodd(grade(BB)) && return :($(swap ? :>>> : :⊘)(a,multispin(b),$(args...))))
         else
-            :(isodd(grade(BB))≠isodd(N) && return :(a⊘multispin(b)))
+            :(isodd(grade(BB))≠isodd(N) && return :($(swap ? :>>> : :⊘)(a,multispin(b),$(args...))))
         end)
         inspin = iseven(grade(BB))
         VECS = isodd(G) ? VEC : string(VEC)*"s"
@@ -1537,14 +1544,14 @@ for input ∈ (:Couple,:PseudoCouple)
                 if S<:Chain
                     @inbounds for j ∈ 1:bn[G+1]
                         @inbounds B = ib[j]
-                        $preproduct!(V,out,A,B,derive_pre(V,A,B,val,:(@inbounds a[$j]),MUL))
+                        $preproduct!(V,out,A,B,derive_pre(V,A,B,val,:(@inbounds a[$j]),MUL),vfield)
                     end
                 else
                     B = UInt(basis(a))
                     if S<:Single
-                        $preproduct!(V,out,A,B,derive_pre(V,A,B,val,:(a.v),MUL))
+                        $preproduct!(V,out,A,B,derive_pre(V,A,B,val,:(a.v),MUL),vfield)
                     else
-                        $preproduct!(V,out,A,B,derive_pre(V,A,B,val,false))
+                        $preproduct!(V,out,A,B,derive_pre(V,A,B,val,false),vfield)
                     end
                 end
             end
@@ -1556,7 +1563,7 @@ for input ∈ (:Couple,:PseudoCouple)
                     @inbounds val = out[bs2[g]+i]
                     !isnull(val) && for (B,val2) ∈ ((UInt(BB),(swap ? parityclifford(grade(BB)) : false) ? :(-value(imaginary(b))) : :(value(imaginary(b)))),(indexbasis(N,$pg)[1],(swap ? parityclifford($pg) : false) ? :(-value($$calar(b))) : :(value($$calar(b)))))
                         @inbounds A = ia[i]
-                        $preproduct2!(V,out2,A,B,derive_pre(V,A,B,val,val2,MUL))
+                        $preproduct2!(V,out2,A,B,derive_pre(V,A,B,val,val2,MUL),vfield)
                     end
                 end
             end
@@ -1608,8 +1615,9 @@ for com ∈ (:spinor,:s_m,:m_s,:anti,:a_m,:m_a,:multivector,:s_a,:a_s)
     left,leftspin,right,rightspin,br = leftrightsym(com)
     VEC = outspin ? :svecs : :svec
     genloop = Symbol(:generate_loop_,com)
-    @eval @noinline function $genloop(V,a,b,t,MUL,product!,preproduct!,d=nothing)
+    @eval @noinline function $genloop(V,a,b,t,MUL,product!,preproduct!,field=false,d=nothing)
         $(insert_expr((:N,br...,:bn),:mvec)...)
+        vfield = Val(field)
         if mdims(V)<cache_limit/2
             out = $VEC(N,Any)(zeros($VEC(N,t)))
             for g ∈ $leftspin
@@ -1620,7 +1628,7 @@ for com ∈ (:spinor,:s_m,:m_s,:anti,:a_m,:m_a,:multivector,:s_a,:a_s)
                         @inbounds R = $right[G]
                         Y = indexbasis(N,G-1)
                         @inbounds for j ∈ 1:bn[G]
-                            @inbounds preproduct!(V,out,X[i],Y[j],derive_pre(V,X[i],Y[j],val,:(@inbounds $b[$(R+j)]),MUL))
+                            @inbounds preproduct!(V,out,X[i],Y[j],derive_pre(V,X[i],Y[j],val,:(@inbounds $b[$(R+j)]),MUL),vfield)
                         end
                     end
                 end
diff --git a/src/composite.jl b/src/composite.jl
index 735812c..2b3945e 100644
--- a/src/composite.jl
+++ b/src/composite.jl
@@ -45,7 +45,7 @@ function Base.expm1(t::T) where T<:TensorAlgebra
 end
 
 @eval @generated function Base.expm1(b::Multivector{V,T}) where {V,T}
-    loop = generate_loop_multivector(V,:term,:B,promote_type(T,Float64),:*,:geomaddmulti!,geomaddmulti!_pre,:k)
+    loop = generate_loop_multivector(V,:term,:B,promote_type(T,Float64),:*,:geomaddmulti!,geomaddmulti!_pre,false,:k)
     return quote
         B = value(b)
         sb,nb = scalar(b),AbstractTensors.norm(B)
@@ -72,7 +72,7 @@ end
 end
 
 @eval @generated function Base.expm1(b::Spinor{V,T}) where {V,T}
-    loop = generate_loop_spinor(V,:term,:B,promote_type(T,Float64),:*,:geomaddspin!,geomaddspin!_pre,:k)
+    loop = generate_loop_spinor(V,:term,:B,promote_type(T,Float64),:*,:geomaddspin!,geomaddspin!_pre,false,:k)
     return quote
         B = value(b)
         sb,nb = scalar(b),AbstractTensors.norm(B)
@@ -523,7 +523,7 @@ function Base.cosh(t::T) where T<:TensorAlgebra
 end
 
 @eval @generated function Base.cosh(b::Multivector{V,T,E}) where {V,T,E}
-    loop = generate_loop_multivector(V,:term,:B,promote_type(T,Float64),:*,:geomaddmulti!,geomaddmulti!_pre,:(k*(k-1)))
+    loop = generate_loop_multivector(V,:term,:B,promote_type(T,Float64),:*,:geomaddmulti!,geomaddmulti!_pre,false,:(k*(k-1)))
     return quote
         sb,nb = scalar(b),norm(b)
         sb ≈ nb && (return Single{V}(AbstractTensors.cosh(value(sb))))
@@ -552,7 +552,7 @@ end
 end
 
 @eval @generated function Base.cosh(b::Spinor{V,T,E}) where {V,T,E}
-    loop = generate_loop_spinor(V,:term,:B,promote_type(T,Float64),:*,:geomaddspin!,geomaddspin!_pre,:(k*(k-1)))
+    loop = generate_loop_spinor(V,:term,:B,promote_type(T,Float64),:*,:geomaddspin!,geomaddspin!_pre,false,:(k*(k-1)))
     return quote
         sb,nb = scalar(b),norm(b)
         sb ≈ nb && (return Single{V}(AbstractTensors.cosh(value(sb))))
@@ -607,7 +607,7 @@ function Base.sinh(t::T) where T<:TensorAlgebra
 end
 
 @eval @generated function Base.sinh(b::Multivector{V,T,E}) where {V,T,E}
-    loop = generate_loop_multivector(V,:term,:B,promote_type(T,Float64),:*,:geomaddmulti!,geomaddmulti!_pre,:(k*(k-1)))
+    loop = generate_loop_multivector(V,:term,:B,promote_type(T,Float64),:*,:geomaddmulti!,geomaddmulti!_pre,false,:(k*(k-1)))
     return quote
         sb,nb = scalar(b),norm(b)
         sb ≈ nb && (return Single{V}(AbstractTensors.sinh(value(sb))))
@@ -635,7 +635,7 @@ end
 end
 
 @eval @generated function Base.sinh(b::Spinor{V,T,E}) where {V,T,E}
-    loop = generate_loop_spinor(V,:term,:B,promote_type(T,Float64),:*,:geomaddspin!,geomaddspin!_pre,:(k*(k-1)))
+    loop = generate_loop_spinor(V,:term,:B,promote_type(T,Float64),:*,:geomaddspin!,geomaddspin!_pre,false,:(k*(k-1)))
     return quote
         sb,nb = scalar(b),norm(b)
         sb ≈ nb && (return Single{V}(AbstractTensors.sinh(value(sb))))
diff --git a/src/forms.jl b/src/forms.jl
index 5301104..d24d33a 100644
--- a/src/forms.jl
+++ b/src/forms.jl
@@ -399,16 +399,48 @@ show(io::IO,P::Dyadic) = print(io,"(",P.x,")⊗(",P.y,")")
 Chain{V}(P::Dyadic{V}) where V = outer(P.x,P.y)
 Chain(P::Dyadic{V}) where V = Chain{V}(P)
 
-export TensorOperator, Endomorphism
+export DiagonalOperator
 
-#=struct TensorOperator{V,W,S<:TensorAlgebra{W},T<:TensorAlgebra{V,S}} <: TensorNested{V,S}
+struct DiagonalOperator{V,T<:TensorAlgebra{V}} <: TensorNested{V,T}
     v::T
-    TensorOperator{V,W}(t::T) where {V,W,S<:TensorAlgebra{W},T<:TensorAlgebra{V,S}} = new{V,W,S,T}(t)
-    TensorOperator{V}(t::T) where {V,W,S<:TensorAlgebra{W},T<:TensorAlgebra{V,S}} = new{V,W,S,T}(t)
-    TensorOperator(t::T) where {V,W,S<:TensorAlgebra{W},T<:TensorAlgebra{V,S}} = new{V,W,S,T}(t)
+    DiagonalOperator{V}(t::T) where {V,T<:TensorAlgebra{V}} = new{V,T}(t)
+    DiagonalOperator(t::T) where {V,T<:TensorAlgebra{V}} = new{V,T}(t)
+end
+
+value(t::DiagonalOperator) = t.v
+matrix(m::DiagonalOperator) = matrix(TensorOperator(m))
+getindex(t::DiagonalOperator,i::Int,j::Int) = i≠j ? zero(valuetype(value(t))) : value(t)[i]
+getindex(t::DiagonalOperator,i::Int) = value(t)(i)
+
+compound(m::DiagonalOperator{V,<:Chain{V,1}},::Val{0}) where V = DiagonalOperator(Chain{V,0}(1))
+@generated function compound(m::DiagonalOperator{V,<:Chain{V,1}},::Val{G}) where {V,G}
+    Expr(:call,:DiagonalOperator,Expr(:call,:(Chain{V,G}),Expr(:call,Values,[Expr(:call,:*,[:(@inbounds m.v[$i]) for i ∈ indices(j)]...) for j ∈ indexbasis(mdims(V),G)]...)))
+end
+@generated function outermorphism(m::DiagonalOperator{V,<:Chain{V,1}}) where V
+    Expr(:call,:DiagonalOperator,Expr(:call,:(Multivector{V}),Expr(:call,Values,1,[Expr(:call,:*,[:(@inbounds m.v[$i]) for i ∈ indices(j)]...) for j ∈ indexbasis(mdims(V))[list(2,tdims(V))]]...)))
+end
+
+for op ∈ (:(Base.inv),:(Base.exp))
+    @eval $op(t::DiagonalOperator) = DiagonalOperator(map($op,value(t)))
+end
+
+_axes(t::DiagonalOperator) = (Base.OneTo(length(t.v)),Base.OneTo(length(t.v)))
+_axes(t::DiagonalOperator{V,T}) where {V,G,T<:Chain{V,G}} = (Base.OneTo(gdims(T)),Base.OneTo(gdims(T)))
+
+# anything array-like gets summarized e.g. 10-element Array{Int64,1}
+Base.summary(io::IO, a::DiagonalOperator) = Base.array_summary(io, a, _axes(a))
+
+show(io::IO,X::DiagonalOperator) = Base.show(io,TensorOperator(X))
+
+function show(io::IO, ::MIME"text/plain", t::DiagonalOperator)
+    X = display_matrix(value(TensorOperator(t)))
+    if isempty(X) && get(io, :compact, false)::Bool
+        return show(io, X)
+    end
+    show_matrix(io, t, X)
 end
 
-Endomorphism{V,S<:TensorAlgebra{V},T<:TensorAlgebra{V,S}} = TensorOperator{V,V,S,T}=#
+export TensorOperator, Endomorphism
 
 struct TensorOperator{V,W,T<:TensorAlgebra{V,<:TensorAlgebra{W}}} <: TensorNested{V,T}
     v::T
@@ -424,11 +456,17 @@ matrix(m::TensorOperator) = matrix(value(m))
 compound(m::TensorOperator,g) = TensorOperator(compound(value(m),g))
 compound(m::TensorOperator,g::Integer) = TensorOperator(compound(value(m),g))
 getindex(t::TensorOperator,i::Int,j::Int) = value(value(t.v)[j])[i]
+getindex(t::TensorOperator,i::Int) = value(t.v)[i]
 
 for op ∈ (:(Base.inv),)
     @eval $op(t::Endomorphism{V,<:Chain}) where V = TensorOperator($op(value(t)))
 end
 
+TensorOperator(t::DiagonalOperator{V,<:Chain{V,G}}) where {V,G} = TensorOperator(Chain{V,G}(value(value(t)).*chainbasis(V,G)))
+TensorOperator(t::DiagonalOperator{V,<:Spinor{V,G}}) where {V,G} = TensorOperator(Spinor{V}(value(value(t)).*evenbasis(V)))
+TensorOperator(t::DiagonalOperator{V,<:AntiSpinor{V,G}}) where {V,G} = TensorOperator(AntiSpinor{V}(value(value(t)).*oddbasis(V)))
+TensorOperator(t::DiagonalOperator{V,<:Multivector{V,G}}) where {V,G} = TensorOperator(Multivector{V}(value(value(t)).*Λ(V).b))
+
 _axes(t::TensorOperator) = (Base.OneTo(length(t.v)),Base.OneTo(length(t.v)))
 _axes(t::TensorOperator{V,W,T}) where {V,W,G,L,S<:Chain{W,L},T<:Chain{V,G,S}} = (Base.OneTo(gdims(S)),Base.OneTo(gdims(T)))
 _axes(t::TensorOperator{V,W,T}) where {V,W,S<:Multivector{W},T<:TensorAlgebra{V,S}} = (Base.OneTo(tdims(S)),Base.OneTo(tdims(T)))
@@ -600,7 +638,35 @@ minus(a::TensorNested,b::TensorNested) = a+(-b)
 @inline ⟑(a::Chain{V,G,<:Chain{V,G}} where {V,G},b::TensorNested) = contraction(a,b)
 @inline ⟑(a::TensorNested,b::Chain{V,G,<:Chain{V,G}} where {V,G}) = contraction(a,b)
 
-for op ∈ (:*,:⟑,:contraction,:plus,:minus,:+,:-,:/)
+contraction(a::DiagonalOperator{V,<:Chain{V,G}},b::Chain{V,G}) where {V,G} = Chain{V,G}(value(value(a)).*value(b))
+contraction(a::Chain{V,G},b::DiagonalOperator{V,<:Chain{V,G}}) where {V,G} = Chain{V,G}(value(a).*value(value(b)))
+contraction(a::DiagonalOperator{V,<:Chain{V,G}},b::DiagonalOperator{V,<:Chain{V,G}}) where {V,G} = DiagonalOperator(Chain{V,G}(value(value(a)).*value(value(b))))
+
+contraction(a::DiagonalOperator{V,<:Multivector{V}},b::Chain{V,G}) where {V,G} = Chain{V,G}(value(value(a)(Val(G))).*value(b))
+contraction(a::Chain{V,G},b::DiagonalOperator{V,<:Multivector{V}}) where {V,G} = Chain{V,G}(value(a).*value(value(b)(Val(G))))
+contraction(a::DiagonalOperator{V,<:Multivector{V}},b::Spinor{V}) where V = Spinor{V}(value(even(value(a))).*value(b))
+contraction(a::Spinor{V},b::DiagonalOperator{V,<:Multivector{V}}) where V = Spinor{V}(value(a).*value(even(value(b))))
+contraction(a::DiagonalOperator{V,<:Multivector{V}},b::AntiSpinor{V}) where V = AntiSpinor{V}(value(even(value(a))).*value(b))
+contraction(a::AntiSpinor{V},b::DiagonalOperator{V,<:Multivector{V}}) where V = AntiSpinor{V}(value(a).*value(even(value(b))))
+contraction(a::DiagonalOperator{V,<:Multivector{V}},b::Multivector{V}) where V = Multivector{V}(value(value(a)).*value(b))
+contraction(a::Multivector{V},b::DiagonalOperator{V,<:Multivector{V}}) where V = Multivector{V}(value(a).*value(value(b)))
+contraction(a::DiagonalOperator{V,<:Multivector{V}},b::DiagonalOperator{V,<:Multivector{V}}) where V = DiagonalOperator(Multivector{V}(value(value(a)).*value(value(b))))
+
+for op ∈ (:⟑,:*)
+    @eval begin
+        $op(a::DiagonalOperator,b::TensorAlgebra) = contraction(a,b)
+        $op(a::TensorAlgebra,b::DiagonalOperator) = contraction(a,b)
+        $op(a::DiagonalOperator,b::DiagonalOperator) = contraction(a,b)
+    end
+end
+for op ∈ (:plus,:minus,:+,:-)
+    for operator ∈ (:TensorOperator,:DiagonalOperator)
+        @eval begin
+            $op(a::$operator,b::$operator) = $operator($op(value(a),value(b)))
+        end
+    end
+end
+for op ∈ (:*,:⟑,:contraction,:/)
     @eval begin
         $op(a::TensorAlgebra,b::TensorOperator) = $op(a,value(b))
         $op(a::TensorOperator,b::TensorAlgebra) = $op(value(a),b)
@@ -608,9 +674,11 @@ for op ∈ (:*,:⟑,:contraction,:plus,:minus,:+,:-,:/)
     end
 end
 for F ∈ Fields
-    @eval begin
-        *(a::F,b::TensorOperator) where F<:$F = TensorOperator(a*value(b))
-        *(a::TensorOperator,b::F) where F<:$F = TensorOperator(value(a)*b)
+    for operator ∈ (:TensorOperator,:DiagonalOperator)
+        @eval begin
+            *(a::F,b::$operator) where F<:$F = $operator(a*value(b))
+            *(a::$operator,b::F) where F<:$F = $operator(value(a)*b)
+        end
     end
 end
 
@@ -702,9 +770,11 @@ function metricdyad(V)
     end
 end
 
+applyf(f,mat::TensorOperator) = f.(value(value(mat)))
+
 metricfull(V) = TensorOperator(Multivector{V}(vcat(value.(map.(Multivector,value.(metrictensor.(V,list(0,mdims(V))))))...)))
-metriceven(V) = TensorOperator(Spinor{V}(vcat(value.(map.(Spinor,value.(metrictensor.(V,evens(0,mdims(V))))))...)))
-metricodd(V) = TensorOperator(AntiSpinor{V}(vcat(value.(map.(AntiSpinor,value.(metrictensor.(V,evens(1,mdims(V))))))...)))
+metriceven(V) = TensorOperator(Spinor{V}(vcat(applyf.(Spinor,metrictensor.(V,evens(0,mdims(V))))...)))
+metricodd(V) = TensorOperator(AntiSpinor{V}(vcat(applyf.(AntiSpinor,metrictensor.(V,evens(1,mdims(V))))...)))
 
 struct MetricTensor{n,ℙ,g,Vars,Diff,Name} <: TensorBundle{n,ℙ,g,Vars,Diff,Name}
     @pure MetricTensor{N,M,S,F,D,L}() where {N,M,S,F,D,L} = new{N,M,S,F,D,L}()
diff --git a/src/multivectors.jl b/src/multivectors.jl
index bb622c7..be6f0da 100644
--- a/src/multivectors.jl
+++ b/src/multivectors.jl
@@ -452,9 +452,10 @@ for pinor ∈ (:Spinor,:AntiSpinor)
         @computed struct $pinor{V,T} <: AbstractSpinor{V,T}
             v::Values{1<<(mdims(V)-1),T}
             $pinor{V,T}(v) where {V,T} = new{DirectSum.submanifold(V),T}(v)
+            $pinor{V}(v::Values{N,T}) where {N,V,T} = new{DirectSum.submanifold(V),T}(v)
         end
         #$pinor{V,T}(v::AbstractVector{T}) where {V,T} = $pinor{V,T}(Values{1<<(mdims(V)-1),T}(v)
-        $pinor{V}(v::AbstractVector{T}) where {V,T} = $pinor{V,T}(v)
+        $pinor{V}(v::S) where {V,S<:AbstractVector{T}} where T = $pinor{V,T}(v)
         $pinor{V,𝕂}(val::Single{V,G,B,𝕂}) where {V,G,B,𝕂} = $pinor{V,𝕂}(val.v,B)
         $pinor{V}(val::Single{V,G,B,𝕂}) where {V,G,B,𝕂} = $pinor{V,𝕂}(val)
         $pinor(val::TensorAlgebra{V}) where V = $pinor{V}(val)
@@ -595,7 +596,7 @@ end
     :(Multivector{V,T}($(Expr(:call,:Values,vcat([isodd(G) ? [:(@inbounds t.v[$(i+bs[G+1])]) for i ∈ list(1,binomial(N,G))] : zeros(T,binomial(N,G)) for G ∈ list(0,N)]...)...))))
 end
 
-@pure function Base.getproperty(a::Spinor{V,T},v::Symbol) where {V,T}
+#=@pure function Base.getproperty(a::Spinor{V,T},v::Symbol) where {V,T}
     return if v == :v
         getfield(a,:v)
     else
@@ -610,7 +611,7 @@ end
         B = getproperty(Λ(V),v)
         isodd(grade(B)) ? a.v[bladeindex(mdims(V),UInt(B))]*B : zero(T)*B
     end
-end
+end=#
 
 function Base.show(io::IO, m::Spinor{V,T}) where {V,T}
     N,compact = mdims(V),get(io,:compact,false)
diff --git a/src/parity.jl b/src/parity.jl
index f9edc83..31cb0d2 100644
--- a/src/parity.jl
+++ b/src/parity.jl
@@ -107,14 +107,19 @@ end=#
     d≠0 && count_ones(A&v)+count_ones(B&v)>diffmode(V)
 end
 
-@pure function parityinterior(V::M,a,b,::Val{lim}=Val(false)) where {W,M<:Manifold{W},lim}
+@pure function parityinterior(V::M,a,b,::Val{lim}=Val(false),::Val{field}=Val(false)) where {W,M<:Manifold{W},lim,field}
     A,B,Q,Z = symmetricmask(V,a,b); N = rank(V)
     diffcheck(V,A,B) && (return lim ? (Values{0,Tuple{UInt,Int}}(),Z) : (1,Zero(UInt),false,Z))
     gout,tout,G,diag = 0,false,count_ones(B),isdiag(V)
     bas = diag ? Values((B,)) : indexbasis(grade(V),G)
     g = if diag
-        gg = V[indices(B,N)]
-        Values((prod(isempty(gg) ? 1 : signbool.(gg)),))
+        if field
+            bi = basisindex(N,B)
+            Values((:(value(value(g))[$bi]),))
+        else
+            gg = V[indices(B,N)]
+            Values((prod(isempty(gg) ? 1 : signbool.(gg)),))
+        end
     else
         value(metrictensor(V,G))[bladeindex(grade(V),B)]
     end
@@ -124,7 +129,7 @@ end
             p,C,t = parityregressive(Signature(W),A,complement(N,bas[i],diffvars(V)),Val{true}())
             CQ,tout = C|Q,tout|t
             if t
-                ggg = (p⊻parityright(0,sum(indices(bas[i],N)),G)) ? -(g[i]) : g[i]
+                ggg = (p⊻parityright(0,sum(indices(bas[i],N)),G)) ? field ? :(-($(g[i]))) : -(g[i]) : g[i]
                 if CQ ∉ bs
                     bs = (bs...,CQ)
                     bg = (bg...,(CQ,ggg))
@@ -132,7 +137,7 @@ end
                     j = findfirst(x->x==CQ,bs)
                     bg = @inbounds (bg[1:j-1]...,(CQ,(bg[j][2]+ggg)),bg[j+1:length(bs)]...)
                 end
-                gout += ggg
+                iszero(gout) ? (gout = ggg) : (gout += ggg)
             end
         end
     end
@@ -149,16 +154,21 @@ end
     parity(V,A,B) ? -1 : 1
 end
 
-@pure function parityinner(V::M,a::UInt,b::UInt) where {W,M<:Manifold{W}}
+@pure function parityinner(V::M,a::UInt,b::UInt,::Val{field}=Val(false)) where {W,M<:Manifold{W},field}
     A,B = symmetricmask(V,a,b)
     C = A&B; G = count_ones(C)
     g = if isdiag(V) || hasconformal(V)
-        gg = V[indices(C,mdims(V))]
-        abs(prod(isempty(gg) ? 1 : signbool.(gg)))
+        if field
+            bi = basisindex(mdims(V),C)
+            :(value(value(g))[$bi])
+        else
+            gg = V[indices(C,mdims(V))]
+            abs(prod(isempty(gg) ? 1 : signbool.(gg)))
+        end
     else
         value(metrictensor(V,G))[bladeindex(mdims(V),C)]
     end
-    parity(Signature(W),A,B) ? -(g) : g
+    parity(Signature(W),A,B) ? fieldneg(g) : g
 end
 
 function parityseq(V,B)
@@ -172,85 +182,89 @@ end
 
 maxempty(x) = isempty(x) ? 0 : maximum(x)
 
-function paritygeometric(V,A::UInt,B::UInt)
+function paritygeometric(V,A::UInt,B::UInt,field=Val(false))
     #if iszero(B)
     #    Values(((A,1),))
     a,b = splitbasis(V,A),splitbasis(V,B)
     ga,gb = maxempty(count_ones.(a)),maxempty(count_ones.(b))
     if  (ga≤1 && gb≤1) ? count_ones(A) ≥ count_ones(B) : ga ≥ gb
-        paritygeometric(V,A,b)
+        paritygeometric(V,A,b,field)
     else
-        paritygeometric(V,a,B)
+        paritygeometric(V,a,B,field)
     end
 end
-function paritygeometric(V,A::UInt,b::Tuple)
+function paritygeometric(V,A::UInt,b::Tuple,field)
     i = length(b)
     vals = if iszero(i)
         Values((((UInt(0),1),(A,1)),))
     else
         p = parityseq(V,b)
-        out = paritygeometricright(V,((UInt(0),p),(A,1)),b[1])
-        isone(i) ? out : paritygeometricright(V,out,b,2)
+        out = paritygeometricright(V,((UInt(0),p),(A,1)),b[1],field)
+        isone(i) ? out : paritygeometricright(V,out,b,2,field)
     end
     combinebasis(V,vals)
 end
-function paritygeometric(V,a::Tuple,B::UInt)
+function paritygeometric(V,a::Tuple,B::UInt,field)
     i = length(a)
     vals = if iszero(i)
         Values((((UInt(0),1),(B,1)),))
     else
         p = parityseq(V,a)
-        out = paritygeometricleft(V,a[i],((UInt(0),p),(B,1)))
-        isone(i) ? out : paritygeometricleft(V,a,out,i-1)
+        out = paritygeometricleft(V,a[i],((UInt(0),p),(B,1)),field)
+        isone(i) ? out : paritygeometricleft(V,a,out,i-1,field)
     end
     combinebasis(V,vals)
 end
-function paritygeometricright(V,a,b::Tuple,i)
-    out = vcat(paritygeometricright.(Ref(V),a,Ref(b[i]))...)
-    i==length(b) ? out : paritygeometricright(V,out,b,i+1)
+function paritygeometricright(V,a,b::Tuple,i,field)
+    out = vcat(paritygeometricright.(Ref(V),a,Ref(b[i]),field)...)
+    i==length(b) ? out : paritygeometricright(V,out,b,i+1,field)
 end
-function paritygeometricright(V,aeai,B::UInt)
+function paritygeometricright(V,aeai,B::UInt,field)
     ae,ai = @inbounds (aeai[1],aeai[2])
     Ae,Aeg = @inbounds (ae[1],ae[2])
     Ai,Aig = @inbounds (ai[1],ai[2])
     G = count_ones(B)
     CCg = if isdiag(V) || hasconformal(V)
-        g,C,t,Z = interior(V,Ai,B)
-        Cg = parityclifford(G)⊻isodd(G*count_ones(Ai)) ? -Aig*g : Aig*g
+        g,C,t,Z = interior(V,Ai,B,Val(false),field)
+        Aigg = fieldprod(Aig,g)
+        Cg = parityclifford(G)⊻isodd(G*count_ones(Ai)) ? fieldneg(Aigg) : Aigg
         t ? ((ae,(C,Cg)),) : ()
     else
-        Cg,Z = parityinterior(V,Ai,B,Val(true))
-        g = parityclifford(G)⊻isodd(G*count_ones(Ai)) ? -Aig*Aeg : Aig*Aeg
+        Cg,Z = parityinterior(V,Ai,B,Val(true),field)
+        AigAeg = fieldprod(Aig,Aeg)
+        g = parityclifford(G)⊻isodd(G*count_ones(Ai)) ? fieldneg(AigAeg) : AigAeg
         ([((Ae,g),cg) for cg ∈ Cg]...,)
     end
     out = if iszero(Ai&B)
-        p = parity(grade(V),Ai⊻Ae,B) ? -Aeg : Aeg
+        p = parity(grade(V),Ai⊻Ae,B) ? fieldneg(Aeg) : Aeg
         (combinegeometric(V,(Ae⊻B,p),ai),CCg...)
     else
         CCg
     end
     isempty(out) ? Values{0,Tuple{Tuple{UInt,Int},Tuple{UInt,Int}}}() : Values(out)
 end
-function paritygeometricleft(V,a::Tuple,b,i)
-    out = vcat(paritygeometricleft.(Ref(V),Ref(a[i]),b)...)
-    isone(i) ? out : paritygeometricleft(V,a,out,i-1)
+function paritygeometricleft(V,a::Tuple,b,i,field)
+    out = vcat(paritygeometricleft.(Ref(V),Ref(a[i]),b,field)...)
+    isone(i) ? out : paritygeometricleft(V,a,out,i-1,field)
 end
-function paritygeometricleft(V,A::UInt,bebi)
+function paritygeometricleft(V,A::UInt,bebi,field)
     be,bi = @inbounds (bebi[1],bebi[2])
     Be,Beg = @inbounds (be[1],be[2])
     Bi,Big = @inbounds (bi[1],bi[2])
     G = count_ones(A)
     CCg = if isdiag(V) || hasconformal(V)
-        g,C,t,Z = interior(V,Bi,A)
-        Cg = parityreverse(G) ? -Big*g : Big*g
+        g,C,t,Z = interior(V,Bi,A,Val(false),field)
+        Bigg = fieldprod(Big,g)
+        Cg = parityreverse(G) ? fieldneg(Bigg) : Bigg
         t ? ((be,(C,Cg)),) : ()
     else
-        Cg,Z = parityinterior(V,Bi,A,Val(true))
-        g = parityreverse(G) ? -Big*Beg : Big*Beg
+        Cg,Z = parityinterior(V,Bi,A,Val(true),field)
+        BigBeg = fieldprod(Big,Beg)
+        g = parityreverse(G) ? fieldneg(BigBeg) : BigBeg
         ([((Be,g),cg) for cg ∈ Cg]...,)
     end
     out = if iszero(A&Bi)
-        p = parity(grade(V),A,Be⊻Bi) ? -Beg : Beg
+        p = parity(grade(V),A,Be⊻Bi) ? fieldneg(Beg) : Beg
         (combinegeometric(V,(A⊻Be,p),bi),CCg...)
     else
         CCg
@@ -309,15 +323,22 @@ function combinegeometric(V,ei)
     e,i = @inbounds ei[1],ei[2]
     E,Eg = @inbounds e[1],e[2]
     I,Ig = @inbounds i[1],i[2]
-    iszero(E&I) ? (E⊻I,Eg*Ig) : nothing
+    iszero(E&I) ? (E⊻I,fieldprod(Eg,Ig)) : nothing
 end
 function combinegeometric(V,e,i)
     E,Eg = @inbounds e[1],e[2]
     I,Ig = @inbounds i[1],i[2]
     #p = parity(grade(V),E,I) ? -Eg*Ig : Eg*Ig
-    return ((E,Eg*Ig),(I,1))
+    return ((E,fieldprod(Eg,Ig)),(I,1))
 end
 
+fieldprod(a::Expr,b::Expr,op=:*) = :($op($a,$b))
+fieldprod(a::Expr,b,op=:*) = isone(b) ? a : isone(abs(b)) ? :(-($a)) : :($op($a,$b))
+fieldprod(a,b::Expr,op=:*) = isone(a) ? b : isone(abs(a)) ? :(-($b)) : :($op($a,$b))
+fieldprod(a,b) = a*b
+fieldneg(a::Expr) = :(-($a))
+fieldneg(a) = -a
+
 ### parity cache
 
 const parity_cache = Dict{UInt,Vector{Vector{Bool}}}[]
@@ -360,6 +381,10 @@ end
 
 ### parity product caches
 
+function interior(V,a,b,c::Val{lim},d::Val{field}=Val(false)) where {lim,field}
+    lim||field ? parityinterior(V,a,b,c,d) : interior(V,a,b)
+end
+
 for par ∈ (:conformal,:regressive,:interior)
     calc = Symbol(:parity,par)
     T = Tuple{Any,UInt,Bool,UInt}
diff --git a/src/products.jl b/src/products.jl
index 4d0eef9..041f7fa 100644
--- a/src/products.jl
+++ b/src/products.jl
@@ -196,7 +196,7 @@ function generate_mutators(M,F,set_val,SUB,MUL)
                     end
                     return false
                 end
-                @inline function $(Symbol(:join,spre))(V,m::$M,a::UInt,b::UInt,v::S) where {T<:$F,S<:$F,M}
+                @inline function $(Symbol(:join,spre))(V,m::$M,a::UInt,b::UInt,v::S,field=nothing) where {T<:$F,S<:$F,M}
                     if v ≠ 0 && !diffcheck(V,a,b)
                         A,B,Q,Z = symmetricmask(V,a,b)
                         val = :($$MUL($(parityinner(grade(V),A,B)),$v))
@@ -234,12 +234,12 @@ function generate_mutators(M,F,set_val,SUB,MUL)
                     end
                     return false
                 end
-                @inline function $(Symbol(:geom,spre))(V,m::$M,a::UInt,b::UInt,v::S) where {T<:$F,S<:$F,M}
+                @inline function $(Symbol(:geom,spre))(V,m::$M,a::UInt,b::UInt,v::S,vfield::Val{field}=Val(false)) where {T<:$F,S<:$F,M,field}
                     if v ≠ 0 && !diffcheck(V,a,b)
                         A,B,Q,Z = symmetricmask(V,a,b)
                         if isdiag(V)
                             pcc,bas,cc = (hasinf(V) && hasorigin(V)) ? conformal(V,A,B) : (false,A⊻B,false)
-                            g = parityinner(V,A,B)
+                            g = parityinner(V,A,B,vfield)
                             val = :($$MUL($g,$(pcc ? :($$SUB($v)) : v)))
                             if istangent(V)
                                 !iszero(Z) && (val = Expr(:call,:*,val,getbasis(loworder(V),Z)))
@@ -248,7 +248,7 @@ function generate_mutators(M,F,set_val,SUB,MUL)
                             $spre(m,val,bas|Q,Val(mdims(V)))
                             cc && $spre(m,hasinforigin(V,A,B) ? :($$SUB($val)) : val,(conformalmask(V)⊻bas)|Q,Val(mdims(V)))
                         else
-                            for (bas,g) ∈ paritygeometric(V,A,B)
+                            for (bas,g) ∈ paritygeometric(V,A,B,vfield)
                                 val = :($$MUL($g,$v))
                                 if istangent(V)
                                     !iszero(Z) && (val = Expr(:call,:*,val,getbasis(loworder(V),Z)))
@@ -267,63 +267,93 @@ function generate_mutators(M,F,set_val,SUB,MUL)
                         $(Symbol(prod,S))(V,m,UInt(A),UInt(B),v)
                     end
                 end
-                @eval begin
-                    @inline function $(Symbol(prod,s))(V,m::$M,A::UInt,B::UInt,val::T) where {T,M}
-                        if val ≠ 0
-                            if isdiag(V)
-                                g,C,t,Z = $uct(V,A,B)
-                                v = val
-                                if istangent(V) && !iszero(Z)
-                                    T≠Any && (return true)
-                                    _,_,Q,_ = symmetricmask(V,A,B)
-                                    v *= getbasis(loworder(V),Z)
-                                    count_ones(Q)+order(v)>diffmode(V) && (return false)
-                                end
-                                t && $s(m,$MUL(g,v),C,Val(mdims(V)))
-                            else
-                                Cg,Z = $(Symbol(:parity,uct))(V,A,B,Val(true))
-                                v = val
-                                if istangent(V) && !iszero(Z)
-                                    T≠Any && (return true)
-                                    _,_,Q,_ = symmetricmask(V,A,B)
-                                    v *= getbasis(loworder(V),Z)
-                                    count_ones(Q)+order(v)>diffmode(V) && (return false)
-                                end
-                                for (C,g) ∈ Cg
-                                    $s(m,$MUL(g,v),C,Val(mdims(V)))
-                                end
+            end
+            @eval begin
+                @inline function $(Symbol(:meet,s))(V,m::$M,A::UInt,B::UInt,val::T) where {T,M}
+                    if val ≠ 0
+                        g,C,t,Z = regressive(V,A,B)
+                        v = val
+                        if istangent(V) && !iszero(Z)
+                            T≠Any && (return true)
+                            _,_,Q,_ = symmetricmask(V,A,B)
+                            v *= getbasis(loworder(V),Z)
+                            count_ones(Q)+order(v)>diffmode(V) && (return false)
+                        end
+                        t && $s(m,$MUL(g,v),C,Val(mdims(V)))
+                    end
+                    return false
+                end
+                @inline function $(Symbol(:meet,spre))(V,m::$M,A::UInt,B::UInt,val::T,field::Val=Val(false)) where {T,M}
+                    if val ≠ 0
+                        g,C,t,Z = regressive(V,A,B)
+                        v = val
+                        if istangent(V) && !iszero(Z)
+                            _,_,Q,_ = symmetricmask(V,A,B)
+                            v = Expr(:call,:*,v,getbasis(loworder(V),Z))
+                            v = :(h=$v;iszero(h)||$(count_ones(Q))+order(h)>$(diffmode(V)) ? 0 : h)
+                        end
+                        t && $spre(m,Expr(:call,$(QuoteNode(MUL)),g,v),C,Val(mdims(V)))
+                    end
+                    return false
+                end
+                @inline function $(Symbol(:skew,s))(V,m::$M,A::UInt,B::UInt,val::T) where {T,M}
+                    if val ≠ 0
+                        if isdiag(V)
+                            g,C,t,Z = interior(V,A,B)
+                            v = val
+                            if istangent(V) && !iszero(Z)
+                                T≠Any && (return true)
+                                _,_,Q,_ = symmetricmask(V,A,B)
+                                v *= getbasis(loworder(V),Z)
+                                count_ones(Q)+order(v)>diffmode(V) && (return false)
+                            end
+                            t && $s(m,$MUL(g,v),C,Val(mdims(V)))
+                        else
+                            Cg,Z = parityinterior(V,A,B,Val(true),false)
+                            v = val
+                            if istangent(V) && !iszero(Z)
+                                T≠Any && (return true)
+                                _,_,Q,_ = symmetricmask(V,A,B)
+                                v *= getbasis(loworder(V),Z)
+                                count_ones(Q)+order(v)>diffmode(V) && (return false)
+                            end
+                            for (C,g) ∈ Cg
+                                $s(m,$MUL(g,v),C,Val(mdims(V)))
                             end
                         end
-                        return false
                     end
-                    @inline function $(Symbol(prod,spre))(V,m::$M,A::UInt,B::UInt,val::T) where {T,M}
-                        if val ≠ 0
-                            if isdiag(V)
-                                g,C,t,Z = $uct(V,A,B)
-                                v = val
-                                if istangent(V) && !iszero(Z)
-                                    _,_,Q,_ = symmetricmask(V,A,B)
-                                    v = Expr(:call,:*,v,getbasis(loworder(V),Z))
-                                    v = :(h=$v;iszero(h)||$(count_ones(Q))+order(h)>$(diffmode(V)) ? 0 : h)
-                                end
-                                t && $spre(m,Expr(:call,$(QuoteNode(MUL)),g,v),C,Val(mdims(V)))
-                            else
-                                Cg,Z = $(Symbol(:parity,uct))(V,A,B,Val(true))
-                                v = val
-                                if istangent(V) && !iszero(Z)
-                                    _,_,Q,_ = symmetricmask(V,A,B)
-                                    v = Expr(:call,:*,v,getbasis(loworder(V),Z))
-                                    v = :(h=$v;iszero(h)||$(count_ones(Q))+order(h)>$(diffmode(V)) ? 0 : h)
-                                end
-                                for (C,g) ∈ Cg
-                                    $spre(m,Expr(:call,$(QuoteNode(MUL)),g,v),C,Val(mdims(V)))
-                                end
+                    return false
+                end
+                @inline function $(Symbol(:skew,spre))(V,m::$M,A::UInt,B::UInt,val::T,field::Val=Val(false)) where {T,M}
+                    if val ≠ 0
+                        if isdiag(V)
+                            g,C,t,Z = interior(V,A,B,Val(false),field)
+                            v = val
+                            if istangent(V) && !iszero(Z)
+                                _,_,Q,_ = symmetricmask(V,A,B)
+                                v = Expr(:call,:*,v,getbasis(loworder(V),Z))
+                                v = :(h=$v;iszero(h)||$(count_ones(Q))+order(h)>$(diffmode(V)) ? 0 : h)
+                            end
+                            t && $spre(m,Expr(:call,$(QuoteNode(MUL)),g,v),C,Val(mdims(V)))
+                        else
+                            Cg,Z = parityinterior(V,A,B,Val(true),field)
+                            v = val
+                            if istangent(V) && !iszero(Z)
+                                _,_,Q,_ = symmetricmask(V,A,B)
+                                v = Expr(:call,:*,v,getbasis(loworder(V),Z))
+                                v = :(h=$v;iszero(h)||$(count_ones(Q))+order(h)>$(diffmode(V)) ? 0 : h)
+                            end
+                            for (C,g) ∈ Cg
+                                $spre(m,Expr(:call,$(QuoteNode(MUL)),g,v),C,Val(mdims(V)))
                             end
                         end
-                        return false
                     end
+                    return false
                 end
+
+
             end
+
         end
     end
 end
@@ -1089,16 +1119,21 @@ end
 
 ### Product Algebra
 
+const product_contraction_metric = product_contraction
 @generated function contraction2(a::TensorGraded{V,L},b::Chain{V,G,T}) where {V,G,L,T}
-    product_contraction(a,b,false,:product)
+    product_contraction(a,b,false,false,:product)
 end
-for (op,prop) ∈ ((:⟑,:product),(:contraction,:product_contraction))
+@generated function contraction2_metric(a::TensorGraded{V,L},b::Chain{V,G,T},g) where {V,G,L,T}
+    product_contraction(a,b,false,true,:product)
+end
+for (op,prop,field) ∈ ((:⟑,:product,false),(:contraction,:product_contraction,false),(:wedgedot_metric,:product,true),(:contraction_metric,:product_contraction,true))
+    args = field ? (:g,) : ()
     @eval begin
-        @generated function $op(b::Chain{V,G,T},a::TensorTerm{V,L}) where {V,G,L,T}
-            $prop(a,b,true)
+        @generated function $op(b::Chain{V,G,T},a::TensorTerm{V,L},$(args...)) where {V,G,L,T}
+            $prop(a,b,true,$field)
         end
-        @generated function $op(a::TensorGraded{V,L},b::Chain{V,G,T}) where {V,G,L,T}
-            $prop(a,b)
+        @generated function $op(a::TensorGraded{V,L},b::Chain{V,G,T},$(args...)) where {V,G,L,T}
+            $prop(a,b,false,$field)
         end
     end
 end
@@ -1106,30 +1141,32 @@ for op ∈ (:∧,:∨)
     prop = Symbol(:product_,op)
     @eval begin
         @generated function $op(a::Chain{w,G,T},b::Chain{W,L,S}) where {T,w,S,W,G,L}
-            $prop(a,b)
+            $prop(a,b,false)
         end
         @generated function $op(b::Chain{Q,G,T},a::TensorTerm{R,L}) where {Q,G,T,R,L}
             $prop(a,b,true)
         end
         @generated function $op(a::TensorTerm{Q,G},b::Chain{R,L,T}) where {Q,R,T,G,L}
-            $prop(a,b)
+            $prop(a,b,false)
         end
     end
 end
-for (op,product!) ∈ ((:∧,:exteraddmulti!),(:⟑,:geomaddmulti!),
-                     (:∨,:meetaddmulti!),(:contraction,:skewaddmulti!))
+for (op,product!,field) ∈ ((:∧,:exteraddmulti!,false),(:⟑,:geomaddmulti!,false),
+                     (:∨,:meetaddmulti!,false),(:contraction,:skewaddmulti!,false),
+                     (:wedgedot_metric,:geomaddmulti!,true),(:contraction_metric,:skewaddmulti!,true))
     preproduct! = Symbol(product!,:_pre)
-    prop = op≠:⟑ ? Symbol(:product_,op) : :product
+    prop = op∉(:⟑,:wedgedot_metric) ? Symbol(:product_,op) : :product
+    args = field ? (:g,) : ()
     @eval begin
-        @generated function $op(b::Multivector{V,T},a::TensorGraded{V,G}) where {V,T,G}
-            $prop(a,b,true)
+        @generated function $op(b::Multivector{V,T},a::TensorGraded{V,G},$(args...)) where {V,T,G}
+            $prop(a,b,true,$field)
         end
-        @generated function $op(a::TensorGraded{V,G},b::Multivector{V,S}) where {V,G,S}
-            $prop(a,b)
+        @generated function $op(a::TensorGraded{V,G},b::Multivector{V,S},$(args...)) where {V,G,S}
+            $prop(a,b,false,$field)
         end
-        @generated function $op(a::Multivector{V,T},b::Multivector{V,S}) where {V,T,S}
+        @generated function $op(a::Multivector{V,T},b::Multivector{V,S},$(args...)) where {V,T,S}
             MUL,VEC = mulvec(a,b)
-            loop = generate_loop_multivector(V,:(a.v),:(b.v),promote_type(T,S),MUL,$product!,$preproduct!)
+            loop = generate_loop_multivector(V,:(a.v),:(b.v),promote_type(T,S),MUL,$product!,$preproduct!,$field)
             if mdims(V)<cache_limit/2
                 return :(Multivector{V}($(loop[2].args[2])))
             else return quote
@@ -1138,9 +1175,9 @@ for (op,product!) ∈ ((:∧,:exteraddmulti!),(:⟑,:geomaddmulti!),
                 return Multivector{V,t}(out)
             end end
         end
-        @generated function $op(a::Spinor{V,T},b::Multivector{V,S}) where {V,T,S}
+        @generated function $op(a::Spinor{V,T},b::Multivector{V,S},$(args...)) where {V,T,S}
             MUL,VEC = mulvec(a,b)
-            loop = generate_loop_s_m(V,:(a.v),:(b.v),promote_type(T,S),MUL,$product!,$preproduct!)
+            loop = generate_loop_s_m(V,:(a.v),:(b.v),promote_type(T,S),MUL,$product!,$preproduct!,$field)
             if mdims(V)<cache_limit/2
                 return :(Multivector{V}($(loop[2].args[2])))
             else return quote
@@ -1149,9 +1186,9 @@ for (op,product!) ∈ ((:∧,:exteraddmulti!),(:⟑,:geomaddmulti!),
                 return Multivector{V,t}(out)
             end end
         end
-        @generated function $op(a::Multivector{V,T},b::Spinor{V,S}) where {V,T,S}
+        @generated function $op(a::Multivector{V,T},b::Spinor{V,S},$(args...)) where {V,T,S}
             MUL,VEC = mulvec(a,b)
-            loop = generate_loop_m_s(V,:(a.v),:(b.v),promote_type(T,S),MUL,$product!,$preproduct!)
+            loop = generate_loop_m_s(V,:(a.v),:(b.v),promote_type(T,S),MUL,$product!,$preproduct!,$field)
             if mdims(V)<cache_limit/2
                 return :(Multivector{V}($(loop[2].args[2])))
             else return quote
@@ -1161,9 +1198,9 @@ for (op,product!) ∈ ((:∧,:exteraddmulti!),(:⟑,:geomaddmulti!),
             end end
 
         end
-        @generated function $op(a::AntiSpinor{V,T},b::Multivector{V,S}) where {V,T,S}
+        @generated function $op(a::AntiSpinor{V,T},b::Multivector{V,S},$(args...)) where {V,T,S}
             MUL,VEC = mulvec(a,b)
-            loop = generate_loop_a_m(V,:(a.v),:(b.v),promote_type(T,S),MUL,$product!,$preproduct!)
+            loop = generate_loop_a_m(V,:(a.v),:(b.v),promote_type(T,S),MUL,$product!,$preproduct!,$field)
             if mdims(V)<cache_limit/2
                 return :(Multivector{V}($(loop[2].args[2])))
             else return quote
@@ -1172,9 +1209,9 @@ for (op,product!) ∈ ((:∧,:exteraddmulti!),(:⟑,:geomaddmulti!),
                 return Multivector{V,t}(out)
             end end
         end
-        @generated function $op(a::Multivector{V,T},b::AntiSpinor{V,S}) where {V,T,S}
+        @generated function $op(a::Multivector{V,T},b::AntiSpinor{V,S},$(args...)) where {V,T,S}
             MUL,VEC = mulvec(a,b)
-            loop = generate_loop_m_a(V,:(a.v),:(b.v),promote_type(T,S),MUL,$product!,$preproduct!)
+            loop = generate_loop_m_a(V,:(a.v),:(b.v),promote_type(T,S),MUL,$product!,$preproduct!,$field)
             if mdims(V)<cache_limit/2
                 return :(Multivector{V}($(loop[2].args[2])))
             else return quote
@@ -1185,32 +1222,35 @@ for (op,product!) ∈ ((:∧,:exteraddmulti!),(:⟑,:geomaddmulti!),
         end
     end
 end
-for (op,product!) ∈ ((:∧,:exteraddspin!),(:⟑,:geomaddspin!),
-                     (:∨,:meetaddspin!),(:contraction,:skewaddspin!))
+for (op,product!,field) ∈ ((:∧,:exteraddspin!,false),(:⟑,:geomaddspin!,false),
+                     (:∨,:meetaddspin!,false),(:contraction,:skewaddspin!,false),
+                     (:wedgedot_metric,:geomaddspin!,true),(:contraction_metric,:skewaddspin!,true))
     preproduct! = Symbol(product!,:_pre)
-    prop = op≠:⟑ ? Symbol(:product_,op) : :product
+    prop = op∉(:⟑,:wedgedot_metric) ? Symbol(:product_,op) : :product
+    args = field ? (:g,) : ()
     @eval begin
-        @generated function $op(b::Spinor{V,T},a::TensorGraded{V,G}) where {V,T,G}
-            Grassmann.$prop(a,b,true)
+        @generated function $op(b::Spinor{V,T},a::TensorGraded{V,G},$(args...)) where {V,T,G}
+            Grassmann.$prop(a,b,true,$field)
         end
-        @generated function $op(a::TensorGraded{V,G},b::Spinor{V,S}) where {V,G,S}
-            Grassmann.$prop(a,b)
+        @generated function $op(a::TensorGraded{V,G},b::Spinor{V,S},$(args...)) where {V,G,S}
+            Grassmann.$prop(a,b,false,$field)
         end
-        @generated function $op(b::AntiSpinor{V,T},a::TensorGraded{V,G}) where {V,T,G}
-            Grassmann.$prop(a,b,true)
+        @generated function $op(b::AntiSpinor{V,T},a::TensorGraded{V,G},$(args...)) where {V,T,G}
+            Grassmann.$prop(a,b,true,$field)
         end
-        @generated function $op(a::TensorGraded{V,G},b::AntiSpinor{V,S}) where {V,G,S}
-            Grassmann.$prop(a,b)
+        @generated function $op(a::TensorGraded{V,G},b::AntiSpinor{V,S},$(args...)) where {V,G,S}
+            Grassmann.$prop(a,b,false,$field)
         end
     end
 end
-for (op,product!) ∈ ((:∧,:exteraddspin!),(:⟑,:geomaddspin!),(:contraction,:skewaddspin!))
+for (op,product!,field) ∈ ((:∧,:exteraddspin!,false),(:⟑,:geomaddspin!,false),(:contraction,:skewaddspin!,false),(:wedgedot_metric,:geomaddspin!,true),(:contraction_metric,:skewaddspin!,true))
     preproduct! = Symbol(product!,:_pre)
-    prop = op≠:⟑ ? Symbol(:product_,op) : :product
+    prop = op∉(:⟑,:wedgedot_metric) ? Symbol(:product_,op) : :product
+    args = field ? (:g,) : ()
     @eval begin
-        @generated function $op(a::Spinor{V,T},b::Spinor{V,S}) where {V,T,S}
+        @generated function $op(a::Spinor{V,T},b::Spinor{V,S},$(args...)) where {V,T,S}
             MUL,VEC = mulvec(a,b)
-            loop = generate_loop_spinor(V,:(a.v),:(b.v),promote_type(T,S),MUL,$product!,$preproduct!)
+            loop = generate_loop_spinor(V,:(a.v),:(b.v),promote_type(T,S),MUL,$product!,$preproduct!,$field)
             if mdims(V)<cache_limit/2
                 return :(Spinor{V}($(loop[2].args[2])))
             else return quote
@@ -1219,9 +1259,9 @@ for (op,product!) ∈ ((:∧,:exteraddspin!),(:⟑,:geomaddspin!),(:contraction,
                 return Spinor{V,t}(out)
             end end
         end
-        @generated function $op(a::AntiSpinor{V,T},b::AntiSpinor{V,S}) where {V,T,S}
+        @generated function $op(a::AntiSpinor{V,T},b::AntiSpinor{V,S},$(args...)) where {V,T,S}
             MUL,VEC = mulvec(a,b)
-            loop = generate_loop_anti(V,:(a.v),:(b.v),promote_type(T,S),MUL,$product!,$preproduct!)
+            loop = generate_loop_anti(V,:(a.v),:(b.v),promote_type(T,S),MUL,$product!,$preproduct!,$field)
             if mdims(V)<cache_limit/2
                 return :(Spinor{V}($(loop[2].args[2])))
             else return quote
@@ -1232,13 +1272,14 @@ for (op,product!) ∈ ((:∧,:exteraddspin!),(:⟑,:geomaddspin!),(:contraction,
         end
     end
 end
-for (op,product!) ∈ ((:∧,:exteraddanti!),(:⟑,:geomaddanti!),(:contraction,:skewaddanti!))
+for (op,product!,field) ∈ ((:∧,:exteraddanti!,false),(:⟑,:geomaddanti!,false),(:contraction,:skewaddanti!,false),(:wedgedot_metric,:geomaddanti!,true),(:contraction_metric,:skewaddanti!,true))
     preproduct! = Symbol(product!,:_pre)
-    prop = op≠:⟑ ? Symbol(:product_,op) : :product
+    prop = op∉(:⟑,:wedgedot_metric) ? Symbol(:product_,op) : :product
+    args = field ? (:g,) : ()
     @eval begin
-        @generated function $op(a::Spinor{V,T},b::AntiSpinor{V,S}) where {V,T,S}
+        @generated function $op(a::Spinor{V,T},b::AntiSpinor{V,S},$(args...)) where {V,T,S}
             MUL,VEC = mulvec(a,b)
-            loop = generate_loop_s_a(V,:(a.v),:(b.v),promote_type(T,S),MUL,$product!,$preproduct!)
+            loop = generate_loop_s_a(V,:(a.v),:(b.v),promote_type(T,S),MUL,$product!,$preproduct!,$field)
             if mdims(V)<cache_limit/2
                 return :(AntiSpinor{V}($(loop[2].args[2])))
             else return quote
@@ -1247,9 +1288,9 @@ for (op,product!) ∈ ((:∧,:exteraddanti!),(:⟑,:geomaddanti!),(:contraction,
                 return AntiSpinor{V,t}(out)
             end end
         end
-        @generated function $op(a::AntiSpinor{V,T},b::Spinor{V,S}) where {V,T,S}
+        @generated function $op(a::AntiSpinor{V,T},b::Spinor{V,S},$(args...)) where {V,T,S}
             MUL,VEC = mulvec(a,b)
-            loop = generate_loop_a_s(V,:(a.v),:(b.v),promote_type(T,S),MUL,$product!,$preproduct!)
+            loop = generate_loop_a_s(V,:(a.v),:(b.v),promote_type(T,S),MUL,$product!,$preproduct!,$field)
             if mdims(V)<cache_limit/2
                 return :(AntiSpinor{V}($(loop[2].args[2])))
             else return quote
@@ -1309,18 +1350,19 @@ for side ∈ (:left,:right)
     cc,p = Symbol(:complement,side),Symbol(:parity,side)
     h,pg,pn = Symbol(cc,:hodge),Symbol(p,:hodge),Symbol(p,:null)
     pnp = :(Leibniz.$(Symbol(pn,:pre)))
-    for (c,p) ∈ ((cc,p),(h,pg))
+    for (c,p,ff) ∈ ((cc,p,false),(h,pg,false),(h,pg,true))
+        args = ff ? (:g,) : ()
         @eval begin
-            $c(z::Phasor) = $c(Couple(z))
-            function $c(z::Couple{V}) where V
+            $c(z::Phasor,$(args...)) = $c(Couple(z),$(args...))
+            function $c(z::Couple{V},$(args...)) where V
                 G = grade(V)
-                Single{V,G,getbasis(V,UInt(1)<<G-1)}(realvalue(z)) + $c(imaginary(z))
+                Single{V,G,getbasis(V,UInt(1)<<G-1)}(realvalue(z)) + $c(imaginary(z),$(args...))
             end
-            $c(z::PseudoCouple{V}) where V = $c(volume(z)) + $c(imaginary(z))
-            @generated function $c(b::Chain{V,G,T}) where {V,G,T}
+            $c(z::PseudoCouple{V},$(args...)) where V = $c(volume(z),$(args...)) + $c(imaginary(z),$(args...))
+            @generated function $c(b::Chain{V,G,T},$(args...)) where {V,G,T}
                 isdyadic(V) && throw(error("Complement for dyadic tensors is undefined"))
-                istangent(V) && (return :($$c(Multivector(b))))
-                $(c≠h ? nothing : :((!isdiag(V)) && (return :($$cc(metric(b)))) ))
+                istangent(V) && (return :($$c(Multivector(b),$(args...))))
+                $(c≠h ? nothing : :(((!isdiag(V)) || $ff) && (return :($$cc(metric(b,$($args...))))) ))
                 SUB,VEC,MUL = subvec(b)
                 if binomial(mdims(V),G)<(1<<cache_limit)
                     $(insert_expr((:N,:ib,:D),:svec)...)
@@ -1350,9 +1392,9 @@ for side ∈ (:left,:right)
                     return Chain{V,N-G}(out)
                 end end
             end
-            @generated function $c(m::Multivector{V,T}) where {V,T}
+            @generated function $c(m::Multivector{V,T},$(args...)) where {V,T}
                 isdyadic(V) && throw(error("Complement for dyadic tensors is undefined"))
-                $(c≠h ? nothing : :((!isdiag(V)) && (return :($$cc(metric(m)))) ))
+                $(c≠h ? nothing : :(((!isdiag(V)) || $ff) && (return :($$cc(metric(m,$($args...))))) ))
                 SUB,VEC = subvec(m)
                 if mdims(V)<cache_limit
                     $(insert_expr((:N,:bs,:bn),:svec)...)
@@ -1388,9 +1430,9 @@ for side ∈ (:left,:right)
                     return Multivector{V}(out)
                 end end
             end
-            @generated function $c(m::Spinor{V,T}) where {V,T}
+            @generated function $c(m::Spinor{V,T},$(args...)) where {V,T}
                 isdyadic(V) && throw(error("Complement for dyadic tensors is undefined"))
-                $(c≠h ? nothing : :((!isdiag(V)) && (return :($$cc(metric(m)))) ))
+                $(c≠h ? nothing : :(((!isdiag(V)) || $ff) && (return :($$cc(metric(m,$($args...))))) ))
                 SUB,VEC = subvecs(m)
                 if mdims(V)<cache_limit
                     $(insert_expr((:N,:rs,:bn),:svec)...)
@@ -1426,9 +1468,9 @@ for side ∈ (:left,:right)
                     return $(isodd(N) ? :AntiSpinor : :Spinor){V}(out)
                 end end
             end
-            @generated function $c(m::AntiSpinor{V,T}) where {V,T}
+            @generated function $c(m::AntiSpinor{V,T},$(args...)) where {V,T}
                 isdyadic(V) && throw(error("Complement for dyadic tensors is undefined"))
-                $(c≠h ? nothing : :((!isdiag(V)) && (return :($$cc(metric(m)))) ))
+                $(c≠h ? nothing : :(((!isdiag(V)) || $ff) && (return :($$cc(metric(m,$($args...))))) ))
                 SUB,VEC = subvecs(m)
                 if mdims(V)<cache_limit
                     $(insert_expr((:N,:ps,:bn),:svec)...)
@@ -1502,17 +1544,19 @@ for c ∈ (:even,:odd)
         end
     end
 end
-for side ∈ (:metric,:anti)
+for (side,field) ∈ ((:metric,false),(:anti,false),(:metric,true),(:anti,true))
     c,p = (side≠:anti ? side : Symbol(side,:metric)),Symbol(:parity,side)
     tens,tensfull = Symbol(side,:tensor),Symbol(side,:full)
     tenseven,tensodd = Symbol(side,:even),Symbol(side,:odd)
+    args = field ? (:g,) : ()
     @eval begin
-        $c(z::Phasor) = $c(Couple(z))
-        $c(z::Couple{V}) where V = scalar(z) + $c(imaginary(z))
-        $c(z::PseudoCouple{V}) where V = $c(imaginary(z)) + $c(volume(z))
-        @generated function $c(b::Chain{V,G,T}) where {V,G,T}
+        $c(z::Phasor,$(args...)) = $c(Couple(z),$(args...))
+        $c(z::Couple{V},$(args...)) where V = scalar(z) + $c(imaginary(z),$(args...))
+        $c(z::PseudoCouple{V},$(args...)) where V = $c(imaginary(z),$(args...)) + $c(volume(z),$(args...))
+        @generated function $c(b::Chain{V,G,T},$(args...)) where {V,G,T}
             isdyadic(V) && throw(error("Complement for dyadic tensors is undefined"))
-            istangent(V) && (return :($$c(Multivector(b))))
+            istangent(V) && (return :($$c(Multivector(b),$$(args...))))
+            $field && (return :(contraction(g,b)))
             (!isdiag(V)) && (return :(contraction($($tens(V,G)),b)))
             SUB,VEC,MUL = subvec(b)
             if binomial(mdims(V),G)<(1<<cache_limit)
@@ -1549,8 +1593,9 @@ for side ∈ (:metric,:anti)
                 return Chain{V,G}(out)
             end end
         end
-        @generated function $c(m::Multivector{V,T}) where {V,T}
+        @generated function $c(m::Multivector{V,T},$(args...)) where {V,T}
             isdyadic(V) && throw(error("Complement for dyadic tensors is undefined"))
+            $field && (return :(contraction(g,m)))
             (!isdiag(V)) && (return :(contraction($($tensfull(V)),m)))
             SUB,VEC = subvec(m)
             if mdims(V)<cache_limit
@@ -1593,8 +1638,9 @@ for side ∈ (:metric,:anti)
                 return Multivector{V}(out)
             end end
         end
-        @generated function $c(m::Spinor{V,T}) where {V,T}
+        @generated function $c(m::Spinor{V,T},$(args...)) where {V,T}
             isdyadic(V) && throw(error("Complement for dyadic tensors is undefined"))
+            $field && (return :(contraction(g,m)))
             (!isdiag(V)) && (return :(contraction($($tenseven(V)),m)))
             SUB,VEC = subvecs(m)
             if mdims(V)<cache_limit
@@ -1637,9 +1683,10 @@ for side ∈ (:metric,:anti)
                 return Spinor{V}(out)
             end end
         end
-        @generated function $c(m::AntiSpinor{V,T}) where {V,T}
+        @generated function $c(m::AntiSpinor{V,T},$(args...)) where {V,T}
             isdyadic(V) && throw(error("Complement for dyadic tensors is undefined"))
-            (!isdiag(V)) && (return :(contraction($($tensodd(V)),m)))
+            $field && (return :(contraction(g,m)))
+            (!isdiag(V)) && (return :(contraction($($tensodd(V)),m,)))
             SUB,VEC = subvecs(m)
             if mdims(V)<cache_limit
                 $(insert_expr((:N,:ps,:bn),:svecs)...)
diff --git a/test/generictests.jl b/test/generictests.jl
index 45e9194..af53222 100644
--- a/test/generictests.jl
+++ b/test/generictests.jl
@@ -73,7 +73,7 @@ for 𝔽 in [Float64]
     α = rand(𝔽)
     @test α*e == α
     @testset "Field: $(𝔽)" begin
-        for G in [3,V"+++", S"∞+", S"∅+", V"-+++"]#, S"∞∅+"]
+        for G in [3,V"+++", S"∞+", S"∅+", V"-+++", S"∞∅+"]
             @testset "Algebra: $(G)" begin
                 dims = mdims(G)