I was wrong here {
One can generalize spinors and create infinitely many kinds of objects by 'mimicking' a tensor.
It is known that Metvv=v^2.
So it would be logical to do va^2=a^2.
If a spinor is the square root in some sense, one then can do va^2=v2;
So one must define the map vaa->v, which can be recovered through QM, or whatever the situation is.
So spinors are likely not the most fundamental, because this can be applied as many times as one wants.
It is seen that the square of a vector is a scalar due to the metric which is a vector squared.
If the square of a spinor is a vector, then a vector times two spinors which is a spinor squared which is a vector.
So this kind of context where baa=b2=a2^2 supports the existence of a spinor when going this route (and infinitely many other things).
A spinor keeps the train of thought rolling past the assignment of real numbers in the metric, to create such objects.
This is a bunch of careful choices to implement the square root of an object.
But it is consistent in the result, and it works.
Time evolution should also be determined.
If Uvaa=v2, (where U defines the type of object such as a spinor) then d^n(Uvaa)=d^n(v2) determines the time evolution and an even larger whole new set of objects to explore.
In Short:So one does Uvss=v (s=spinor like object, v=vector).
For a general nth root one does Uva^n=v;
Another way to define a spinor is to 'slow down' the generators of the lie algebra by half.
Then one can restrict the values of U, or use that idea as another whole set of objects.
A spinor seems to act like both of these. The generators are slowed down and two of those objects can change a vector.
}
Doing more research and attempting to make it abelian to abelian,
I found that
{,}^(-1)(2*Met)=>Tensor_Product_Power(Met,1/2);
Simply put, it maps the undoing of the averaging (divide by 2) anticommutator binary operation (typically with the metric being the result of the anti-commutator of each object) to the half tensor product of that object (typically the metric (again)).
It goes like this:
If {a,b}=2*Met, then A2XB2=Met;
A2 is the transformation of A, and a is in A, same deal with b,B,B2.
The map is consistent (both ends are abelian so no need to worry yet).
The dimension for these items a and b is typically 2^k, while the dimensions for A2 and B2 is likely k.
I first thought today, that It maps the anti...-anti-commutator (look above to see what I mean, it's crazier than just a commutator. I didn't stutter nor am I using double negatives to make either positive or negative clauses. ), to the anti-product (gets a set).
That is obviously wrong, since one is abelian the other is not.
So I found this.
I need more prefixes than the english language offers to make this sentence.
Anti2-Anti-Average-Like-Commutator of the Metric goes to Anti2-Tensor-Product-Square of the Metric.
That is the way to remember it (At least for me).
The gamma matrices are the anti2-anti-commutator of the metric. I put a 2 there to warn you that this means undoing a binary operation to recover a set of items, rather than the anti as in anti-commutator kind of anti.
The best way to write it I found is,
Make_Spinor({,}^(-1)(Met))=(X)^(1/2)(Met).
The dimensions are likely either a matter of combinatorics, or quantum mechanics.
Another way to think about it quantum mechanically, is SMAT_{universal}(sqrt((...)a^2+(...)b^2+...),a,b,...) maps to MetX^(1/2).
What I mean by that, is solve a constant matrix for some square root of the sum of squares (or another combination via the metric) and map it to the vector that it's square tensor product is the metric.
So that becomes even simpler.
One does SMAT(sqrt(Met(s,s)),s)->sqrt_{Tensor_Product)(Met);
That becomes SMAT(sqrt O Met*s^2,...)->sqrt(SMAT(ds,v^2)).
That becomes SMATsqrt(...)->sqrtSMAT(...) (the simplest it can be).
SMAT(OUT,IN) is basically 'solve matrix' (like neural networking). I find that is the best way to notate it. Partial derivatives aren't always clear on what it doesn't include, while a matrix problem is 100% clear and one can execute it the same way every time.
My notation is different (I develop my own notation like newton,.... (long list)), so beware. But it is well suited to all of these concepts.
Hopefully I simplified it.
The main result (in very short form) is:
sqrt*SMAT(...)<->SMAT * sqrt(..)...;
That is the main rule that recovers it all. To me it is currently the most important. I don't know about others (they might just call me crazy), but the work on spinors cares in itself.