refactor code

Author: vitktor

.github/workflows/TagBot.yml

@@ -6,7 +6,7 @@ on:
   workflow_dispatch:
     inputs:
       lookback:
-        default: 3
+        default: "3"
 permissions:
   actions: read
   checks: read

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Viktor Korotynskiy <korotynskiy.viktor@gmail.com> and contributors
+Copyright (c) 2026 Viktor Korotynskiy <korotynskiy.viktor@gmail.com> and contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

src/DecomposingPolynomialSystems.jl

@@ -3,23 +3,20 @@ module DecomposingPolynomialSystems
 import HomotopyContinuation
 const HC = HomotopyContinuation
 using HomotopyContinuation.ModelKit
-export @var, Variable, Expression, System
+export @var, Variable, Expression, subs
 
 using SparseArrays: SparseVector, SparseMatrixCSC, spzeros, AbstractSparseVector, findnz, sparse
 using Combinatorics: partitions, multiset_permutations, combinations
-using LinearAlgebra: nullspace
+using LinearAlgebra: nullspace, I, det
+export det
 using UnPack: @unpack
 
 include("utils.jl")
-include("sampled_system.jl")
+include("param_system.jl")
+include("sampling/sampled_system.jl")
 include("monomials.jl")
-# include("expression_map.jl")
 include("scalings.jl")
 include("interpolation.jl")
 include("deck_transformations.jl")
-# include("invariants.jl")
-# include("implicitization.jl")
-# include("decompose.jl")
-
 
 end # module

src/deck_transformations.jl

@@ -53,17 +53,17 @@ A `DeckTransformationGroup` is the result of deck transformations computation.
 struct DeckTransformationGroup
     maps::Vector{DeckTransformation}
     group::GapObj
-    F::SampledSystem
+    F::SampledParametricSystem
 end
 
-function DeckTransformationGroup(F::SampledSystem)
+function DeckTransformationGroup(F::SampledParametricSystem)
     symmetries = _init_symmetries(length(deck_permutations(F)), unknowns(F))
     return DeckTransformationGroup(symmetries, F)
 end
 
 function DeckTransformationGroup(
     symmetries::Vector{Vector{MiExpression}},
-    F::SampledSystem
+    F::SampledParametricSystem
 )
     action = [DeckTransformation(symmetry, unknowns(F), parameters(F)) for symmetry in symmetries]
     return DeckTransformationGroup(action, to_group(deck_permutations(F)), F)
@@ -386,7 +386,7 @@ end
 # end
 
 function _sample_for_deck_computation(
-    F::SampledSystem;
+    F::SampledParametricSystem;
     n_instances::Int
 )
     Δ_ninstances = n_instances - ninstances(F)
@@ -396,7 +396,7 @@ function _sample_for_deck_computation(
 end
 
 function symmetries_fixing_parameters_graded!(
-    F::SampledSystem,
+    F::SampledParametricSystem,
     grading::Grading;
     degree_bound::Integer=1,
     param_dep::Bool=true,
@@ -477,7 +477,7 @@ function symmetries_fixing_parameters_graded!(
 end
 
 function symmetries_fixing_parameters_dense!(
-    F::SampledSystem; 
+    F::SampledParametricSystem; 
     degree_bound::Integer=1,
     param_dep::Bool=true,
     tols::Tolerances=Tolerances(),
@@ -546,7 +546,7 @@ to_CC(scaling::Tuple{Tv, SparseVector{Tv,Ti}}) where {Tv<:Integer,Ti<:Integer} =
 function _deck_action(
     deck_permutation::Vector{Int},
     (x₀, p₀)::NTuple{2, AbstractVector{<:Number}},
-    F::SampledSystem;
+    F::SampledParametricSystem;
     tol::Real=1e-5
 )
     sols, params = all_solutions_samples(F).solutions, all_solutions_samples(F).parameters
@@ -565,7 +565,7 @@ end
 function _deck_commutes_with_scaling(
     deck_permutation::Vector{Int},
     scaling::Tuple{Tv, SparseVector{Tv,Ti}},
-    F::SampledSystem;
+    F::SampledParametricSystem;
     tol::Real=1e-5
 ) where {Tv<:Integer,Ti<:Integer}
 
@@ -584,7 +584,7 @@ function _deck_commutes_with_scaling(
 end
 
 function _all_deck_commute(
-    F::SampledSystem,
+    F::SampledParametricSystem,
     scaling::Tuple{Tv, SparseVector{Tv, Ti}};
     tol::Real=1e-5
 ) where {Tv<:Integer,Ti<:Integer}
@@ -597,10 +597,13 @@ function _all_deck_commute(
     return true
 end
 
-function _scalings_commuting_with_deck(F::SampledSystem, scalings::ScalingGroup)
-    grading = scalings.grading
-    final_grading = Grading{Int8, Int16}(nfree(grading), grading.free_part, [])
-    for (sᵢ, Uᵢ) in grading.mod_part
+function _scalings_commuting_with_deck(F::SampledParametricSystem, scalings::ScalingGroup)
+    if isempty(grading(scalings))
+        return scalings
+    end
+    grding = scalings.grading
+    final_grading = Grading{Int8, Int16}(nfree(grding), grding.free_part, [])
+    for (sᵢ, Uᵢ) in grding.mod_part
         Vᵢ = Array{Int}(undef, 0, size(Uᵢ, 2))
         # TODO: Uᵢ ↦ all linear combinations of rows of Uᵢ (might not commute with 2 gens, but commutes with their combination)
         for j in axes(Uᵢ, 1)
@@ -616,7 +619,7 @@ function _scalings_commuting_with_deck(F::SampledSystem, scalings::ScalingGroup)
 end
 
 function symmetries_fixing_parameters!(
-    F::SampledSystem;
+    F::SampledParametricSystem;
     degree_bound::Integer=1,
     param_dep::Bool=true,
     tols::Tolerances=Tolerances(),
@@ -627,7 +630,8 @@ function symmetries_fixing_parameters!(
         return DeckTransformationGroup(F)
     end
 
-    scalings = _scalings_commuting_with_deck(F, scaling_symmetries(F))
+    scalings = scaling_symmetries(F)
+    scalings = _scalings_commuting_with_deck(F, scalings)
     # scalings = param_dep ? scalings : restrict_scalings(scalings, unknowns(F))  # TODO: justify!
     if isempty(grading(scalings))
         logging && printstyled("Running dense version...\n", color=:green)
@@ -726,7 +730,7 @@ function reduced_nullspace(A::AbstractMatrix{<:Number}; tols::Tolerances=Toleran
 end
 
 function deck_vandermonde_dense(
-    F::SampledSystem;
+    F::SampledParametricSystem;
     deck_id::Int,
     var::Variable,
     degree::Integer=1,
@@ -765,7 +769,7 @@ function to_multiexponent(mon::Expression, vars::Vector{Variable})
 end
 
 function deck_vandermonde_graded(
-    F::SampledSystem,
+    F::SampledParametricSystem,
     grading::Grading;
     deck_id::Int,
     var::Variable,

src/decompose.jl

@@ -287,61 +287,3 @@ function interpolate(
         error("Not supported method '", method, "' for interpolation")
     end
 end
-
-
-
-
-
-
-
-#----------- SPARSE INTERPOLATION TESTING -------------
-
-function inv_chinese(d::Int, p::Vector{Int})
-    n = length(p)
-    m = prod(p)
-    D = zeros(Int, n)
-    for i in 1:n
-        D[i] = mod(d*invmod(Int(m/p[i]), p[i]), p[i])
-    end
-    return D
-end
-
-function companion_matrix(λ::Vector{CC})::Matrix{CC}
-    d = length(λ)
-    return [[zeros(1,d-1); eye(d-1)] -λ]
-end
-
-function f(x, y)
-    return x^20*y + 2*x^2 + 3*x + 4*y^11 + 5
-end
-
-function interpolate_sparse()
-
-end
-
-# t = 5 # number of terms in f
-# p₁, p₂ = 139, 193 # pᵢ > deg(fₓᵢ)
-# m = p₁*p₂
-# ω₁, ω₂ = cispi(2/p₁), cispi(2/p₂) # pᵢ-th roots of unity
-# ω = cispi(2/m)
-
-# α = [f(ω₁^s, ω₂^s) for s in 0:2*t-1]
-
-# H₀ = VV2M([[α[j] for j in i:i+t-1] for i in 1:t])
-# h = -[α[i] for i in t+1:2*t]
-# Hh = [H₀ -h]
-# N = nullspace(Hh)
-# λ = M2V(p2a(N))
-
-# M = companion_matrix(λ) 
-# b = eigvals(M)
-
-# d = [mod(Int(round(log(ω, b[i]))), m) for i in 1:length(b)]
-# e = [inv_chinese(d[i], [p₁, p₂]) for i in 1:length(d)]
-
-# B = [transpose(VV2M([b.^i for i in 0:t-1])) -α[1:t]]
-# N = nullspace(B)
-# c = round.(M2V(p2a(N)))
-
-# @var x y
-# f_approx = dot(c, [prod([x,y].^e[i]) for i in 1:length(e)])