Define Dirac Matrices (in the Weyl representation).   Calculate the square root of p . sigma, square roots of 2x2 matrices, and representations of u, v spinors.

ClearAll[z2,DiracMatrix,pdotsigma,pdotosigma]

z2 =ConstantArray[0,{2,2}];

DiracMatrix::usage = "DiracMatrix[0-3].";
DiracMatrix[k_Integer] :=  ({{z2, PauliMatrix[k]}, {-PauliMatrix[k], z2}} // ArrayFlatten);
DiracMatrix[0] = ({{z2, PauliMatrix[0]}, {PauliMatrix[0], z2}} // ArrayFlatten);

pdotsigma::usage = "p · σ = (Subscript[p, μ]) (σ^μ)= (Subscript[p, 0]) - (OverVector[p]) · (OverVector[σ])";
pdotsigma[{p0_, p1_, p2_, p3_}] := p0 PauliMatrix[0] -p1 PauliMatrix[1] - p2 PauliMatrix[2] - p3 PauliMatrix[3] ;

pdotosigma::usage = "p · (OverBar[σ]) = (Subscript[p, 0]) + (OverVector[p]) · (OverVector[σ])";
pdotosigma[{p0_, p1_, p2_, p3_}] := pdotsigma[{p0, -p1, -p2, -p3}]

sqrtm::usage = "square root (numeric or symbolic) or a 2x2 matrix, assumed Hermitian.";
sqrtm[{{a_, b_}, {c_,d_}}] := Module[{m,values, vectors, u, ut, diag},
m = {{a,b},{c,d}};
{values, vectors} = Eigensystem[m];
ut = {vectors[[1]]// Normalize, vectors[[2]]// Normalize};
u = ut// Transpose;
diag = Sqrt[DiagonalMatrix[values]];
u . diag . ConjugateTranspose[u]
]


ClearAll[complex, normsq, norm, complexQ, notComplexQ, real, imag, conjugate, complexI]
complex/:complex[r1_,i1_]+complex[r2_,i2_]:=complex[r1+r2,i1+i2];
complex/:r1_+complex[r2_,i2_]:=complex[r1+r2,i2];

complex/:-complex[re_,im_]:=complex[-re,-im];

complex/:complex[re_]:=re;
complex/:complex[re_,0]:=re;

complex/:complex[r1_,i1_] complex[r2_,i2_]:=complex[r1 r2-i1 i2,r1 i2+r2 i1];


(* a simple Complex-like implementation that allows for explicitly encoding real and imaginary without using Assumptions. *)
complex/:Power[z_complex,2]:=complex[z] complex[z];
complex/:Power[z_complex,n_]:=Module[{r=norm[z]^(n/2),theta=n ArcTan[z//First,z//Last]},r complex[Cos[theta],Sin[theta]]];

normsq[z_complex]:=((z//First)^2+(z//Last)^2);
normsq[v_]:=v^2;
norm[v_] := Sqrt[normsq[v]];

complexQ[z_complex]:=True;
complexQ[_]:=False;
notComplexQ[v_]:=Not[complexQ[v]];

complex/:(v_?notComplexQ) complex[re_,im_]:=complex[v re,v im];

real[z_complex]:=(z//First);
imag[z_complex]:=(z//Last);
real[ex_]:=ex;
imag[ex_]:=0;
conjugate[z_complex]:=complex[z//First,-z//Last];
conjugate[ex_]:=ex;

complexI:=complex[0,1];

ClearAll[diracMatrix]
diracMatrix::usage = "Like DiracMatrix, but uses complex instead of Complex";
diracMatrix[2] = (DiracMatrix[2] /. {I -> complexI,-I -> -complexI});
diracMatrix[k_] := DiracMatrix[k]

ClearAll[pauliMatrix]
pauliMatrix::usage="Like PauliMatrix, but uses complex instead of Complex";
pauliMatrix[2]=(PauliMatrix[2]/.{I->complexI,-I->-complexI});
pauliMatrix[k_]:=PauliMatrix[k]

ClearAll[pSlashMinusM]
pSlashMinusM::usage = "(Subscript[p, μ])(γ^μ) : parameters are the (Subscript[p, μ])'s.";
pSlashMinusM[w_, px_, py_, pz_, m_] := w diracMatrix[0] + px diracMatrix[1] + py diracMatrix[2] + pz diracMatrix[3] - m IdentityMatrix[4];


ClearAll[sqrtpdotsigma]
sqrtpdotsigma[{w_,px_,py_,pz_, m_}] :=
(1/(Sqrt[2 w + 2 m])) {{w - pz + m, -px + complexI py},{-px - py complexI, w +pz + m}};
sqrtpdotsigma[{w_,px_,py_,pz_}] := Module[{p},
p = Sqrt[px^2 + py^2 + pz^2];
(1/(Sqrt[w - p] + Sqrt[w + p])) {{w - pz + Sqrt[w^2 - p^2], -px + complexI py},{-px - py complexI, w +pz + Sqrt[w^2 - p^2]}}
];


ClearAll[length, normalize, sqrtps]
length[p_] := Sqrt[p[[1]]^2+p[[2]]^2+p[[3]]^2];
normalize[v_] := v/Sqrt[(v// First // normsq) +  (v // Last // normsq)];

sqrtps[w_,px_,py_,pz_] := Module[{p, um,umdagger, d, scale, e1, e2,v1,v2,ps, f1, f2},
p = length[{px, py,pz}];
v1 = p + w;
v2 = -p +w;
e1 = normalize[{complex[-px, py ],complex[pz + p,0]}];
e2 = normalize[{complex[-px, py ],complex[pz - p,0]}];
f1 = normalize[{complex[-px, -py ],complex[pz + p,0]}];
f2 = normalize[{complex[-px, -py ],complex[pz - p,0]}];
um = Transpose[{e1,e2}] // ExpandAll;
d = DiagonalMatrix[{v1, v2}];
umdagger = {f1,f2}// ExpandAll;
umdagger// MatrixForm;

um.Sqrt[d].umdagger // ExpandAll // FullSimplify 
]

ClearAll[sqrtpdotsigma]
sqrtpdotsigma[{w_,px_,py_,pz_, m_}] :=
(1/(Sqrt[2 w + 2 m])) {{w - pz + m, -px + complexI py},{-px - py complexI, w +pz + m}};
sqrtpdotsigma[{w_,px_,py_,pz_}] := Module[{p},
p = Sqrt[px^2 + py^2 + pz^2];
(1/(Sqrt[w - p] + Sqrt[w + p])) {{w - pz + Sqrt[w^2 - p^2], -px + complexI py},{-px - py complexI, w +pz + Sqrt[w^2 - p^2]}}
];

ClearAll[u,v, eta, zeta]
eta[1] = {1,0};
eta[2] = {0,1};
zeta[1] = {1,0};
zeta[2] = {0,1};
u[w_,px_,py_,pz_,k_] := {sqrtpdotsigma[{w,px,py,pz}].eta[k], sqrtpdotsigma[{w,-px,-py,-pz}].eta[k]} // Flatten;
v[w_,px_,py_,pz_,k_] := {sqrtpdotsigma[{w,px,py,pz}].eta[k], -sqrtpdotsigma[{w,-px,-py,-pz}].eta[k]} // Flatten;


ClearAll[ubar,vbar];
ubar[w_,px_, py_, pz_,k_] := Map[conjugate,u[w,px,py,pz,k]].diracMatrix[0];
vbar[w_,px_, py_, pz_,k_] := Map[conjugate,v[w,px,py,pz,k]].diracMatrix[0];

Verify the anti-commutators (dot products)

(*Table[(DiracMatrix[i].DiracMatrix[j]+DiracMatrix[j].DiracMatrix[i])/2// MatrixForm, {i,0,3}, {j,0,3}]// Grid*)
Table[(diracMatrix[i].diracMatrix[j]+diracMatrix[j].diracMatrix[i])/2//MatrixForm,{i,0,3},{j,0,3}]//Grid

(diracMatrix[#]// MatrixForm) & /@(Range[4]-1)  // Row

pdotsigma[{w,px,py,pz}] // MatrixForm
pdotosigma[{w,px,py,pz}] // MatrixForm

pdotsigma[{w,px,py,pz}] // Eigenvalues
pdotosigma[{w,px,py,pz}] // Eigenvalues

pSlashMinusM[ω, -(Subscript[p, x]), -(Subscript[p, y]),-(Subscript[p, z]), m] // MatrixForm

mm = sqrtm[{{1,2},{2,4}}]
mm.mm

usq = sqrtps[ω,(Subscript[p, x]), (Subscript[p, y]),(Subscript[p, z]),m];
usq = usq // ExpandAll // FullSimplify ;
usq // MatrixForm

usq.usq // ExpandAll // FullSimplify // MatrixForm

uosq = sqrtps[ω,-(Subscript[p, x]), -(Subscript[p, y]),-(Subscript[p, z])];
uosq = uosq // ExpandAll // FullSimplify ;
uosq // MatrixForm

uosq.uosq // ExpandAll // FullSimplify // MatrixForm

{{u[ω, (Subscript[p, x]), (Subscript[p, y]),(Subscript[p, z]),1] // MatrixForm,
u[ω, (Subscript[p, x]), (Subscript[p, y]),(Subscript[p, z]),2] // MatrixForm,
v[ω, (Subscript[p, x]), (Subscript[p, y]),(Subscript[p, z]),1] // MatrixForm,
v[ω, (Subscript[p, x]), (Subscript[p, y]),(Subscript[p, z]),2] // MatrixForm}}// Grid

pSlashMinusM[ω, -(Subscript[p, x]), -(Subscript[p, y]),-(Subscript[p, z]), Sqrt[(ω^2) -((Subscript[p, x])^2) -((Subscript[p, y])^2)-((Subscript[p, z])^2)]] // MatrixForm

(*Test: verify that these solutions work.  I've used (Subscript[p, k ])as the spatial vector coordinates so flipped signs for the (Subscript[p, μ])'s below.*)
{{pSlashMinusM[ω, -(Subscript[p, x]), -(Subscript[p, y]),-(Subscript[p, z]), Sqrt[(ω^2) -((Subscript[p, x])^2) -((Subscript[p, y])^2)-((Subscript[p, z])^2)]] .u[ω, (Subscript[p, x]), (Subscript[p, y]),(Subscript[p, z]),1] // ExpandAll  // MatrixForm,
pSlashMinusM[ω, -(Subscript[p, x]), -(Subscript[p, y]),-(Subscript[p, z]), Sqrt[(ω^2) -((Subscript[p, x])^2) -((Subscript[p, y])^2)-((Subscript[p, z])^2)]] .u[ω, (Subscript[p, x]), (Subscript[p, y]),(Subscript[p, z]),2]// ExpandAll // MatrixForm,
pSlashMinusM[ω, -(Subscript[p, x]), -(Subscript[p, y]),-(Subscript[p, z]), -Sqrt[(ω^2) -((Subscript[p, x])^2) -((Subscript[p, y])^2)-((Subscript[p, z])^2)]] .v[ω, (Subscript[p, x]), (Subscript[p, y]),(Subscript[p, z]),1] // ExpandAll  // MatrixForm,
pSlashMinusM[ω, -(Subscript[p, x]), -(Subscript[p, y]),-(Subscript[p, z]), -Sqrt[(ω^2) -((Subscript[p, x])^2) -((Subscript[p, y])^2)-((Subscript[p, z])^2)]] .v[ω, (Subscript[p, x]), (Subscript[p, y]),(Subscript[p, z]),2]// ExpandAll // MatrixForm}} // Grid

(*manual test: these should be non-zero.*)
(*
{{pSlashMinusM[ω, -(Subscript[p, x]), -(Subscript[p, y]),-(Subscript[p, z]), Sqrt[(ω^2) -((Subscript[p, x])^2) -((Subscript[p, y])^2)-((Subscript[p, z])^2)]] .v[1] // ExpandAll  // MatrixForm,
pSlashMinusM[ω, -(Subscript[p, x]), -(Subscript[p, y]),-(Subscript[p, z]), Sqrt[(ω^2) -((Subscript[p, x])^2) -((Subscript[p, y])^2)-((Subscript[p, z])^2)]] .v[2]// ExpandAll // MatrixForm,
pSlashMinusM[ω, -(Subscript[p, x]), -(Subscript[p, y]),-(Subscript[p, z]), -Sqrt[(ω^2) -((Subscript[p, x])^2) -((Subscript[p, y])^2)-((Subscript[p, z])^2)]] .u[1] // ExpandAll  // MatrixForm,
pSlashMinusM[ω, -(Subscript[p, x]), -(Subscript[p, y]),-(Subscript[p, z]), -Sqrt[(ω^2) -((Subscript[p, x])^2) -((Subscript[p, y])^2)-((Subscript[p, z])^2)]] .u[2]// ExpandAll // MatrixForm}} // Grid
*)

(*u[ω, (Subscript[p, x]), (Subscript[p, y]),(Subscript[p, z]),1] [[2]]// FullForm*)

(*u[ω, (Subscript[p, x]), (Subscript[p, y]),(Subscript[p, z]),1] // conjugate*)
(*Map[conjugate,u[ω, (Subscript[p, x]), (Subscript[p, y]),(Subscript[p, z]),1]]*)



(*u[ω, (Subscript[p, x]), (Subscript[p, y]),(Subscript[p, z]),1] // MatrixForm
ubar[ω, (Subscript[p, x]), (Subscript[p, y]),(Subscript[p, z]),1] // MatrixForm*)

(*expect 2m, 2m, 0, 0*)
ubar[ω, (Subscript[p, x]), (Subscript[p, y]),(Subscript[p, z]),1].u[ω, (Subscript[p, x]), (Subscript[p, y]),(Subscript[p, z]),1]// FullSimplify
ubar[ω, (Subscript[p, x]), (Subscript[p, y]),(Subscript[p, z]),2].u[ω, (Subscript[p, x]), (Subscript[p, y]),(Subscript[p, z]),2]// FullSimplify
ubar[ω, (Subscript[p, x]), (Subscript[p, y]),(Subscript[p, z]),1].u[ω, (Subscript[p, x]), (Subscript[p, y]),(Subscript[p, z]),2]// FullSimplify
ubar[ω, (Subscript[p, x]), (Subscript[p, y]),(Subscript[p, z]),2].u[ω, (Subscript[p, x]), (Subscript[p, y]),(Subscript[p, z]),1]// FullSimplify

(*expect -2m, -2m, 0, 0*)
vbar[ω,Subscript[p,x],Subscript[p,y],Subscript[p,z],1].v[ω,Subscript[p,x],Subscript[p,y],Subscript[p,z],1]//FullSimplify
vbar[ω,Subscript[p,x],Subscript[p,y],Subscript[p,z],2].v[ω,Subscript[p,x],Subscript[p,y],Subscript[p,z],2]//FullSimplify
vbar[ω,Subscript[p,x],Subscript[p,y],Subscript[p,z],1].v[ω,Subscript[p,x],Subscript[p,y],Subscript[p,z],2]//FullSimplify
vbar[ω,Subscript[p,x],Subscript[p,y],Subscript[p,z],2].v[ω,Subscript[p,x],Subscript[p,y],Subscript[p,z],1]//FullSimplify

(pauliMatrix[#]// MatrixForm) & /@(Range[4]-1)  // Row
(*(((Sqrt[ω-(Sqrt[(Subscript[p, x]^2)+(Subscript[p, y]^2)+(Subscript[p, z]^2)])])+(Sqrt[ω+(Sqrt[(Subscript[p, x]^2)+(Subscript[p, y]^2)+(Subscript[p, z]^2)])]))(usq.pauliMatrix[1] - pauliMatrix[1].usq))// ExpandAll // MatrixForm
(((Sqrt[ω-(Sqrt[(Subscript[p, x]^2)+(Subscript[p, y]^2)+(Subscript[p, z]^2)])])+(Sqrt[ω+(Sqrt[(Subscript[p, x]^2)+(Subscript[p, y]^2)+(Subscript[p, z]^2)])]))(usq.pauliMatrix[2] - pauliMatrix[2].usq))// ExpandAll // MatrixForm
(((Sqrt[ω-(Sqrt[(Subscript[p, x]^2)+(Subscript[p, y]^2)+(Subscript[p, z]^2)])])+(Sqrt[ω+(Sqrt[(Subscript[p, x]^2)+(Subscript[p, y]^2)+(Subscript[p, z]^2)])]))(usq.pauliMatrix[3] - pauliMatrix[3].usq))// ExpandAll // MatrixForm*)

(((((((Sqrt[ω-(Sqrt[(Subscript[p, x]^2)+(Subscript[p, y]^2)+(Subscript[p, z]^2)])])+(Sqrt[ω+(Sqrt[(Subscript[p, x]^2)+(Subscript[p, y]^2)+(Subscript[p, z]^2)])])))^2))(usq.pauliMatrix[1].uosq +
usq.pauliMatrix[2].uosq+
usq.pauliMatrix[3].uosq))(*/. ω -> Sqrt[m^2 + (Subscript[p, x]^2)+(Subscript[p, y]^2)+(Subscript[p, z]^2)]*))//FullSimplify // MatrixForm

ubar[ω, "(p^1)", "(p^2)","(p^3)",1].diracMatrix[1].u[ω, "(p^1)", "(p^2)","(p^3)",1]