Given a matrix I want a cheap construction of something that is an aproximate inverse.  It is importantthat 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]]]