At the moment we have:
 	1) A linear “reference map” from our reference triangle to our physical triangle.
 	2) A simple class of functions on the reference triangle. 
 Since our “reference map” is linear the class of functions is the same on the physical triangle as on the reference triangle.  This has the advantage of 
 simplicity but has a draw back when trying to generate smooth spaces. There is an unavoidable problem at vertices and edges where the piecewise definition of the underlying map shines through.

ϕ[{X1_,X2_}]:= If[ X1<1-X2,1-X1-X2,0]
Plot3D[ϕ[{X1,X2}],{X1,0,1},{X2,0,1}]
ParametricPlot3D[{X1,X2,ϕ[{X1,X2}]},
{X1,0,1},{X2,0,1}]

p1[X_,{x1_,x2_,x3_}]:= x1+ Transpose[{x2-x1,x3-x1}].X
xx1=RandomReal[{-1,1},{3,2}];
Show[
Graphics[{
{LightBlue,Polygon[Map[ p1[#,xx1]&,{{0,0},{1,0},{0,1}}]]},
{PointSize[0.03],Map[Point,xx1]}
}
],
Frame->True
]

ParametricPlot3D[
Join[p1[{X1,X2},xx1],{ϕ[{X1,X2}]}],
{X1,0,1},{X2,0,1}]

Show[
ParametricPlot[ p1[{X1,X2},xx1],{X1,0,1},{X2,0,1}],
Graphics[{
{Red, Opacity[0.5],Polygon[xx1]},
{Blue,Arrow[xx1]},
{Red, PointSize[0.02],Map[Point,xx1]}
}
]
]

Plot[

Break

Given a matrix I want a cheap construction of something that is an aproximate inverse.  It is important that it commutes. The idea I had was that I could do a recursive construction using the 2×2 formula.
	(((({{a, b}, {c, d}})))^(-1))=(1/(a d - bc))(({{d, -b}, {-c,   a}}))

Obvious comments are:  
1)  the present version has a scaled copy of this without the -signs.  It might work better with the -signs in it.

2) There is an obvious way to extend this.
	 (((({{(Subscript[𝔸, 1,1]), (Subscript[𝔸, 1,2])}, {(Subscript[𝔸, 2,1]), (Subscript[𝔸, 2,2])}})))^(-1))=((((Subscript[𝔸, 1,1]) (Subscript[𝔸, 2,2]) - (Subscript[𝔸, 1,2])(Subscript[𝔸, 2,1])))^(-1))(({{   (Subscript[𝔸, 2,2]), -(Subscript[𝔸, 1,2])}, {-(Subscript[𝔸, 2,1]),    (Subscript[𝔸, 1,1])}}))
If I want to make this into arithmetic I need to make the matrix inverse explicit.  I see two possibilities right now. 
 a) I can diagonalize the poor thing 
 b) or I can ignore it.
 or I can do something more complicated.

Flip[A_]:= Module[
{n=Length[A],Xdiv,XASplit},
ASplit=Partition[A,{n/2,n/2}];
div=Max[Diagonal[ASplit[[1,1]].ASplit[[2,2]]-ASplit[[1,2]].ASplit[[2,1]]]];
ArrayFlatten[{
{ASplit[[2,2]],-ASplit[[1,2]]},
{-ASplit[[2,1]],ASplit[[1,1]]}
}]
]

FAD=Flip[AD]
AD.FAD-FAD.AD
AD.FAD

FA=Flip[A];
A.FA-FA.A

ASplit[[1,1]].ASplit[[2,2]]
div
FAD

?Switch

n=2;
A= Array[a,{n,n}];
MatrixForm[Simplify[Det[A]Inverse[A]]]
Det[A]

n=2;
A= Array[a,{n,n}]/.{a[1,1]->1,a[2,2]->1};
A0=Array[a0,{n,n}];
Expand[
A.A0-A0.A
]//MatrixForm
G=FullSimplify[
((Norm[A0-A0.A.A0,"Frobenius"])^2)
]/.((Abs[z_])^(2 )):>(z^2)

Simplify[D[G, {{a0[1,1], a0[2,2]}}]]==0

Minimize something inside the class of permutng stuff.

D

n=2;
Mat[i_,j_]:= Array[a[i,j],{2,2}]
A=ArrayFlatten[Array[Mat,{2,2}]];
MatrixForm[A]
MatrixForm[Expand[Det[A]Inverse[A]]]