diff --git a/Project.toml b/Project.toml index f34b6f624421..15c61340e783 100644 --- a/Project.toml +++ b/Project.toml @@ -26,7 +26,7 @@ UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" cohomCalg_jll = "5558cf25-a90e-53b0-b813-cadaa3ae7ade" [compat] -AbstractAlgebra = "0.37.5" +AbstractAlgebra = "0.37.6" AlgebraicSolving = "0.4.6" Distributed = "1.6" DocStringExtensions = "0.8, 0.9" @@ -35,7 +35,7 @@ Hecke = "0.27.0" JSON = "^0.20, ^0.21" JSON3 = "1.13.2" LazyArtifacts = "1.6" -Nemo = "0.41.3" +Nemo = "0.41.5" Pkg = "1.6" Polymake = "0.11.12" Preferences = "1" diff --git a/experimental/GITFans/src/GITFans.jl b/experimental/GITFans/src/GITFans.jl index fb57333b1c46..eac7160afce7 100644 --- a/experimental/GITFans/src/GITFans.jl +++ b/experimental/GITFans/src/GITFans.jl @@ -7,6 +7,8 @@ module GITFans # the necessary Julia packages using Oscar +import Oscar: AbstractAlgebra.Solve + export git_fan ############################################################################# @@ -207,7 +209,7 @@ function action_on_target(Q::Matrix{Int}, G::PermGroup) matgens = typeof(mat)[] for ppi in permgens matimg = mat[Vector{Int}(ppi), 1:n] # permute the rows with `ppi` - push!(matgens, solve(mat, matimg)) + push!(matgens, Solve.solve(mat, matimg; side = :right)) end # Create the matrix group. diff --git a/experimental/LieAlgebras/src/LieAlgebraIdeal.jl b/experimental/LieAlgebras/src/LieAlgebraIdeal.jl index 14dd8759d4f1..fcb2c28fb409 100644 --- a/experimental/LieAlgebras/src/LieAlgebraIdeal.jl +++ b/experimental/LieAlgebras/src/LieAlgebraIdeal.jl @@ -23,7 +23,7 @@ left = copy(gens) while !isempty(left) g = pop!(left) - can_solve(basis_matrix, _matrix(g); side=:left) && continue + Solve.can_solve(basis_matrix, _matrix(g); side=:left) && continue for b in basis(L) push!(left, b * g) end diff --git a/experimental/LieAlgebras/src/LieAlgebras.jl b/experimental/LieAlgebras/src/LieAlgebras.jl index d8c53b55cb19..3dec1cacffee 100644 --- a/experimental/LieAlgebras/src/LieAlgebras.jl +++ b/experimental/LieAlgebras/src/LieAlgebras.jl @@ -13,8 +13,10 @@ using AbstractAlgebra: CacheDictType, ProductIterator, get_cached!, ordinal_numb using AbstractAlgebra.PrettyPrinting + # functions with new methods import ..Oscar: + AbstractAlgebra.Solve, _iso_oscar_gap, action, basis_matrix, diff --git a/experimental/LieAlgebras/src/LieSubalgebra.jl b/experimental/LieAlgebras/src/LieSubalgebra.jl index 09a9ebd68637..2d64ab56676e 100644 --- a/experimental/LieAlgebras/src/LieSubalgebra.jl +++ b/experimental/LieAlgebras/src/LieSubalgebra.jl @@ -23,7 +23,7 @@ left = copy(gens) while !isempty(left) g = pop!(left) - can_solve(basis_matrix, _matrix(g); side=:left) && continue + Solve.can_solve(basis_matrix, _matrix(g); side=:left) && continue for i in 1:nrows(basis_matrix) push!(left, g * L(basis_matrix[i, :])) end @@ -160,7 +160,7 @@ end Return `true` if `x` is in the Lie subalgebra `S`, `false` otherwise. """ function Base.in(x::LieAlgebraElem, S::LieSubalgebra) - return can_solve(basis_matrix(S), _matrix(x); side=:left) + return Solve.can_solve(basis_matrix(S), _matrix(x); side=:left) end ############################################################################### diff --git a/experimental/LieAlgebras/src/Util.jl b/experimental/LieAlgebras/src/Util.jl index b6a7aff337ca..e61e595e762d 100644 --- a/experimental/LieAlgebras/src/Util.jl +++ b/experimental/LieAlgebras/src/Util.jl @@ -24,7 +24,7 @@ function coefficient_vector(M::MatElem{T}, basis::Vector{<:MatElem{T}}) where {T for i in 1:nr, j in 1:nc rhs[(i - 1) * nc + j, 1] = M[i, j] end - fl, sol = can_solve_with_solution(lgs, rhs) + fl, sol = Solve.can_solve_with_solution(lgs, rhs; side = :right) @assert fl return transpose(sol) end diff --git a/experimental/LieAlgebras/test/LieAlgebraModule-test.jl b/experimental/LieAlgebras/test/LieAlgebraModule-test.jl index e581c1968467..a269edcc9507 100644 --- a/experimental/LieAlgebras/test/LieAlgebraModule-test.jl +++ b/experimental/LieAlgebras/test/LieAlgebraModule-test.jl @@ -402,7 +402,7 @@ b = V() while iszero(a) || iszero(b) || - can_solve( + Oscar.Solve.can_solve( Oscar.LieAlgebras._matrix(a), Oscar.LieAlgebras._matrix(b); side=:left, diff --git a/experimental/ModStd/ModStdQt.jl b/experimental/ModStd/ModStdQt.jl index d5e71977c2fe..2afa546004b6 100644 --- a/experimental/ModStd/ModStdQt.jl +++ b/experimental/ModStd/ModStdQt.jl @@ -3,6 +3,7 @@ module ModStdQt using Oscar import Oscar.Nemo import Oscar.Hecke +import Oscar.Solve function __init__() Hecke.add_verbose_scope(:ModStdQt) @@ -892,7 +893,7 @@ function Oscar.lift(f::PolyRingElem, g::PolyRingElem, a::AbsSimpleNumFieldElem, for i=1:n mm[i, 1] = coeff(d*b, i-1) end - s = solve(m, mm) + s = Solve.solve(m, mm; side = :right) B = q(parent(f)(vec(collect(s)))) @assert all(x->iszero(evaluate(numerator(x), V)), coefficients(lift(gg(B)))) o = lift(inv(derivative(gg)(B))) diff --git a/experimental/QuadFormAndIsom/src/embeddings.jl b/experimental/QuadFormAndIsom/src/embeddings.jl index 5015532d4bf6..f4e24ffc7127 100644 --- a/experimental/QuadFormAndIsom/src/embeddings.jl +++ b/experimental/QuadFormAndIsom/src/embeddings.jl @@ -925,7 +925,8 @@ function _subgroups_orbit_representatives_and_stabilizers_elementary(Vinq::TorQu F = base_ring(Qp) # K is H0 but seen a subvector space of Vp (which is V) - k, K = kernel(VptoQp.matrix; side = :left) + K = Solve.kernel(VptoQp.matrix; side = :left) + k = nrows(K) gene_H0p = elem_type(Vp)[Vp(vec(collect(K[i,:]))) for i in 1:k] orb_and_stab = orbit_representatives_and_stabilizers(MGp, g-k) diff --git a/experimental/Rings/QQAbAndPChars.jl b/experimental/Rings/QQAbAndPChars.jl index 862472b70ca8..19827be0ac2a 100644 --- a/experimental/Rings/QQAbAndPChars.jl +++ b/experimental/Rings/QQAbAndPChars.jl @@ -4,6 +4,8 @@ using ..Oscar import Oscar: IJuliaMime +import Oscar: Solve + ############################################################################### # # Partial character functions @@ -42,7 +44,7 @@ end function (Chi::PartialCharacter)(b::ZZMatrix) @assert nrows(b) == 1 @assert Nemo.ncols(b) == Nemo.ncols(Chi.A) - s = can_solve_with_solution(Chi.A, b, side = :left) + s = Solve.can_solve_with_solution(Chi.A, b, side = :left) @assert s[1] return evaluate(FacElem(Dict([(Chi.b[i], s[2][1, i]) for i = 1:length(Chi.b)]))) end diff --git a/experimental/Schemes/elliptic_surface.jl b/experimental/Schemes/elliptic_surface.jl index fe2c64a2444b..b0280c7f0821 100644 --- a/experimental/Schemes/elliptic_surface.jl +++ b/experimental/Schemes/elliptic_surface.jl @@ -1028,7 +1028,8 @@ function _prop217(E::EllipticCurve, P::EllipticCurvePoint, k) cc = [[coeff(j, abi) for abi in ab] for j in eqns] M = matrix(B, length(eqns), length(ab), reduce(vcat,cc, init=elem_type(base)[])) # @assert M == matrix(base, cc) # does not work if length(eqns)==0 - kerdim, K = kernel(M) + K = Solve.kernel(M; side = :right) + kerdim = ncols(K) result = Tuple{elem_type(Bt),elem_type(Bt)}[] t = gen(Bt) for j in 1:kerdim diff --git a/src/AlgebraicGeometry/Surfaces/K3Auto.jl b/src/AlgebraicGeometry/Surfaces/K3Auto.jl index 4c470f074255..a96a0488957f 100644 --- a/src/AlgebraicGeometry/Surfaces/K3Auto.jl +++ b/src/AlgebraicGeometry/Surfaces/K3Auto.jl @@ -564,7 +564,7 @@ function short_vectors_affine(gram::MatrixElem, v::MatrixElem, alpha::QQFieldEle tmp = FakeFmpqMat(w) wn = numerator(tmp) wd = denominator(tmp) - b, x = can_solve_with_solution(transpose(wn), matrix(ZZ, 1, 1, [alpha*wd])) + b, x = can_solve_with_solution(transpose(wn), matrix(ZZ, 1, 1, [alpha*wd]); side = :right) if !b return QQMatrix[] end @@ -1096,7 +1096,7 @@ function _alg58_close_vector(data::BorcherdsCtx, w::ZZMatrix) B = basis_matrix(SSdual) KB = K*B for (alpha, d) in keys(cvp_inputs) - can_solve_i, x = can_solve_with_solution(transpose(wn), matrix(ZZ, 1, 1, [alpha*wd])) + can_solve_i, x = Solve.can_solve_with_solution(transpose(wn), matrix(ZZ, 1, 1, [alpha*wd]); side = :right) if !can_solve_i continue end @@ -1598,8 +1598,8 @@ function span_in_S(L, S, weyl) else M = linear_equation_matrix(spanC) end - k, K = kernel(M) - gensN = transpose(K)[1:k,:] + K = Solve.kernel(M; side = :right) + gensN = transpose(K) return gensN end diff --git a/src/AlgebraicGeometry/ToricVarieties/ToricMorphisms/attributes.jl b/src/AlgebraicGeometry/ToricVarieties/ToricMorphisms/attributes.jl index 4b85615f2109..abfc05f06689 100644 --- a/src/AlgebraicGeometry/ToricVarieties/ToricMorphisms/attributes.jl +++ b/src/AlgebraicGeometry/ToricVarieties/ToricMorphisms/attributes.jl @@ -78,7 +78,7 @@ Map v = [images[i,k] for k in 1:ncols(images)] j = findfirst(x -> x == true, [(v in maximal_cones(cod)[j]) for j in 1:nmaxcones(cod)]) m = reduce(vcat, [Int(ray_indices(maximal_cones(cod))[j, k]) * cod_rays[k:k, :] for k in 1:nrays(cod)]) - mapping_matrix = hcat(mapping_matrix, solve(transpose(m), transpose(images[i:i, :]))) + mapping_matrix = hcat(mapping_matrix, solve(transpose(m), transpose(images[i:i, :]); side = :right)) end return hom(torusinvariant_weil_divisor_group(d), torusinvariant_weil_divisor_group(cod), transpose(mapping_matrix)) end @@ -240,7 +240,7 @@ Covering hb_V_mat = matrix(ZZ, hb_V) hb_V_img = hb_V_mat * At hb_U_mat = matrix(ZZ, hb_U) - sol = solve_left(hb_U_mat, hb_V_img) + sol = solve(hb_U_mat, hb_V_img; side = :left) @assert sol*hb_U_mat == hb_V_img @assert all(x->x>=0, sol) diff --git a/src/Oscar.jl b/src/Oscar.jl index 2c02dfa3a82d..432adb134afd 100644 --- a/src/Oscar.jl +++ b/src/Oscar.jl @@ -203,6 +203,27 @@ function build() system("Build.jl") end +# temporarily + +import AbstractAlgebra: Solve + +const solve = AbstractAlgebra.Solve.solve +const can_solve = AbstractAlgebra.Solve.can_solve +const can_solve_with_solution = AbstractAlgebra.Solve.can_solve_with_solution + +kernel(args...; kw...) = Hecke.kernel(args...; kw...) + +export solve, can_solve, can_solve_with_solution, kernel + +function kernel(M::MatElem; side::Symbol = :right) + return AbstractAlgebra.Solve.kernel(M, side = side) +end + +function kernel(R::Ring, M::MatElem; side::Symbol = :right) + return AbstractAlgebra.Solve.kernel(R, M, side = side) +end + + include("assertions.jl") include("exports.jl") diff --git a/src/Rings/AbelianClosure.jl b/src/Rings/AbelianClosure.jl index 9496cef12842..c75b28e03c6b 100644 --- a/src/Rings/AbelianClosure.jl +++ b/src/Rings/AbelianClosure.jl @@ -923,7 +923,7 @@ function _embedding(F::AbsSimpleNumField, K::QQAbField{AbsSimpleNumField}, x = Hecke.force_coerce_cyclo(Kn, x) # ... and then w.r.t. `F` a = Hecke.coefficients(x) - fl, sol = can_solve_with_solution(c, matrix(QQ, length(a), 1, a)) + fl, sol = can_solve_with_solution(c, matrix(QQ, length(a), 1, a); side = :right) if fl b = transpose(sol) b = [b[i] for i in 1:length(b)] diff --git a/src/Rings/groebner.jl b/src/Rings/groebner.jl index 473522b94952..079d6f526a96 100644 --- a/src/Rings/groebner.jl +++ b/src/Rings/groebner.jl @@ -1561,7 +1561,7 @@ function _find_weights(F::Vector{P}) where {P <: MPolyRingElem} exp_diffs = permutedims(reduce(hcat, [e[i] - e[1] for e in (collect).((exponents).(F)) for i in 2:length(e)])) - K = kernel(matrix(QQ, nrows, ncols, exp_diffs))[2] + K = kernel(matrix(QQ, nrows, ncols, exp_diffs); side = :right) isempty(K) && return zeros(Int, ncols) # Here we try to find a vector with strictly positive entries in K # this method to find such a vector is taken from diff --git a/src/imports.jl b/src/imports.jl index b17da7fc48b9..19915f75c58c 100644 --- a/src/imports.jl +++ b/src/imports.jl @@ -175,6 +175,10 @@ let exclude_hecke = [ :tail, :terms, :YoungTableau, + :kernel, + :solve, + :can_solve, + :can_solve_with_solution, ] for i in names(Hecke) (i in exclude_hecke || !isdefined(Hecke, i)) && continue