use SolveCtx in inv (#2177)

* use SolveCtx in inv

* better Trait for Rational{BigInt}

* special case for MatRing

* .. in the correct module

* .. sorting name spaces

* fix the F2Matrix stuff for tests

Author: fieker

src/Matrix.jl

@@ -3715,7 +3715,7 @@ end
 
 function Base.inv(M::MatrixElem{T}) where {T <: FieldElement}
    is_square(M) || throw(DomainError(M, "Can not invert non-square Matrix"))
-   flag, A = _can_solve_with_solution_lu(M, identity_matrix(M))
+   flag, A = can_solve_with_solution(M, identity_matrix(M))
    !flag && error("Singular matrix in inv")
    return A
 end

src/Solve.jl

@@ -6,6 +6,7 @@ using AbstractAlgebra.PrettyPrinting: @show_name
 using AbstractAlgebra.PrettyPrinting: Dedent
 using AbstractAlgebra.PrettyPrinting: Indent
 using AbstractAlgebra.PrettyPrinting: pretty
+import AbstractAlgebra: can_solve_with_solution
 using AbstractAlgebra: _can_solve_with_solution_fflu
 using AbstractAlgebra: _can_solve_with_solution_interpolation
 using AbstractAlgebra: _solve_fflu_precomp
@@ -20,7 +21,6 @@ export solve
 export solve_init
 export solve_context_type
 export can_solve
-export can_solve_with_solution
 export can_solve_with_solution_and_kernel
 
 ################################################################################
@@ -97,6 +97,7 @@ function matrix_normal_form_type(R::Ring)
 end
 
 matrix_normal_form_type(::Field) = RREFTrait()
+matrix_normal_form_type(::Matrix{Rational{BigInt}}) = FFLUTrait()
 
 # The fflu approach is the fastest over a fraction field (see benchmarks on PR 661)
 matrix_normal_form_type(::FracField) = FFLUTrait()

src/fundamental_interface.jl

@@ -458,3 +458,5 @@ function _number_of_direct_product_factors end
 Return the homomorphism from the domain `D` into the codomain `C` defined by the data.
 """
 function hom end
+
+function can_solve_with_solution end

src/generic/MatRing.jl

@@ -55,6 +55,16 @@ function _can_solve_with_solution_lu(M::MatRingElem{T}, B::MatRingElem{T}) where
    return flag, SA
 end
 
+function AbstractAlgebra.can_solve_with_solution(M::MatRingElem{T}, B::MatRingElem{T}) where {T <: RingElement}
+   check_parent(M, B)
+   R = base_ring(M)
+   MS = MatSpaceElem{T}(R, M.entries) # convert to ordinary matrix
+   BS = MatSpaceElem{T}(R, B.entries)
+   flag, S = can_solve_with_solution(MS, BS)
+   SA = MatRingElem{T}(R, S.entries)
+   return flag, SA
+end
+
 function _can_solve_with_solution_fflu(M::MatRingElem{T}, B::MatRingElem{T}) where {T <: RingElement}
    check_parent(M, B)
    R = base_ring(M)

test/generic/Matrix-test.jl

@@ -47,8 +47,10 @@ struct F2Elem <: AbstractAlgebra.FieldElem
 end
 
 (::F2)(x::F2Elem) = x
+(::F2)(x::Integer) = F2Elem(x % Bool)
 Base.:-(x::F2Elem) = x
 Base.:+(x::F2Elem, y::F2Elem) = F2Elem(x.x ⊻ y.x)
+Base.:-(x::F2Elem, y::F2Elem) = F2Elem(x.x ⊻ y.x)
 Base.inv(x::F2Elem) = x.x ? x : throw(DivideError())
 Base.:*(x::F2Elem, y::F2Elem) = F2Elem(x.x * y.x)
 
@@ -60,6 +62,7 @@ AbstractAlgebra.elem_type(::Type{F2}) = F2Elem
 AbstractAlgebra.parent(x::F2Elem) = F2()
 AbstractAlgebra.mul!(x::F2Elem, y::F2Elem, z::F2Elem) = y * z
 AbstractAlgebra.add!(x::F2Elem, y::F2Elem) = x + y
+AbstractAlgebra.sub!(x::F2Elem, y::F2Elem) = x + y
 AbstractAlgebra.divexact(x::F2Elem, y::F2Elem) = y.x ? x : throw(DivideError())
 
 Random.rand(rng::AbstractRNG, sp::Random.SamplerTrivial{F2}) = F2Elem(rand(rng, Bool))