diff --git a/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/compatibility.py b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/compatibility.py
new file mode 100644
index 0000000000000000000000000000000000000000..ee71d9efedae9cf15f36968a9e04ff90719cda48
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/compatibility.py
@@ -0,0 +1,1142 @@
+"""Compatibility interface between dense and sparse polys. """
+
+
+from sympy.polys.densearith import dup_add_term
+from sympy.polys.densearith import dmp_add_term
+from sympy.polys.densearith import dup_sub_term
+from sympy.polys.densearith import dmp_sub_term
+from sympy.polys.densearith import dup_mul_term
+from sympy.polys.densearith import dmp_mul_term
+from sympy.polys.densearith import dup_add_ground
+from sympy.polys.densearith import dmp_add_ground
+from sympy.polys.densearith import dup_sub_ground
+from sympy.polys.densearith import dmp_sub_ground
+from sympy.polys.densearith import dup_mul_ground
+from sympy.polys.densearith import dmp_mul_ground
+from sympy.polys.densearith import dup_quo_ground
+from sympy.polys.densearith import dmp_quo_ground
+from sympy.polys.densearith import dup_exquo_ground
+from sympy.polys.densearith import dmp_exquo_ground
+from sympy.polys.densearith import dup_lshift
+from sympy.polys.densearith import dup_rshift
+from sympy.polys.densearith import dup_abs
+from sympy.polys.densearith import dmp_abs
+from sympy.polys.densearith import dup_neg
+from sympy.polys.densearith import dmp_neg
+from sympy.polys.densearith import dup_add
+from sympy.polys.densearith import dmp_add
+from sympy.polys.densearith import dup_sub
+from sympy.polys.densearith import dmp_sub
+from sympy.polys.densearith import dup_add_mul
+from sympy.polys.densearith import dmp_add_mul
+from sympy.polys.densearith import dup_sub_mul
+from sympy.polys.densearith import dmp_sub_mul
+from sympy.polys.densearith import dup_mul
+from sympy.polys.densearith import dmp_mul
+from sympy.polys.densearith import dup_sqr
+from sympy.polys.densearith import dmp_sqr
+from sympy.polys.densearith import dup_pow
+from sympy.polys.densearith import dmp_pow
+from sympy.polys.densearith import dup_pdiv
+from sympy.polys.densearith import dup_prem
+from sympy.polys.densearith import dup_pquo
+from sympy.polys.densearith import dup_pexquo
+from sympy.polys.densearith import dmp_pdiv
+from sympy.polys.densearith import dmp_prem
+from sympy.polys.densearith import dmp_pquo
+from sympy.polys.densearith import dmp_pexquo
+from sympy.polys.densearith import dup_rr_div
+from sympy.polys.densearith import dmp_rr_div
+from sympy.polys.densearith import dup_ff_div
+from sympy.polys.densearith import dmp_ff_div
+from sympy.polys.densearith import dup_div
+from sympy.polys.densearith import dup_rem
+from sympy.polys.densearith import dup_quo
+from sympy.polys.densearith import dup_exquo
+from sympy.polys.densearith import dmp_div
+from sympy.polys.densearith import dmp_rem
+from sympy.polys.densearith import dmp_quo
+from sympy.polys.densearith import dmp_exquo
+from sympy.polys.densearith import dup_max_norm
+from sympy.polys.densearith import dmp_max_norm
+from sympy.polys.densearith import dup_l1_norm
+from sympy.polys.densearith import dmp_l1_norm
+from sympy.polys.densearith import dup_l2_norm_squared
+from sympy.polys.densearith import dmp_l2_norm_squared
+from sympy.polys.densearith import dup_expand
+from sympy.polys.densearith import dmp_expand
+from sympy.polys.densebasic import dup_LC
+from sympy.polys.densebasic import dmp_LC
+from sympy.polys.densebasic import dup_TC
+from sympy.polys.densebasic import dmp_TC
+from sympy.polys.densebasic import dmp_ground_LC
+from sympy.polys.densebasic import dmp_ground_TC
+from sympy.polys.densebasic import dup_degree
+from sympy.polys.densebasic import dmp_degree
+from sympy.polys.densebasic import dmp_degree_in
+from sympy.polys.densebasic import dmp_to_dict
+from sympy.polys.densetools import dup_integrate
+from sympy.polys.densetools import dmp_integrate
+from sympy.polys.densetools import dmp_integrate_in
+from sympy.polys.densetools import dup_diff
+from sympy.polys.densetools import dmp_diff
+from sympy.polys.densetools import dmp_diff_in
+from sympy.polys.densetools import dup_eval
+from sympy.polys.densetools import dmp_eval
+from sympy.polys.densetools import dmp_eval_in
+from sympy.polys.densetools import dmp_eval_tail
+from sympy.polys.densetools import dmp_diff_eval_in
+from sympy.polys.densetools import dup_trunc
+from sympy.polys.densetools import dmp_trunc
+from sympy.polys.densetools import dmp_ground_trunc
+from sympy.polys.densetools import dup_monic
+from sympy.polys.densetools import dmp_ground_monic
+from sympy.polys.densetools import dup_content
+from sympy.polys.densetools import dmp_ground_content
+from sympy.polys.densetools import dup_primitive
+from sympy.polys.densetools import dmp_ground_primitive
+from sympy.polys.densetools import dup_extract
+from sympy.polys.densetools import dmp_ground_extract
+from sympy.polys.densetools import dup_real_imag
+from sympy.polys.densetools import dup_mirror
+from sympy.polys.densetools import dup_scale
+from sympy.polys.densetools import dup_shift
+from sympy.polys.densetools import dmp_shift
+from sympy.polys.densetools import dup_transform
+from sympy.polys.densetools import dup_compose
+from sympy.polys.densetools import dmp_compose
+from sympy.polys.densetools import dup_decompose
+from sympy.polys.densetools import dmp_lift
+from sympy.polys.densetools import dup_sign_variations
+from sympy.polys.densetools import dup_clear_denoms
+from sympy.polys.densetools import dmp_clear_denoms
+from sympy.polys.densetools import dup_revert
+from sympy.polys.euclidtools import dup_half_gcdex
+from sympy.polys.euclidtools import dmp_half_gcdex
+from sympy.polys.euclidtools import dup_gcdex
+from sympy.polys.euclidtools import dmp_gcdex
+from sympy.polys.euclidtools import dup_invert
+from sympy.polys.euclidtools import dmp_invert
+from sympy.polys.euclidtools import dup_euclidean_prs
+from sympy.polys.euclidtools import dmp_euclidean_prs
+from sympy.polys.euclidtools import dup_primitive_prs
+from sympy.polys.euclidtools import dmp_primitive_prs
+from sympy.polys.euclidtools import dup_inner_subresultants
+from sympy.polys.euclidtools import dup_subresultants
+from sympy.polys.euclidtools import dup_prs_resultant
+from sympy.polys.euclidtools import dup_resultant
+from sympy.polys.euclidtools import dmp_inner_subresultants
+from sympy.polys.euclidtools import dmp_subresultants
+from sympy.polys.euclidtools import dmp_prs_resultant
+from sympy.polys.euclidtools import dmp_zz_modular_resultant
+from sympy.polys.euclidtools import dmp_zz_collins_resultant
+from sympy.polys.euclidtools import dmp_qq_collins_resultant
+from sympy.polys.euclidtools import dmp_resultant
+from sympy.polys.euclidtools import dup_discriminant
+from sympy.polys.euclidtools import dmp_discriminant
+from sympy.polys.euclidtools import dup_rr_prs_gcd
+from sympy.polys.euclidtools import dup_ff_prs_gcd
+from sympy.polys.euclidtools import dmp_rr_prs_gcd
+from sympy.polys.euclidtools import dmp_ff_prs_gcd
+from sympy.polys.euclidtools import dup_zz_heu_gcd
+from sympy.polys.euclidtools import dmp_zz_heu_gcd
+from sympy.polys.euclidtools import dup_qq_heu_gcd
+from sympy.polys.euclidtools import dmp_qq_heu_gcd
+from sympy.polys.euclidtools import dup_inner_gcd
+from sympy.polys.euclidtools import dmp_inner_gcd
+from sympy.polys.euclidtools import dup_gcd
+from sympy.polys.euclidtools import dmp_gcd
+from sympy.polys.euclidtools import dup_rr_lcm
+from sympy.polys.euclidtools import dup_ff_lcm
+from sympy.polys.euclidtools import dup_lcm
+from sympy.polys.euclidtools import dmp_rr_lcm
+from sympy.polys.euclidtools import dmp_ff_lcm
+from sympy.polys.euclidtools import dmp_lcm
+from sympy.polys.euclidtools import dmp_content
+from sympy.polys.euclidtools import dmp_primitive
+from sympy.polys.euclidtools import dup_cancel
+from sympy.polys.euclidtools import dmp_cancel
+from sympy.polys.factortools import dup_trial_division
+from sympy.polys.factortools import dmp_trial_division
+from sympy.polys.factortools import dup_zz_mignotte_bound
+from sympy.polys.factortools import dmp_zz_mignotte_bound
+from sympy.polys.factortools import dup_zz_hensel_step
+from sympy.polys.factortools import dup_zz_hensel_lift
+from sympy.polys.factortools import dup_zz_zassenhaus
+from sympy.polys.factortools import dup_zz_irreducible_p
+from sympy.polys.factortools import dup_cyclotomic_p
+from sympy.polys.factortools import dup_zz_cyclotomic_poly
+from sympy.polys.factortools import dup_zz_cyclotomic_factor
+from sympy.polys.factortools import dup_zz_factor_sqf
+from sympy.polys.factortools import dup_zz_factor
+from sympy.polys.factortools import dmp_zz_wang_non_divisors
+from sympy.polys.factortools import dmp_zz_wang_lead_coeffs
+from sympy.polys.factortools import dup_zz_diophantine
+from sympy.polys.factortools import dmp_zz_diophantine
+from sympy.polys.factortools import dmp_zz_wang_hensel_lifting
+from sympy.polys.factortools import dmp_zz_wang
+from sympy.polys.factortools import dmp_zz_factor
+from sympy.polys.factortools import dup_qq_i_factor
+from sympy.polys.factortools import dup_zz_i_factor
+from sympy.polys.factortools import dmp_qq_i_factor
+from sympy.polys.factortools import dmp_zz_i_factor
+from sympy.polys.factortools import dup_ext_factor
+from sympy.polys.factortools import dmp_ext_factor
+from sympy.polys.factortools import dup_gf_factor
+from sympy.polys.factortools import dmp_gf_factor
+from sympy.polys.factortools import dup_factor_list
+from sympy.polys.factortools import dup_factor_list_include
+from sympy.polys.factortools import dmp_factor_list
+from sympy.polys.factortools import dmp_factor_list_include
+from sympy.polys.factortools import dup_irreducible_p
+from sympy.polys.factortools import dmp_irreducible_p
+from sympy.polys.rootisolation import dup_sturm
+from sympy.polys.rootisolation import dup_root_upper_bound
+from sympy.polys.rootisolation import dup_root_lower_bound
+from sympy.polys.rootisolation import dup_step_refine_real_root
+from sympy.polys.rootisolation import dup_inner_refine_real_root
+from sympy.polys.rootisolation import dup_outer_refine_real_root
+from sympy.polys.rootisolation import dup_refine_real_root
+from sympy.polys.rootisolation import dup_inner_isolate_real_roots
+from sympy.polys.rootisolation import dup_inner_isolate_positive_roots
+from sympy.polys.rootisolation import dup_inner_isolate_negative_roots
+from sympy.polys.rootisolation import dup_isolate_real_roots_sqf
+from sympy.polys.rootisolation import dup_isolate_real_roots
+from sympy.polys.rootisolation import dup_isolate_real_roots_list
+from sympy.polys.rootisolation import dup_count_real_roots
+from sympy.polys.rootisolation import dup_count_complex_roots
+from sympy.polys.rootisolation import dup_isolate_complex_roots_sqf
+from sympy.polys.rootisolation import dup_isolate_all_roots_sqf
+from sympy.polys.rootisolation import dup_isolate_all_roots
+
+from sympy.polys.sqfreetools import (
+    dup_sqf_p, dmp_sqf_p, dmp_norm, dup_sqf_norm, dmp_sqf_norm,
+    dup_gf_sqf_part, dmp_gf_sqf_part, dup_sqf_part, dmp_sqf_part,
+    dup_gf_sqf_list, dmp_gf_sqf_list, dup_sqf_list, dup_sqf_list_include,
+    dmp_sqf_list, dmp_sqf_list_include, dup_gff_list, dmp_gff_list)
+
+from sympy.polys.galoistools import (
+    gf_degree, gf_LC, gf_TC, gf_strip, gf_from_dict,
+    gf_to_dict, gf_from_int_poly, gf_to_int_poly, gf_neg, gf_add_ground, gf_sub_ground,
+    gf_mul_ground, gf_quo_ground, gf_add, gf_sub, gf_mul, gf_sqr, gf_add_mul, gf_sub_mul,
+    gf_expand, gf_div, gf_rem, gf_quo, gf_exquo, gf_lshift, gf_rshift, gf_pow, gf_pow_mod,
+    gf_gcd, gf_lcm, gf_cofactors, gf_gcdex, gf_monic, gf_diff, gf_eval, gf_multi_eval,
+    gf_compose, gf_compose_mod, gf_trace_map, gf_random, gf_irreducible, gf_irred_p_ben_or,
+    gf_irred_p_rabin, gf_irreducible_p, gf_sqf_p, gf_sqf_part, gf_Qmatrix,
+    gf_berlekamp, gf_ddf_zassenhaus, gf_edf_zassenhaus, gf_ddf_shoup, gf_edf_shoup,
+    gf_zassenhaus, gf_shoup, gf_factor_sqf, gf_factor)
+
+from sympy.utilities import public
+
+@public
+class IPolys:
+    symbols = None
+    ngens = None
+    domain = None
+    order = None
+    gens = None
+
+    def drop(self, gen):
+        pass
+
+    def clone(self, symbols=None, domain=None, order=None):
+        pass
+
+    def to_ground(self):
+        pass
+
+    def ground_new(self, element):
+        pass
+
+    def domain_new(self, element):
+        pass
+
+    def from_dict(self, d):
+        pass
+
+    def wrap(self, element):
+        from sympy.polys.rings import PolyElement
+        if isinstance(element, PolyElement):
+            if element.ring == self:
+                return element
+            else:
+                raise NotImplementedError("domain conversions")
+        else:
+            return self.ground_new(element)
+
+    def to_dense(self, element):
+        return self.wrap(element).to_dense()
+
+    def from_dense(self, element):
+        return self.from_dict(dmp_to_dict(element, self.ngens-1, self.domain))
+
+    def dup_add_term(self, f, c, i):
+        return self.from_dense(dup_add_term(self.to_dense(f), c, i, self.domain))
+    def dmp_add_term(self, f, c, i):
+        return self.from_dense(dmp_add_term(self.to_dense(f), self.wrap(c).drop(0).to_dense(), i, self.ngens-1, self.domain))
+    def dup_sub_term(self, f, c, i):
+        return self.from_dense(dup_sub_term(self.to_dense(f), c, i, self.domain))
+    def dmp_sub_term(self, f, c, i):
+        return self.from_dense(dmp_sub_term(self.to_dense(f), self.wrap(c).drop(0).to_dense(), i, self.ngens-1, self.domain))
+    def dup_mul_term(self, f, c, i):
+        return self.from_dense(dup_mul_term(self.to_dense(f), c, i, self.domain))
+    def dmp_mul_term(self, f, c, i):
+        return self.from_dense(dmp_mul_term(self.to_dense(f), self.wrap(c).drop(0).to_dense(), i, self.ngens-1, self.domain))
+
+    def dup_add_ground(self, f, c):
+        return self.from_dense(dup_add_ground(self.to_dense(f), c, self.domain))
+    def dmp_add_ground(self, f, c):
+        return self.from_dense(dmp_add_ground(self.to_dense(f), c, self.ngens-1, self.domain))
+    def dup_sub_ground(self, f, c):
+        return self.from_dense(dup_sub_ground(self.to_dense(f), c, self.domain))
+    def dmp_sub_ground(self, f, c):
+        return self.from_dense(dmp_sub_ground(self.to_dense(f), c, self.ngens-1, self.domain))
+    def dup_mul_ground(self, f, c):
+        return self.from_dense(dup_mul_ground(self.to_dense(f), c, self.domain))
+    def dmp_mul_ground(self, f, c):
+        return self.from_dense(dmp_mul_ground(self.to_dense(f), c, self.ngens-1, self.domain))
+    def dup_quo_ground(self, f, c):
+        return self.from_dense(dup_quo_ground(self.to_dense(f), c, self.domain))
+    def dmp_quo_ground(self, f, c):
+        return self.from_dense(dmp_quo_ground(self.to_dense(f), c, self.ngens-1, self.domain))
+    def dup_exquo_ground(self, f, c):
+        return self.from_dense(dup_exquo_ground(self.to_dense(f), c, self.domain))
+    def dmp_exquo_ground(self, f, c):
+        return self.from_dense(dmp_exquo_ground(self.to_dense(f), c, self.ngens-1, self.domain))
+
+    def dup_lshift(self, f, n):
+        return self.from_dense(dup_lshift(self.to_dense(f), n, self.domain))
+    def dup_rshift(self, f, n):
+        return self.from_dense(dup_rshift(self.to_dense(f), n, self.domain))
+
+    def dup_abs(self, f):
+        return self.from_dense(dup_abs(self.to_dense(f), self.domain))
+    def dmp_abs(self, f):
+        return self.from_dense(dmp_abs(self.to_dense(f), self.ngens-1, self.domain))
+
+    def dup_neg(self, f):
+        return self.from_dense(dup_neg(self.to_dense(f), self.domain))
+    def dmp_neg(self, f):
+        return self.from_dense(dmp_neg(self.to_dense(f), self.ngens-1, self.domain))
+
+    def dup_add(self, f, g):
+        return self.from_dense(dup_add(self.to_dense(f), self.to_dense(g), self.domain))
+    def dmp_add(self, f, g):
+        return self.from_dense(dmp_add(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain))
+
+    def dup_sub(self, f, g):
+        return self.from_dense(dup_sub(self.to_dense(f), self.to_dense(g), self.domain))
+    def dmp_sub(self, f, g):
+        return self.from_dense(dmp_sub(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain))
+
+    def dup_add_mul(self, f, g, h):
+        return self.from_dense(dup_add_mul(self.to_dense(f), self.to_dense(g), self.to_dense(h), self.domain))
+    def dmp_add_mul(self, f, g, h):
+        return self.from_dense(dmp_add_mul(self.to_dense(f), self.to_dense(g), self.to_dense(h), self.ngens-1, self.domain))
+    def dup_sub_mul(self, f, g, h):
+        return self.from_dense(dup_sub_mul(self.to_dense(f), self.to_dense(g), self.to_dense(h), self.domain))
+    def dmp_sub_mul(self, f, g, h):
+        return self.from_dense(dmp_sub_mul(self.to_dense(f), self.to_dense(g), self.to_dense(h), self.ngens-1, self.domain))
+
+    def dup_mul(self, f, g):
+        return self.from_dense(dup_mul(self.to_dense(f), self.to_dense(g), self.domain))
+    def dmp_mul(self, f, g):
+        return self.from_dense(dmp_mul(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain))
+
+    def dup_sqr(self, f):
+        return self.from_dense(dup_sqr(self.to_dense(f), self.domain))
+    def dmp_sqr(self, f):
+        return self.from_dense(dmp_sqr(self.to_dense(f), self.ngens-1, self.domain))
+    def dup_pow(self, f, n):
+        return self.from_dense(dup_pow(self.to_dense(f), n, self.domain))
+    def dmp_pow(self, f, n):
+        return self.from_dense(dmp_pow(self.to_dense(f), n, self.ngens-1, self.domain))
+
+    def dup_pdiv(self, f, g):
+        q, r = dup_pdiv(self.to_dense(f), self.to_dense(g), self.domain)
+        return (self.from_dense(q), self.from_dense(r))
+    def dup_prem(self, f, g):
+        return self.from_dense(dup_prem(self.to_dense(f), self.to_dense(g), self.domain))
+    def dup_pquo(self, f, g):
+        return self.from_dense(dup_pquo(self.to_dense(f), self.to_dense(g), self.domain))
+    def dup_pexquo(self, f, g):
+        return self.from_dense(dup_pexquo(self.to_dense(f), self.to_dense(g), self.domain))
+
+    def dmp_pdiv(self, f, g):
+        q, r = dmp_pdiv(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (self.from_dense(q), self.from_dense(r))
+    def dmp_prem(self, f, g):
+        return self.from_dense(dmp_prem(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain))
+    def dmp_pquo(self, f, g):
+        return self.from_dense(dmp_pquo(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain))
+    def dmp_pexquo(self, f, g):
+        return self.from_dense(dmp_pexquo(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain))
+
+    def dup_rr_div(self, f, g):
+        q, r = dup_rr_div(self.to_dense(f), self.to_dense(g), self.domain)
+        return (self.from_dense(q), self.from_dense(r))
+    def dmp_rr_div(self, f, g):
+        q, r = dmp_rr_div(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (self.from_dense(q), self.from_dense(r))
+    def dup_ff_div(self, f, g):
+        q, r = dup_ff_div(self.to_dense(f), self.to_dense(g), self.domain)
+        return (self.from_dense(q), self.from_dense(r))
+    def dmp_ff_div(self, f, g):
+        q, r = dmp_ff_div(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (self.from_dense(q), self.from_dense(r))
+
+    def dup_div(self, f, g):
+        q, r = dup_div(self.to_dense(f), self.to_dense(g), self.domain)
+        return (self.from_dense(q), self.from_dense(r))
+    def dup_rem(self, f, g):
+        return self.from_dense(dup_rem(self.to_dense(f), self.to_dense(g), self.domain))
+    def dup_quo(self, f, g):
+        return self.from_dense(dup_quo(self.to_dense(f), self.to_dense(g), self.domain))
+    def dup_exquo(self, f, g):
+        return self.from_dense(dup_exquo(self.to_dense(f), self.to_dense(g), self.domain))
+
+    def dmp_div(self, f, g):
+        q, r = dmp_div(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (self.from_dense(q), self.from_dense(r))
+    def dmp_rem(self, f, g):
+        return self.from_dense(dmp_rem(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain))
+    def dmp_quo(self, f, g):
+        return self.from_dense(dmp_quo(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain))
+    def dmp_exquo(self, f, g):
+        return self.from_dense(dmp_exquo(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain))
+
+    def dup_max_norm(self, f):
+        return dup_max_norm(self.to_dense(f), self.domain)
+    def dmp_max_norm(self, f):
+        return dmp_max_norm(self.to_dense(f), self.ngens-1, self.domain)
+
+    def dup_l1_norm(self, f):
+        return dup_l1_norm(self.to_dense(f), self.domain)
+    def dmp_l1_norm(self, f):
+        return dmp_l1_norm(self.to_dense(f), self.ngens-1, self.domain)
+
+    def dup_l2_norm_squared(self, f):
+        return dup_l2_norm_squared(self.to_dense(f), self.domain)
+    def dmp_l2_norm_squared(self, f):
+        return dmp_l2_norm_squared(self.to_dense(f), self.ngens-1, self.domain)
+
+    def dup_expand(self, polys):
+        return self.from_dense(dup_expand(list(map(self.to_dense, polys)), self.domain))
+    def dmp_expand(self, polys):
+        return self.from_dense(dmp_expand(list(map(self.to_dense, polys)), self.ngens-1, self.domain))
+
+    def dup_LC(self, f):
+        return dup_LC(self.to_dense(f), self.domain)
+    def dmp_LC(self, f):
+        LC = dmp_LC(self.to_dense(f), self.domain)
+        if isinstance(LC, list):
+            return self[1:].from_dense(LC)
+        else:
+            return LC
+    def dup_TC(self, f):
+        return dup_TC(self.to_dense(f), self.domain)
+    def dmp_TC(self, f):
+        TC = dmp_TC(self.to_dense(f), self.domain)
+        if isinstance(TC, list):
+            return self[1:].from_dense(TC)
+        else:
+            return TC
+
+    def dmp_ground_LC(self, f):
+        return dmp_ground_LC(self.to_dense(f), self.ngens-1, self.domain)
+    def dmp_ground_TC(self, f):
+        return dmp_ground_TC(self.to_dense(f), self.ngens-1, self.domain)
+
+    def dup_degree(self, f):
+        return dup_degree(self.to_dense(f))
+    def dmp_degree(self, f):
+        return dmp_degree(self.to_dense(f), self.ngens-1)
+    def dmp_degree_in(self, f, j):
+        return dmp_degree_in(self.to_dense(f), j, self.ngens-1)
+    def dup_integrate(self, f, m):
+        return self.from_dense(dup_integrate(self.to_dense(f), m, self.domain))
+    def dmp_integrate(self, f, m):
+        return self.from_dense(dmp_integrate(self.to_dense(f), m, self.ngens-1, self.domain))
+
+    def dup_diff(self, f, m):
+        return self.from_dense(dup_diff(self.to_dense(f), m, self.domain))
+    def dmp_diff(self, f, m):
+        return self.from_dense(dmp_diff(self.to_dense(f), m, self.ngens-1, self.domain))
+
+    def dmp_diff_in(self, f, m, j):
+        return self.from_dense(dmp_diff_in(self.to_dense(f), m, j, self.ngens-1, self.domain))
+    def dmp_integrate_in(self, f, m, j):
+        return self.from_dense(dmp_integrate_in(self.to_dense(f), m, j, self.ngens-1, self.domain))
+
+    def dup_eval(self, f, a):
+        return dup_eval(self.to_dense(f), a, self.domain)
+    def dmp_eval(self, f, a):
+        result = dmp_eval(self.to_dense(f), a, self.ngens-1, self.domain)
+        return self[1:].from_dense(result)
+
+    def dmp_eval_in(self, f, a, j):
+        result = dmp_eval_in(self.to_dense(f), a, j, self.ngens-1, self.domain)
+        return self.drop(j).from_dense(result)
+    def dmp_diff_eval_in(self, f, m, a, j):
+        result = dmp_diff_eval_in(self.to_dense(f), m, a, j, self.ngens-1, self.domain)
+        return self.drop(j).from_dense(result)
+
+    def dmp_eval_tail(self, f, A):
+        result = dmp_eval_tail(self.to_dense(f), A, self.ngens-1, self.domain)
+        if isinstance(result, list):
+            return self[:-len(A)].from_dense(result)
+        else:
+            return result
+
+    def dup_trunc(self, f, p):
+        return self.from_dense(dup_trunc(self.to_dense(f), p, self.domain))
+    def dmp_trunc(self, f, g):
+        return self.from_dense(dmp_trunc(self.to_dense(f), self[1:].to_dense(g), self.ngens-1, self.domain))
+    def dmp_ground_trunc(self, f, p):
+        return self.from_dense(dmp_ground_trunc(self.to_dense(f), p, self.ngens-1, self.domain))
+
+    def dup_monic(self, f):
+        return self.from_dense(dup_monic(self.to_dense(f), self.domain))
+    def dmp_ground_monic(self, f):
+        return self.from_dense(dmp_ground_monic(self.to_dense(f), self.ngens-1, self.domain))
+
+    def dup_extract(self, f, g):
+        c, F, G = dup_extract(self.to_dense(f), self.to_dense(g), self.domain)
+        return (c, self.from_dense(F), self.from_dense(G))
+    def dmp_ground_extract(self, f, g):
+        c, F, G = dmp_ground_extract(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (c, self.from_dense(F), self.from_dense(G))
+
+    def dup_real_imag(self, f):
+        p, q = dup_real_imag(self.wrap(f).drop(1).to_dense(), self.domain)
+        return (self.from_dense(p), self.from_dense(q))
+
+    def dup_mirror(self, f):
+        return self.from_dense(dup_mirror(self.to_dense(f), self.domain))
+    def dup_scale(self, f, a):
+        return self.from_dense(dup_scale(self.to_dense(f), a, self.domain))
+    def dup_shift(self, f, a):
+        return self.from_dense(dup_shift(self.to_dense(f), a, self.domain))
+    def dmp_shift(self, f, a):
+        return self.from_dense(dmp_shift(self.to_dense(f), a, self.ngens-1, self.domain))
+    def dup_transform(self, f, p, q):
+        return self.from_dense(dup_transform(self.to_dense(f), self.to_dense(p), self.to_dense(q), self.domain))
+
+    def dup_compose(self, f, g):
+        return self.from_dense(dup_compose(self.to_dense(f), self.to_dense(g), self.domain))
+    def dmp_compose(self, f, g):
+        return self.from_dense(dmp_compose(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain))
+
+    def dup_decompose(self, f):
+        components = dup_decompose(self.to_dense(f), self.domain)
+        return list(map(self.from_dense, components))
+
+    def dmp_lift(self, f):
+        result = dmp_lift(self.to_dense(f), self.ngens-1, self.domain)
+        return self.to_ground().from_dense(result)
+
+    def dup_sign_variations(self, f):
+        return dup_sign_variations(self.to_dense(f), self.domain)
+
+    def dup_clear_denoms(self, f, convert=False):
+        c, F = dup_clear_denoms(self.to_dense(f), self.domain, convert=convert)
+        if convert:
+            ring = self.clone(domain=self.domain.get_ring())
+        else:
+            ring = self
+        return (c, ring.from_dense(F))
+    def dmp_clear_denoms(self, f, convert=False):
+        c, F = dmp_clear_denoms(self.to_dense(f), self.ngens-1, self.domain, convert=convert)
+        if convert:
+            ring = self.clone(domain=self.domain.get_ring())
+        else:
+            ring = self
+        return (c, ring.from_dense(F))
+
+    def dup_revert(self, f, n):
+        return self.from_dense(dup_revert(self.to_dense(f), n, self.domain))
+
+    def dup_half_gcdex(self, f, g):
+        s, h = dup_half_gcdex(self.to_dense(f), self.to_dense(g), self.domain)
+        return (self.from_dense(s), self.from_dense(h))
+    def dmp_half_gcdex(self, f, g):
+        s, h = dmp_half_gcdex(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (self.from_dense(s), self.from_dense(h))
+    def dup_gcdex(self, f, g):
+        s, t, h = dup_gcdex(self.to_dense(f), self.to_dense(g), self.domain)
+        return (self.from_dense(s), self.from_dense(t), self.from_dense(h))
+    def dmp_gcdex(self, f, g):
+        s, t, h = dmp_gcdex(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (self.from_dense(s), self.from_dense(t), self.from_dense(h))
+
+    def dup_invert(self, f, g):
+        return self.from_dense(dup_invert(self.to_dense(f), self.to_dense(g), self.domain))
+    def dmp_invert(self, f, g):
+        return self.from_dense(dmp_invert(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain))
+
+    def dup_euclidean_prs(self, f, g):
+        prs = dup_euclidean_prs(self.to_dense(f), self.to_dense(g), self.domain)
+        return list(map(self.from_dense, prs))
+    def dmp_euclidean_prs(self, f, g):
+        prs = dmp_euclidean_prs(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return list(map(self.from_dense, prs))
+    def dup_primitive_prs(self, f, g):
+        prs = dup_primitive_prs(self.to_dense(f), self.to_dense(g), self.domain)
+        return list(map(self.from_dense, prs))
+    def dmp_primitive_prs(self, f, g):
+        prs = dmp_primitive_prs(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return list(map(self.from_dense, prs))
+
+    def dup_inner_subresultants(self, f, g):
+        prs, sres = dup_inner_subresultants(self.to_dense(f), self.to_dense(g), self.domain)
+        return (list(map(self.from_dense, prs)), sres)
+    def dmp_inner_subresultants(self, f, g):
+        prs, sres  = dmp_inner_subresultants(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (list(map(self.from_dense, prs)), sres)
+
+    def dup_subresultants(self, f, g):
+        prs = dup_subresultants(self.to_dense(f), self.to_dense(g), self.domain)
+        return list(map(self.from_dense, prs))
+    def dmp_subresultants(self, f, g):
+        prs = dmp_subresultants(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return list(map(self.from_dense, prs))
+
+    def dup_prs_resultant(self, f, g):
+        res, prs = dup_prs_resultant(self.to_dense(f), self.to_dense(g), self.domain)
+        return (res, list(map(self.from_dense, prs)))
+    def dmp_prs_resultant(self, f, g):
+        res, prs = dmp_prs_resultant(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (self[1:].from_dense(res), list(map(self.from_dense, prs)))
+
+    def dmp_zz_modular_resultant(self, f, g, p):
+        res = dmp_zz_modular_resultant(self.to_dense(f), self.to_dense(g), self.domain_new(p), self.ngens-1, self.domain)
+        return self[1:].from_dense(res)
+    def dmp_zz_collins_resultant(self, f, g):
+        res = dmp_zz_collins_resultant(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return self[1:].from_dense(res)
+    def dmp_qq_collins_resultant(self, f, g):
+        res = dmp_qq_collins_resultant(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return self[1:].from_dense(res)
+
+    def dup_resultant(self, f, g): #, includePRS=False):
+        return dup_resultant(self.to_dense(f), self.to_dense(g), self.domain) #, includePRS=includePRS)
+    def dmp_resultant(self, f, g): #, includePRS=False):
+        res = dmp_resultant(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain) #, includePRS=includePRS)
+        if isinstance(res, list):
+            return self[1:].from_dense(res)
+        else:
+            return res
+
+    def dup_discriminant(self, f):
+        return dup_discriminant(self.to_dense(f), self.domain)
+    def dmp_discriminant(self, f):
+        disc = dmp_discriminant(self.to_dense(f), self.ngens-1, self.domain)
+        if isinstance(disc, list):
+            return self[1:].from_dense(disc)
+        else:
+            return disc
+
+    def dup_rr_prs_gcd(self, f, g):
+        H, F, G = dup_rr_prs_gcd(self.to_dense(f), self.to_dense(g), self.domain)
+        return (self.from_dense(H), self.from_dense(F), self.from_dense(G))
+    def dup_ff_prs_gcd(self, f, g):
+        H, F, G = dup_ff_prs_gcd(self.to_dense(f), self.to_dense(g), self.domain)
+        return (self.from_dense(H), self.from_dense(F), self.from_dense(G))
+    def dmp_rr_prs_gcd(self, f, g):
+        H, F, G = dmp_rr_prs_gcd(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (self.from_dense(H), self.from_dense(F), self.from_dense(G))
+    def dmp_ff_prs_gcd(self, f, g):
+        H, F, G = dmp_ff_prs_gcd(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (self.from_dense(H), self.from_dense(F), self.from_dense(G))
+    def dup_zz_heu_gcd(self, f, g):
+        H, F, G = dup_zz_heu_gcd(self.to_dense(f), self.to_dense(g), self.domain)
+        return (self.from_dense(H), self.from_dense(F), self.from_dense(G))
+    def dmp_zz_heu_gcd(self, f, g):
+        H, F, G = dmp_zz_heu_gcd(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (self.from_dense(H), self.from_dense(F), self.from_dense(G))
+    def dup_qq_heu_gcd(self, f, g):
+        H, F, G = dup_qq_heu_gcd(self.to_dense(f), self.to_dense(g), self.domain)
+        return (self.from_dense(H), self.from_dense(F), self.from_dense(G))
+    def dmp_qq_heu_gcd(self, f, g):
+        H, F, G = dmp_qq_heu_gcd(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (self.from_dense(H), self.from_dense(F), self.from_dense(G))
+    def dup_inner_gcd(self, f, g):
+        H, F, G = dup_inner_gcd(self.to_dense(f), self.to_dense(g), self.domain)
+        return (self.from_dense(H), self.from_dense(F), self.from_dense(G))
+    def dmp_inner_gcd(self, f, g):
+        H, F, G = dmp_inner_gcd(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (self.from_dense(H), self.from_dense(F), self.from_dense(G))
+    def dup_gcd(self, f, g):
+        H = dup_gcd(self.to_dense(f), self.to_dense(g), self.domain)
+        return self.from_dense(H)
+    def dmp_gcd(self, f, g):
+        H = dmp_gcd(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return self.from_dense(H)
+    def dup_rr_lcm(self, f, g):
+        H = dup_rr_lcm(self.to_dense(f), self.to_dense(g), self.domain)
+        return self.from_dense(H)
+    def dup_ff_lcm(self, f, g):
+        H = dup_ff_lcm(self.to_dense(f), self.to_dense(g), self.domain)
+        return self.from_dense(H)
+    def dup_lcm(self, f, g):
+        H = dup_lcm(self.to_dense(f), self.to_dense(g), self.domain)
+        return self.from_dense(H)
+    def dmp_rr_lcm(self, f, g):
+        H = dmp_rr_lcm(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return self.from_dense(H)
+    def dmp_ff_lcm(self, f, g):
+        H = dmp_ff_lcm(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return self.from_dense(H)
+    def dmp_lcm(self, f, g):
+        H = dmp_lcm(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return self.from_dense(H)
+
+    def dup_content(self, f):
+        cont = dup_content(self.to_dense(f), self.domain)
+        return cont
+    def dup_primitive(self, f):
+        cont, prim = dup_primitive(self.to_dense(f), self.domain)
+        return cont, self.from_dense(prim)
+
+    def dmp_content(self, f):
+        cont = dmp_content(self.to_dense(f), self.ngens-1, self.domain)
+        if isinstance(cont, list):
+            return self[1:].from_dense(cont)
+        else:
+            return cont
+    def dmp_primitive(self, f):
+        cont, prim = dmp_primitive(self.to_dense(f), self.ngens-1, self.domain)
+        if isinstance(cont, list):
+            return (self[1:].from_dense(cont), self.from_dense(prim))
+        else:
+            return (cont, self.from_dense(prim))
+
+    def dmp_ground_content(self, f):
+        cont = dmp_ground_content(self.to_dense(f), self.ngens-1, self.domain)
+        return cont
+    def dmp_ground_primitive(self, f):
+        cont, prim = dmp_ground_primitive(self.to_dense(f), self.ngens-1, self.domain)
+        return (cont, self.from_dense(prim))
+
+    def dup_cancel(self, f, g, include=True):
+        result = dup_cancel(self.to_dense(f), self.to_dense(g), self.domain, include=include)
+        if not include:
+            cf, cg, F, G = result
+            return (cf, cg, self.from_dense(F), self.from_dense(G))
+        else:
+            F, G = result
+            return (self.from_dense(F), self.from_dense(G))
+    def dmp_cancel(self, f, g, include=True):
+        result = dmp_cancel(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain, include=include)
+        if not include:
+            cf, cg, F, G = result
+            return (cf, cg, self.from_dense(F), self.from_dense(G))
+        else:
+            F, G = result
+            return (self.from_dense(F), self.from_dense(G))
+
+    def dup_trial_division(self, f, factors):
+        factors = dup_trial_division(self.to_dense(f), list(map(self.to_dense, factors)), self.domain)
+        return [ (self.from_dense(g), k) for g, k in factors ]
+    def dmp_trial_division(self, f, factors):
+        factors = dmp_trial_division(self.to_dense(f), list(map(self.to_dense, factors)), self.ngens-1, self.domain)
+        return [ (self.from_dense(g), k) for g, k in factors ]
+
+    def dup_zz_mignotte_bound(self, f):
+        return dup_zz_mignotte_bound(self.to_dense(f), self.domain)
+    def dmp_zz_mignotte_bound(self, f):
+        return dmp_zz_mignotte_bound(self.to_dense(f), self.ngens-1, self.domain)
+
+    def dup_zz_hensel_step(self, m, f, g, h, s, t):
+        D = self.to_dense
+        G, H, S, T = dup_zz_hensel_step(m, D(f), D(g), D(h), D(s), D(t), self.domain)
+        return (self.from_dense(G), self.from_dense(H), self.from_dense(S), self.from_dense(T))
+    def dup_zz_hensel_lift(self, p, f, f_list, l):
+        D = self.to_dense
+        polys = dup_zz_hensel_lift(p, D(f), list(map(D, f_list)), l, self.domain)
+        return list(map(self.from_dense, polys))
+
+    def dup_zz_zassenhaus(self, f):
+        factors = dup_zz_zassenhaus(self.to_dense(f), self.domain)
+        return [ (self.from_dense(g), k) for g, k in factors ]
+
+    def dup_zz_irreducible_p(self, f):
+        return dup_zz_irreducible_p(self.to_dense(f), self.domain)
+    def dup_cyclotomic_p(self, f, irreducible=False):
+        return dup_cyclotomic_p(self.to_dense(f), self.domain, irreducible=irreducible)
+    def dup_zz_cyclotomic_poly(self, n):
+        F = dup_zz_cyclotomic_poly(n, self.domain)
+        return self.from_dense(F)
+    def dup_zz_cyclotomic_factor(self, f):
+        result = dup_zz_cyclotomic_factor(self.to_dense(f), self.domain)
+        if result is None:
+            return result
+        else:
+            return list(map(self.from_dense, result))
+
+    # E: List[ZZ], cs: ZZ, ct: ZZ
+    def dmp_zz_wang_non_divisors(self, E, cs, ct):
+        return dmp_zz_wang_non_divisors(E, cs, ct, self.domain)
+
+    # f: Poly, T: List[(Poly, int)], ct: ZZ, A: List[ZZ]
+    #def dmp_zz_wang_test_points(f, T, ct, A):
+    #   dmp_zz_wang_test_points(self.to_dense(f), T, ct, A, self.ngens-1, self.domain)
+
+    # f: Poly, T: List[(Poly, int)], cs: ZZ, E: List[ZZ], H: List[Poly], A: List[ZZ]
+    def dmp_zz_wang_lead_coeffs(self, f, T, cs, E, H, A):
+        mv = self[1:]
+        T = [ (mv.to_dense(t), k) for t, k in T ]
+        uv = self[:1]
+        H = list(map(uv.to_dense, H))
+        f, HH, CC = dmp_zz_wang_lead_coeffs(self.to_dense(f), T, cs, E, H, A, self.ngens-1, self.domain)
+        return self.from_dense(f), list(map(uv.from_dense, HH)), list(map(mv.from_dense, CC))
+
+    # f: List[Poly], m: int, p: ZZ
+    def dup_zz_diophantine(self, F, m, p):
+        result = dup_zz_diophantine(list(map(self.to_dense, F)), m, p, self.domain)
+        return list(map(self.from_dense, result))
+
+    # f: List[Poly], c: List[Poly], A: List[ZZ], d: int, p: ZZ
+    def dmp_zz_diophantine(self, F, c, A, d, p):
+        result = dmp_zz_diophantine(list(map(self.to_dense, F)), self.to_dense(c), A, d, p, self.ngens-1, self.domain)
+        return list(map(self.from_dense, result))
+
+    # f: Poly, H: List[Poly], LC: List[Poly], A: List[ZZ], p: ZZ
+    def dmp_zz_wang_hensel_lifting(self, f, H, LC, A, p):
+        uv = self[:1]
+        mv = self[1:]
+        H = list(map(uv.to_dense, H))
+        LC = list(map(mv.to_dense, LC))
+        result = dmp_zz_wang_hensel_lifting(self.to_dense(f), H, LC, A, p, self.ngens-1, self.domain)
+        return list(map(self.from_dense, result))
+
+    def dmp_zz_wang(self, f, mod=None, seed=None):
+        factors = dmp_zz_wang(self.to_dense(f), self.ngens-1, self.domain, mod=mod, seed=seed)
+        return [ self.from_dense(g) for g in factors ]
+
+    def dup_zz_factor_sqf(self, f):
+        coeff, factors = dup_zz_factor_sqf(self.to_dense(f), self.domain)
+        return (coeff, [ self.from_dense(g) for g in factors ])
+
+    def dup_zz_factor(self, f):
+        coeff, factors = dup_zz_factor(self.to_dense(f), self.domain)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+    def dmp_zz_factor(self, f):
+        coeff, factors = dmp_zz_factor(self.to_dense(f), self.ngens-1, self.domain)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+
+    def dup_qq_i_factor(self, f):
+        coeff, factors = dup_qq_i_factor(self.to_dense(f), self.domain)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+    def dmp_qq_i_factor(self, f):
+        coeff, factors = dmp_qq_i_factor(self.to_dense(f), self.ngens-1, self.domain)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+
+    def dup_zz_i_factor(self, f):
+        coeff, factors = dup_zz_i_factor(self.to_dense(f), self.domain)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+    def dmp_zz_i_factor(self, f):
+        coeff, factors = dmp_zz_i_factor(self.to_dense(f), self.ngens-1, self.domain)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+
+    def dup_ext_factor(self, f):
+        coeff, factors = dup_ext_factor(self.to_dense(f), self.domain)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+    def dmp_ext_factor(self, f):
+        coeff, factors = dmp_ext_factor(self.to_dense(f), self.ngens-1, self.domain)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+
+    def dup_gf_factor(self, f):
+        coeff, factors = dup_gf_factor(self.to_dense(f), self.domain)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+    def dmp_gf_factor(self, f):
+        coeff, factors = dmp_gf_factor(self.to_dense(f), self.ngens-1, self.domain)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+
+    def dup_factor_list(self, f):
+        coeff, factors = dup_factor_list(self.to_dense(f), self.domain)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+    def dup_factor_list_include(self, f):
+        factors = dup_factor_list_include(self.to_dense(f), self.domain)
+        return [ (self.from_dense(g), k) for g, k in factors ]
+
+    def dmp_factor_list(self, f):
+        coeff, factors = dmp_factor_list(self.to_dense(f), self.ngens-1, self.domain)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+    def dmp_factor_list_include(self, f):
+        factors = dmp_factor_list_include(self.to_dense(f), self.ngens-1, self.domain)
+        return [ (self.from_dense(g), k) for g, k in factors ]
+
+    def dup_irreducible_p(self, f):
+        return dup_irreducible_p(self.to_dense(f), self.domain)
+    def dmp_irreducible_p(self, f):
+        return dmp_irreducible_p(self.to_dense(f), self.ngens-1, self.domain)
+
+    def dup_sturm(self, f):
+        seq = dup_sturm(self.to_dense(f), self.domain)
+        return list(map(self.from_dense, seq))
+
+    def dup_sqf_p(self, f):
+        return dup_sqf_p(self.to_dense(f), self.domain)
+    def dmp_sqf_p(self, f):
+        return dmp_sqf_p(self.to_dense(f), self.ngens-1, self.domain)
+
+    def dmp_norm(self, f):
+        n = dmp_norm(self.to_dense(f), self.ngens-1, self.domain)
+        return self.to_ground().from_dense(n)
+
+    def dup_sqf_norm(self, f):
+        s, F, R = dup_sqf_norm(self.to_dense(f), self.domain)
+        return (s, self.from_dense(F), self.to_ground().from_dense(R))
+    def dmp_sqf_norm(self, f):
+        s, F, R = dmp_sqf_norm(self.to_dense(f), self.ngens-1, self.domain)
+        return (s, self.from_dense(F), self.to_ground().from_dense(R))
+
+    def dup_gf_sqf_part(self, f):
+        return self.from_dense(dup_gf_sqf_part(self.to_dense(f), self.domain))
+    def dmp_gf_sqf_part(self, f):
+        return self.from_dense(dmp_gf_sqf_part(self.to_dense(f), self.domain))
+    def dup_sqf_part(self, f):
+        return self.from_dense(dup_sqf_part(self.to_dense(f), self.domain))
+    def dmp_sqf_part(self, f):
+        return self.from_dense(dmp_sqf_part(self.to_dense(f), self.ngens-1, self.domain))
+
+    def dup_gf_sqf_list(self, f, all=False):
+        coeff, factors = dup_gf_sqf_list(self.to_dense(f), self.domain, all=all)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+    def dmp_gf_sqf_list(self, f, all=False):
+        coeff, factors = dmp_gf_sqf_list(self.to_dense(f), self.ngens-1, self.domain, all=all)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+
+    def dup_sqf_list(self, f, all=False):
+        coeff, factors = dup_sqf_list(self.to_dense(f), self.domain, all=all)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+    def dup_sqf_list_include(self, f, all=False):
+        factors = dup_sqf_list_include(self.to_dense(f), self.domain, all=all)
+        return [ (self.from_dense(g), k) for g, k in factors ]
+    def dmp_sqf_list(self, f, all=False):
+        coeff, factors = dmp_sqf_list(self.to_dense(f), self.ngens-1, self.domain, all=all)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+    def dmp_sqf_list_include(self, f, all=False):
+        factors = dmp_sqf_list_include(self.to_dense(f), self.ngens-1, self.domain, all=all)
+        return [ (self.from_dense(g), k) for g, k in factors ]
+
+    def dup_gff_list(self, f):
+        factors = dup_gff_list(self.to_dense(f), self.domain)
+        return [ (self.from_dense(g), k) for g, k in factors ]
+    def dmp_gff_list(self, f):
+        factors = dmp_gff_list(self.to_dense(f), self.ngens-1, self.domain)
+        return [ (self.from_dense(g), k) for g, k in factors ]
+
+    def dup_root_upper_bound(self, f):
+        return dup_root_upper_bound(self.to_dense(f), self.domain)
+    def dup_root_lower_bound(self, f):
+        return dup_root_lower_bound(self.to_dense(f), self.domain)
+
+    def dup_step_refine_real_root(self, f, M, fast=False):
+        return dup_step_refine_real_root(self.to_dense(f), M, self.domain, fast=fast)
+    def dup_inner_refine_real_root(self, f, M, eps=None, steps=None, disjoint=None, fast=False, mobius=False):
+        return dup_inner_refine_real_root(self.to_dense(f), M, self.domain, eps=eps, steps=steps, disjoint=disjoint, fast=fast, mobius=mobius)
+    def dup_outer_refine_real_root(self, f, s, t, eps=None, steps=None, disjoint=None, fast=False):
+        return dup_outer_refine_real_root(self.to_dense(f), s, t, self.domain, eps=eps, steps=steps, disjoint=disjoint, fast=fast)
+    def dup_refine_real_root(self, f, s, t, eps=None, steps=None, disjoint=None, fast=False):
+        return dup_refine_real_root(self.to_dense(f), s, t, self.domain, eps=eps, steps=steps, disjoint=disjoint, fast=fast)
+    def dup_inner_isolate_real_roots(self, f, eps=None, fast=False):
+        return dup_inner_isolate_real_roots(self.to_dense(f), self.domain, eps=eps, fast=fast)
+    def dup_inner_isolate_positive_roots(self, f, eps=None, inf=None, sup=None, fast=False, mobius=False):
+        return dup_inner_isolate_positive_roots(self.to_dense(f), self.domain, eps=eps, inf=inf, sup=sup, fast=fast, mobius=mobius)
+    def dup_inner_isolate_negative_roots(self, f, inf=None, sup=None, eps=None, fast=False, mobius=False):
+        return dup_inner_isolate_negative_roots(self.to_dense(f), self.domain, inf=inf, sup=sup, eps=eps, fast=fast, mobius=mobius)
+    def dup_isolate_real_roots_sqf(self, f, eps=None, inf=None, sup=None, fast=False, blackbox=False):
+        return dup_isolate_real_roots_sqf(self.to_dense(f), self.domain, eps=eps, inf=inf, sup=sup, fast=fast, blackbox=blackbox)
+    def dup_isolate_real_roots(self, f, eps=None, inf=None, sup=None, basis=False, fast=False):
+        return dup_isolate_real_roots(self.to_dense(f), self.domain, eps=eps, inf=inf, sup=sup, basis=basis, fast=fast)
+    def dup_isolate_real_roots_list(self, polys, eps=None, inf=None, sup=None, strict=False, basis=False, fast=False):
+        return dup_isolate_real_roots_list(list(map(self.to_dense, polys)), self.domain, eps=eps, inf=inf, sup=sup, strict=strict, basis=basis, fast=fast)
+    def dup_count_real_roots(self, f, inf=None, sup=None):
+        return dup_count_real_roots(self.to_dense(f), self.domain, inf=inf, sup=sup)
+    def dup_count_complex_roots(self, f, inf=None, sup=None, exclude=None):
+        return dup_count_complex_roots(self.to_dense(f), self.domain, inf=inf, sup=sup, exclude=exclude)
+    def dup_isolate_complex_roots_sqf(self, f, eps=None, inf=None, sup=None, blackbox=False):
+        return dup_isolate_complex_roots_sqf(self.to_dense(f), self.domain, eps=eps, inf=inf, sup=sup, blackbox=blackbox)
+    def dup_isolate_all_roots_sqf(self, f, eps=None, inf=None, sup=None, fast=False, blackbox=False):
+        return dup_isolate_all_roots_sqf(self.to_dense(f), self.domain, eps=eps, inf=inf, sup=sup, fast=fast, blackbox=blackbox)
+    def dup_isolate_all_roots(self, f, eps=None, inf=None, sup=None, fast=False):
+        return dup_isolate_all_roots(self.to_dense(f), self.domain, eps=eps, inf=inf, sup=sup, fast=fast)
+
+    def fateman_poly_F_1(self):
+        from sympy.polys.specialpolys import dmp_fateman_poly_F_1
+        return tuple(map(self.from_dense, dmp_fateman_poly_F_1(self.ngens-1, self.domain)))
+    def fateman_poly_F_2(self):
+        from sympy.polys.specialpolys import dmp_fateman_poly_F_2
+        return tuple(map(self.from_dense, dmp_fateman_poly_F_2(self.ngens-1, self.domain)))
+    def fateman_poly_F_3(self):
+        from sympy.polys.specialpolys import dmp_fateman_poly_F_3
+        return tuple(map(self.from_dense, dmp_fateman_poly_F_3(self.ngens-1, self.domain)))
+
+    def to_gf_dense(self, element):
+        return gf_strip([ self.domain.dom.convert(c, self.domain) for c in self.wrap(element).to_dense() ])
+
+    def from_gf_dense(self, element):
+        return self.from_dict(dmp_to_dict(element, self.ngens-1, self.domain.dom))
+
+    def gf_degree(self, f):
+        return gf_degree(self.to_gf_dense(f))
+
+    def gf_LC(self, f):
+        return gf_LC(self.to_gf_dense(f), self.domain.dom)
+    def gf_TC(self, f):
+        return gf_TC(self.to_gf_dense(f), self.domain.dom)
+
+    def gf_strip(self, f):
+        return self.from_gf_dense(gf_strip(self.to_gf_dense(f)))
+    def gf_trunc(self, f):
+        return self.from_gf_dense(gf_strip(self.to_gf_dense(f), self.domain.mod))
+    def gf_normal(self, f):
+        return self.from_gf_dense(gf_strip(self.to_gf_dense(f), self.domain.mod, self.domain.dom))
+
+    def gf_from_dict(self, f):
+        return self.from_gf_dense(gf_from_dict(f, self.domain.mod, self.domain.dom))
+    def gf_to_dict(self, f, symmetric=True):
+        return gf_to_dict(self.to_gf_dense(f), self.domain.mod, symmetric=symmetric)
+
+    def gf_from_int_poly(self, f):
+        return self.from_gf_dense(gf_from_int_poly(f, self.domain.mod))
+    def gf_to_int_poly(self, f, symmetric=True):
+        return gf_to_int_poly(self.to_gf_dense(f), self.domain.mod, symmetric=symmetric)
+
+    def gf_neg(self, f):
+        return self.from_gf_dense(gf_neg(self.to_gf_dense(f), self.domain.mod, self.domain.dom))
+
+    def gf_add_ground(self, f, a):
+        return self.from_gf_dense(gf_add_ground(self.to_gf_dense(f), a, self.domain.mod, self.domain.dom))
+    def gf_sub_ground(self, f, a):
+        return self.from_gf_dense(gf_sub_ground(self.to_gf_dense(f), a, self.domain.mod, self.domain.dom))
+    def gf_mul_ground(self, f, a):
+        return self.from_gf_dense(gf_mul_ground(self.to_gf_dense(f), a, self.domain.mod, self.domain.dom))
+    def gf_quo_ground(self, f, a):
+        return self.from_gf_dense(gf_quo_ground(self.to_gf_dense(f), a, self.domain.mod, self.domain.dom))
+
+    def gf_add(self, f, g):
+        return self.from_gf_dense(gf_add(self.to_gf_dense(f), self.to_gf_dense(g), self.domain.mod, self.domain.dom))
+    def gf_sub(self, f, g):
+        return self.from_gf_dense(gf_sub(self.to_gf_dense(f), self.to_gf_dense(g), self.domain.mod, self.domain.dom))
+    def gf_mul(self, f, g):
+        return self.from_gf_dense(gf_mul(self.to_gf_dense(f), self.to_gf_dense(g), self.domain.mod, self.domain.dom))
+    def gf_sqr(self, f):
+        return self.from_gf_dense(gf_sqr(self.to_gf_dense(f), self.domain.mod, self.domain.dom))
+
+    def gf_add_mul(self, f, g, h):
+        return self.from_gf_dense(gf_add_mul(self.to_gf_dense(f), self.to_gf_dense(g), self.to_gf_dense(h), self.domain.mod, self.domain.dom))
+    def gf_sub_mul(self, f, g, h):
+        return self.from_gf_dense(gf_sub_mul(self.to_gf_dense(f), self.to_gf_dense(g), self.to_gf_dense(h), self.domain.mod, self.domain.dom))
+
+    def gf_expand(self, F):
+        return self.from_gf_dense(gf_expand(list(map(self.to_gf_dense, F)), self.domain.mod, self.domain.dom))
+
+    def gf_div(self, f, g):
+        q, r = gf_div(self.to_gf_dense(f), self.to_gf_dense(g), self.domain.mod, self.domain.dom)
+        return self.from_gf_dense(q), self.from_gf_dense(r)
+    def gf_rem(self, f, g):
+        return self.from_gf_dense(gf_rem(self.to_gf_dense(f), self.to_gf_dense(g), self.domain.mod, self.domain.dom))
+    def gf_quo(self, f, g):
+        return self.from_gf_dense(gf_quo(self.to_gf_dense(f), self.to_gf_dense(g), self.domain.mod, self.domain.dom))
+    def gf_exquo(self, f, g):
+        return self.from_gf_dense(gf_exquo(self.to_gf_dense(f), self.to_gf_dense(g), self.domain.mod, self.domain.dom))
+
+    def gf_lshift(self, f, n):
+        return self.from_gf_dense(gf_lshift(self.to_gf_dense(f), n, self.domain.dom))
+    def gf_rshift(self, f, n):
+        return self.from_gf_dense(gf_rshift(self.to_gf_dense(f), n, self.domain.dom))
+
+    def gf_pow(self, f, n):
+        return self.from_gf_dense(gf_pow(self.to_gf_dense(f), n, self.domain.mod, self.domain.dom))
+    def gf_pow_mod(self, f, n, g):
+        return self.from_gf_dense(gf_pow_mod(self.to_gf_dense(f), n, self.to_gf_dense(g), self.domain.mod, self.domain.dom))
+
+    def gf_cofactors(self, f, g):
+        h, cff, cfg = gf_cofactors(self.to_gf_dense(f), self.to_gf_dense(g), self.domain.mod, self.domain.dom)
+        return self.from_gf_dense(h), self.from_gf_dense(cff), self.from_gf_dense(cfg)
+    def gf_gcd(self, f, g):
+        return self.from_gf_dense(gf_gcd(self.to_gf_dense(f), self.to_gf_dense(g), self.domain.mod, self.domain.dom))
+    def gf_lcm(self, f, g):
+        return self.from_gf_dense(gf_lcm(self.to_gf_dense(f), self.to_gf_dense(g), self.domain.mod, self.domain.dom))
+    def gf_gcdex(self, f, g):
+        return self.from_gf_dense(gf_gcdex(self.to_gf_dense(f), self.to_gf_dense(g), self.domain.mod, self.domain.dom))
+
+    def gf_monic(self, f):
+        return self.from_gf_dense(gf_monic(self.to_gf_dense(f), self.domain.mod, self.domain.dom))
+    def gf_diff(self, f):
+        return self.from_gf_dense(gf_diff(self.to_gf_dense(f), self.domain.mod, self.domain.dom))
+
+    def gf_eval(self, f, a):
+        return gf_eval(self.to_gf_dense(f), a, self.domain.mod, self.domain.dom)
+    def gf_multi_eval(self, f, A):
+        return gf_multi_eval(self.to_gf_dense(f), A, self.domain.mod, self.domain.dom)
+
+    def gf_compose(self, f, g):
+        return self.from_gf_dense(gf_compose(self.to_gf_dense(f), self.to_gf_dense(g), self.domain.mod, self.domain.dom))
+    def gf_compose_mod(self, g, h, f):
+        return self.from_gf_dense(gf_compose_mod(self.to_gf_dense(g), self.to_gf_dense(h), self.to_gf_dense(f), self.domain.mod, self.domain.dom))
+
+    def gf_trace_map(self, a, b, c, n, f):
+        a = self.to_gf_dense(a)
+        b = self.to_gf_dense(b)
+        c = self.to_gf_dense(c)
+        f = self.to_gf_dense(f)
+        U, V = gf_trace_map(a, b, c, n, f, self.domain.mod, self.domain.dom)
+        return self.from_gf_dense(U), self.from_gf_dense(V)
+
+    def gf_random(self, n):
+        return self.from_gf_dense(gf_random(n, self.domain.mod, self.domain.dom))
+    def gf_irreducible(self, n):
+        return self.from_gf_dense(gf_irreducible(n, self.domain.mod, self.domain.dom))
+
+    def gf_irred_p_ben_or(self, f):
+        return gf_irred_p_ben_or(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+    def gf_irred_p_rabin(self, f):
+        return gf_irred_p_rabin(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+    def gf_irreducible_p(self, f):
+        return gf_irreducible_p(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+    def gf_sqf_p(self, f):
+        return gf_sqf_p(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+
+    def gf_sqf_part(self, f):
+        return self.from_gf_dense(gf_sqf_part(self.to_gf_dense(f), self.domain.mod, self.domain.dom))
+    def gf_sqf_list(self, f, all=False):
+        coeff, factors = gf_sqf_part(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+        return coeff, [ (self.from_gf_dense(g), k) for g, k in factors ]
+
+    def gf_Qmatrix(self, f):
+        return gf_Qmatrix(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+    def gf_berlekamp(self, f):
+        factors = gf_berlekamp(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+        return [ self.from_gf_dense(g) for g in factors ]
+
+    def gf_ddf_zassenhaus(self, f):
+        factors = gf_ddf_zassenhaus(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+        return [ (self.from_gf_dense(g), k) for g, k in factors ]
+    def gf_edf_zassenhaus(self, f, n):
+        factors = gf_edf_zassenhaus(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+        return [ self.from_gf_dense(g) for g in factors ]
+
+    def gf_ddf_shoup(self, f):
+        factors = gf_ddf_shoup(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+        return [ (self.from_gf_dense(g), k) for g, k in factors ]
+    def gf_edf_shoup(self, f, n):
+        factors = gf_edf_shoup(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+        return [ self.from_gf_dense(g) for g in factors ]
+
+    def gf_zassenhaus(self, f):
+        factors = gf_zassenhaus(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+        return [ self.from_gf_dense(g) for g in factors ]
+    def gf_shoup(self, f):
+        factors = gf_shoup(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+        return [ self.from_gf_dense(g) for g in factors ]
+
+    def gf_factor_sqf(self, f, method=None):
+        coeff, factors = gf_factor_sqf(self.to_gf_dense(f), self.domain.mod, self.domain.dom, method=method)
+        return coeff, [ self.from_gf_dense(g) for g in factors ]
+    def gf_factor(self, f):
+        coeff, factors = gf_factor(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+        return coeff, [ (self.from_gf_dense(g), k) for g, k in factors ]
diff --git a/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/constructor.py b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/constructor.py
new file mode 100644
index 0000000000000000000000000000000000000000..49ce4782b987419ee8b736974f8755301380bdda
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/constructor.py
@@ -0,0 +1,387 @@
+"""Tools for constructing domains for expressions. """
+from math import prod
+
+from sympy.core import sympify
+from sympy.core.evalf import pure_complex
+from sympy.core.sorting import ordered
+from sympy.polys.domains import ZZ, QQ, ZZ_I, QQ_I, EX
+from sympy.polys.domains.complexfield import ComplexField
+from sympy.polys.domains.realfield import RealField
+from sympy.polys.polyoptions import build_options
+from sympy.polys.polyutils import parallel_dict_from_basic
+from sympy.utilities import public
+
+
+def _construct_simple(coeffs, opt):
+    """Handle simple domains, e.g.: ZZ, QQ, RR and algebraic domains. """
+    rationals = floats = complexes = algebraics = False
+    float_numbers = []
+
+    if opt.extension is True:
+        is_algebraic = lambda coeff: coeff.is_number and coeff.is_algebraic
+    else:
+        is_algebraic = lambda coeff: False
+
+    for coeff in coeffs:
+        if coeff.is_Rational:
+            if not coeff.is_Integer:
+                rationals = True
+        elif coeff.is_Float:
+            if algebraics:
+                # there are both reals and algebraics -> EX
+                return False
+            else:
+                floats = True
+                float_numbers.append(coeff)
+        else:
+            is_complex = pure_complex(coeff)
+            if is_complex:
+                complexes = True
+                x, y = is_complex
+                if x.is_Rational and y.is_Rational:
+                    if not (x.is_Integer and y.is_Integer):
+                        rationals = True
+                    continue
+                else:
+                    floats = True
+                    if x.is_Float:
+                        float_numbers.append(x)
+                    if y.is_Float:
+                        float_numbers.append(y)
+            elif is_algebraic(coeff):
+                if floats:
+                    # there are both algebraics and reals -> EX
+                    return False
+                algebraics = True
+            else:
+                # this is a composite domain, e.g. ZZ[X], EX
+                return None
+
+    # Use the maximum precision of all coefficients for the RR or CC
+    # precision
+    max_prec = max(c._prec for c in float_numbers) if float_numbers else 53
+
+    if algebraics:
+        domain, result = _construct_algebraic(coeffs, opt)
+    else:
+        if floats and complexes:
+            domain = ComplexField(prec=max_prec)
+        elif floats:
+            domain = RealField(prec=max_prec)
+        elif rationals or opt.field:
+            domain = QQ_I if complexes else QQ
+        else:
+            domain = ZZ_I if complexes else ZZ
+
+        result = [domain.from_sympy(coeff) for coeff in coeffs]
+
+    return domain, result
+
+
+def _construct_algebraic(coeffs, opt):
+    """We know that coefficients are algebraic so construct the extension. """
+    from sympy.polys.numberfields import primitive_element
+
+    exts = set()
+
+    def build_trees(args):
+        trees = []
+        for a in args:
+            if a.is_Rational:
+                tree = ('Q', QQ.from_sympy(a))
+            elif a.is_Add:
+                tree = ('+', build_trees(a.args))
+            elif a.is_Mul:
+                tree = ('*', build_trees(a.args))
+            else:
+                tree = ('e', a)
+                exts.add(a)
+            trees.append(tree)
+        return trees
+
+    trees = build_trees(coeffs)
+    exts = list(ordered(exts))
+
+    g, span, H = primitive_element(exts, ex=True, polys=True)
+    root = sum(s*ext for s, ext in zip(span, exts))
+
+    domain, g = QQ.algebraic_field((g, root)), g.rep.to_list()
+
+    exts_dom = [domain.dtype.from_list(h, g, QQ) for h in H]
+    exts_map = dict(zip(exts, exts_dom))
+
+    def convert_tree(tree):
+        op, args = tree
+        if op == 'Q':
+            return domain.dtype.from_list([args], g, QQ)
+        elif op == '+':
+            return sum((convert_tree(a) for a in args), domain.zero)
+        elif op == '*':
+            return prod(convert_tree(a) for a in args)
+        elif op == 'e':
+            return exts_map[args]
+        else:
+            raise RuntimeError
+
+    result = [convert_tree(tree) for tree in trees]
+
+    return domain, result
+
+
+def _construct_composite(coeffs, opt):
+    """Handle composite domains, e.g.: ZZ[X], QQ[X], ZZ(X), QQ(X). """
+    numers, denoms = [], []
+
+    for coeff in coeffs:
+        numer, denom = coeff.as_numer_denom()
+
+        numers.append(numer)
+        denoms.append(denom)
+
+    polys, gens = parallel_dict_from_basic(numers + denoms)  # XXX: sorting
+    if not gens:
+        return None
+
+    if opt.composite is None:
+        if any(gen.is_number and gen.is_algebraic for gen in gens):
+            return None # generators are number-like so lets better use EX
+
+        all_symbols = set()
+
+        for gen in gens:
+            symbols = gen.free_symbols
+
+            if all_symbols & symbols:
+                return None # there could be algebraic relations between generators
+            else:
+                all_symbols |= symbols
+
+    n = len(gens)
+    k = len(polys)//2
+
+    numers = polys[:k]
+    denoms = polys[k:]
+
+    if opt.field:
+        fractions = True
+    else:
+        fractions, zeros = False, (0,)*n
+
+        for denom in denoms:
+            if len(denom) > 1 or zeros not in denom:
+                fractions = True
+                break
+
+    coeffs = set()
+
+    if not fractions:
+        for numer, denom in zip(numers, denoms):
+            denom = denom[zeros]
+
+            for monom, coeff in numer.items():
+                coeff /= denom
+                coeffs.add(coeff)
+                numer[monom] = coeff
+    else:
+        for numer, denom in zip(numers, denoms):
+            coeffs.update(list(numer.values()))
+            coeffs.update(list(denom.values()))
+
+    rationals = floats = complexes = False
+    float_numbers = []
+
+    for coeff in coeffs:
+        if coeff.is_Rational:
+            if not coeff.is_Integer:
+                rationals = True
+        elif coeff.is_Float:
+            floats = True
+            float_numbers.append(coeff)
+        else:
+            is_complex = pure_complex(coeff)
+            if is_complex is not None:
+                complexes = True
+                x, y = is_complex
+                if x.is_Rational and y.is_Rational:
+                    if not (x.is_Integer and y.is_Integer):
+                        rationals = True
+                else:
+                    floats = True
+                    if x.is_Float:
+                        float_numbers.append(x)
+                    if y.is_Float:
+                        float_numbers.append(y)
+
+    max_prec = max(c._prec for c in float_numbers) if float_numbers else 53
+
+    if floats and complexes:
+        ground = ComplexField(prec=max_prec)
+    elif floats:
+        ground = RealField(prec=max_prec)
+    elif complexes:
+        if rationals:
+            ground = QQ_I
+        else:
+            ground = ZZ_I
+    elif rationals:
+        ground = QQ
+    else:
+        ground = ZZ
+
+    result = []
+
+    if not fractions:
+        domain = ground.poly_ring(*gens)
+
+        for numer in numers:
+            for monom, coeff in numer.items():
+                numer[monom] = ground.from_sympy(coeff)
+
+            result.append(domain(numer))
+    else:
+        domain = ground.frac_field(*gens)
+
+        for numer, denom in zip(numers, denoms):
+            for monom, coeff in numer.items():
+                numer[monom] = ground.from_sympy(coeff)
+
+            for monom, coeff in denom.items():
+                denom[monom] = ground.from_sympy(coeff)
+
+            result.append(domain((numer, denom)))
+
+    return domain, result
+
+
+def _construct_expression(coeffs, opt):
+    """The last resort case, i.e. use the expression domain. """
+    domain, result = EX, []
+
+    for coeff in coeffs:
+        result.append(domain.from_sympy(coeff))
+
+    return domain, result
+
+
+@public
+def construct_domain(obj, **args):
+    """Construct a minimal domain for a list of expressions.
+
+    Explanation
+    ===========
+
+    Given a list of normal SymPy expressions (of type :py:class:`~.Expr`)
+    ``construct_domain`` will find a minimal :py:class:`~.Domain` that can
+    represent those expressions. The expressions will be converted to elements
+    of the domain and both the domain and the domain elements are returned.
+
+    Parameters
+    ==========
+
+    obj: list or dict
+        The expressions to build a domain for.
+
+    **args: keyword arguments
+        Options that affect the choice of domain.
+
+    Returns
+    =======
+
+    (K, elements): Domain and list of domain elements
+        The domain K that can represent the expressions and the list or dict
+        of domain elements representing the same expressions as elements of K.
+
+    Examples
+    ========
+
+    Given a list of :py:class:`~.Integer` ``construct_domain`` will return the
+    domain :ref:`ZZ` and a list of integers as elements of :ref:`ZZ`.
+
+    >>> from sympy import construct_domain, S
+    >>> expressions = [S(2), S(3), S(4)]
+    >>> K, elements = construct_domain(expressions)
+    >>> K
+    ZZ
+    >>> elements
+    [2, 3, 4]
+    >>> type(elements[0])  # doctest: +SKIP
+    <class 'int'>
+    >>> type(expressions[0])
+    <class 'sympy.core.numbers.Integer'>
+
+    If there are any :py:class:`~.Rational` then :ref:`QQ` is returned
+    instead.
+
+    >>> construct_domain([S(1)/2, S(3)/4])
+    (QQ, [1/2, 3/4])
+
+    If there are symbols then a polynomial ring :ref:`K[x]` is returned.
+
+    >>> from sympy import symbols
+    >>> x, y = symbols('x, y')
+    >>> construct_domain([2*x + 1, S(3)/4])
+    (QQ[x], [2*x + 1, 3/4])
+    >>> construct_domain([2*x + 1, y])
+    (ZZ[x,y], [2*x + 1, y])
+
+    If any symbols appear with negative powers then a rational function field
+    :ref:`K(x)` will be returned.
+
+    >>> construct_domain([y/x, x/(1 - y)])
+    (ZZ(x,y), [y/x, -x/(y - 1)])
+
+    Irrational algebraic numbers will result in the :ref:`EX` domain by
+    default. The keyword argument ``extension=True`` leads to the construction
+    of an algebraic number field :ref:`QQ(a)`.
+
+    >>> from sympy import sqrt
+    >>> construct_domain([sqrt(2)])
+    (EX, [EX(sqrt(2))])
+    >>> construct_domain([sqrt(2)], extension=True)  # doctest: +SKIP
+    (QQ<sqrt(2)>, [ANP([1, 0], [1, 0, -2], QQ)])
+
+    See also
+    ========
+
+    Domain
+    Expr
+    """
+    opt = build_options(args)
+
+    if hasattr(obj, '__iter__'):
+        if isinstance(obj, dict):
+            if not obj:
+                monoms, coeffs = [], []
+            else:
+                monoms, coeffs = list(zip(*list(obj.items())))
+        else:
+            coeffs = obj
+    else:
+        coeffs = [obj]
+
+    coeffs = list(map(sympify, coeffs))
+    result = _construct_simple(coeffs, opt)
+
+    if result is not None:
+        if result is not False:
+            domain, coeffs = result
+        else:
+            domain, coeffs = _construct_expression(coeffs, opt)
+    else:
+        if opt.composite is False:
+            result = None
+        else:
+            result = _construct_composite(coeffs, opt)
+
+        if result is not None:
+            domain, coeffs = result
+        else:
+            domain, coeffs = _construct_expression(coeffs, opt)
+
+    if hasattr(obj, '__iter__'):
+        if isinstance(obj, dict):
+            return domain, dict(list(zip(monoms, coeffs)))
+        else:
+            return domain, coeffs
+    else:
+        return domain, coeffs[0]
diff --git a/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/densebasic.py b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/densebasic.py
new file mode 100644
index 0000000000000000000000000000000000000000..b3a8a9497302b1af5bca20de100b7ae41e96b439
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/densebasic.py
@@ -0,0 +1,1887 @@
+"""Basic tools for dense recursive polynomials in ``K[x]`` or ``K[X]``. """
+
+
+from sympy.core import igcd
+from sympy.polys.monomials import monomial_min, monomial_div
+from sympy.polys.orderings import monomial_key
+
+import random
+
+
+ninf = float('-inf')
+
+
+def poly_LC(f, K):
+    """
+    Return leading coefficient of ``f``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import poly_LC
+
+    >>> poly_LC([], ZZ)
+    0
+    >>> poly_LC([ZZ(1), ZZ(2), ZZ(3)], ZZ)
+    1
+
+    """
+    if not f:
+        return K.zero
+    else:
+        return f[0]
+
+
+def poly_TC(f, K):
+    """
+    Return trailing coefficient of ``f``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import poly_TC
+
+    >>> poly_TC([], ZZ)
+    0
+    >>> poly_TC([ZZ(1), ZZ(2), ZZ(3)], ZZ)
+    3
+
+    """
+    if not f:
+        return K.zero
+    else:
+        return f[-1]
+
+dup_LC = dmp_LC = poly_LC
+dup_TC = dmp_TC = poly_TC
+
+
+def dmp_ground_LC(f, u, K):
+    """
+    Return the ground leading coefficient.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_ground_LC
+
+    >>> f = ZZ.map([[[1], [2, 3]]])
+
+    >>> dmp_ground_LC(f, 2, ZZ)
+    1
+
+    """
+    while u:
+        f = dmp_LC(f, K)
+        u -= 1
+
+    return dup_LC(f, K)
+
+
+def dmp_ground_TC(f, u, K):
+    """
+    Return the ground trailing coefficient.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_ground_TC
+
+    >>> f = ZZ.map([[[1], [2, 3]]])
+
+    >>> dmp_ground_TC(f, 2, ZZ)
+    3
+
+    """
+    while u:
+        f = dmp_TC(f, K)
+        u -= 1
+
+    return dup_TC(f, K)
+
+
+def dmp_true_LT(f, u, K):
+    """
+    Return the leading term ``c * x_1**n_1 ... x_k**n_k``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_true_LT
+
+    >>> f = ZZ.map([[4], [2, 0], [3, 0, 0]])
+
+    >>> dmp_true_LT(f, 1, ZZ)
+    ((2, 0), 4)
+
+    """
+    monom = []
+
+    while u:
+        monom.append(len(f) - 1)
+        f, u = f[0], u - 1
+
+    if not f:
+        monom.append(0)
+    else:
+        monom.append(len(f) - 1)
+
+    return tuple(monom), dup_LC(f, K)
+
+
+def dup_degree(f):
+    """
+    Return the leading degree of ``f`` in ``K[x]``.
+
+    Note that the degree of 0 is negative infinity (``float('-inf')``).
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_degree
+
+    >>> f = ZZ.map([1, 2, 0, 3])
+
+    >>> dup_degree(f)
+    3
+
+    """
+    if not f:
+        return ninf
+    return len(f) - 1
+
+
+def dmp_degree(f, u):
+    """
+    Return the leading degree of ``f`` in ``x_0`` in ``K[X]``.
+
+    Note that the degree of 0 is negative infinity (``float('-inf')``).
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_degree
+
+    >>> dmp_degree([[[]]], 2)
+    -inf
+
+    >>> f = ZZ.map([[2], [1, 2, 3]])
+
+    >>> dmp_degree(f, 1)
+    1
+
+    """
+    if dmp_zero_p(f, u):
+        return ninf
+    else:
+        return len(f) - 1
+
+
+def _rec_degree_in(g, v, i, j):
+    """Recursive helper function for :func:`dmp_degree_in`."""
+    if i == j:
+        return dmp_degree(g, v)
+
+    v, i = v - 1, i + 1
+
+    return max(_rec_degree_in(c, v, i, j) for c in g)
+
+
+def dmp_degree_in(f, j, u):
+    """
+    Return the leading degree of ``f`` in ``x_j`` in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_degree_in
+
+    >>> f = ZZ.map([[2], [1, 2, 3]])
+
+    >>> dmp_degree_in(f, 0, 1)
+    1
+    >>> dmp_degree_in(f, 1, 1)
+    2
+
+    """
+    if not j:
+        return dmp_degree(f, u)
+    if j < 0 or j > u:
+        raise IndexError("0 <= j <= %s expected, got %s" % (u, j))
+
+    return _rec_degree_in(f, u, 0, j)
+
+
+def _rec_degree_list(g, v, i, degs):
+    """Recursive helper for :func:`dmp_degree_list`."""
+    degs[i] = max(degs[i], dmp_degree(g, v))
+
+    if v > 0:
+        v, i = v - 1, i + 1
+
+        for c in g:
+            _rec_degree_list(c, v, i, degs)
+
+
+def dmp_degree_list(f, u):
+    """
+    Return a list of degrees of ``f`` in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_degree_list
+
+    >>> f = ZZ.map([[1], [1, 2, 3]])
+
+    >>> dmp_degree_list(f, 1)
+    (1, 2)
+
+    """
+    degs = [ninf]*(u + 1)
+    _rec_degree_list(f, u, 0, degs)
+    return tuple(degs)
+
+
+def dup_strip(f):
+    """
+    Remove leading zeros from ``f`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.densebasic import dup_strip
+
+    >>> dup_strip([0, 0, 1, 2, 3, 0])
+    [1, 2, 3, 0]
+
+    """
+    if not f or f[0]:
+        return f
+
+    i = 0
+
+    for cf in f:
+        if cf:
+            break
+        else:
+            i += 1
+
+    return f[i:]
+
+
+def dmp_strip(f, u):
+    """
+    Remove leading zeros from ``f`` in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.densebasic import dmp_strip
+
+    >>> dmp_strip([[], [0, 1, 2], [1]], 1)
+    [[0, 1, 2], [1]]
+
+    """
+    if not u:
+        return dup_strip(f)
+
+    if dmp_zero_p(f, u):
+        return f
+
+    i, v = 0, u - 1
+
+    for c in f:
+        if not dmp_zero_p(c, v):
+            break
+        else:
+            i += 1
+
+    if i == len(f):
+        return dmp_zero(u)
+    else:
+        return f[i:]
+
+
+def _rec_validate(f, g, i, K):
+    """Recursive helper for :func:`dmp_validate`."""
+    if not isinstance(g, list):
+        if K is not None and not K.of_type(g):
+            raise TypeError("%s in %s in not of type %s" % (g, f, K.dtype))
+
+        return {i - 1}
+    elif not g:
+        return {i}
+    else:
+        levels = set()
+
+        for c in g:
+            levels |= _rec_validate(f, c, i + 1, K)
+
+        return levels
+
+
+def _rec_strip(g, v):
+    """Recursive helper for :func:`_rec_strip`."""
+    if not v:
+        return dup_strip(g)
+
+    w = v - 1
+
+    return dmp_strip([ _rec_strip(c, w) for c in g ], v)
+
+
+def dmp_validate(f, K=None):
+    """
+    Return the number of levels in ``f`` and recursively strip it.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.densebasic import dmp_validate
+
+    >>> dmp_validate([[], [0, 1, 2], [1]])
+    ([[1, 2], [1]], 1)
+
+    >>> dmp_validate([[1], 1])
+    Traceback (most recent call last):
+    ...
+    ValueError: invalid data structure for a multivariate polynomial
+
+    """
+    levels = _rec_validate(f, f, 0, K)
+
+    u = levels.pop()
+
+    if not levels:
+        return _rec_strip(f, u), u
+    else:
+        raise ValueError(
+            "invalid data structure for a multivariate polynomial")
+
+
+def dup_reverse(f):
+    """
+    Compute ``x**n * f(1/x)``, i.e.: reverse ``f`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_reverse
+
+    >>> f = ZZ.map([1, 2, 3, 0])
+
+    >>> dup_reverse(f)
+    [3, 2, 1]
+
+    """
+    return dup_strip(list(reversed(f)))
+
+
+def dup_copy(f):
+    """
+    Create a new copy of a polynomial ``f`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_copy
+
+    >>> f = ZZ.map([1, 2, 3, 0])
+
+    >>> dup_copy([1, 2, 3, 0])
+    [1, 2, 3, 0]
+
+    """
+    return list(f)
+
+
+def dmp_copy(f, u):
+    """
+    Create a new copy of a polynomial ``f`` in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_copy
+
+    >>> f = ZZ.map([[1], [1, 2]])
+
+    >>> dmp_copy(f, 1)
+    [[1], [1, 2]]
+
+    """
+    if not u:
+        return list(f)
+
+    v = u - 1
+
+    return [ dmp_copy(c, v) for c in f ]
+
+
+def dup_to_tuple(f):
+    """
+    Convert `f` into a tuple.
+
+    This is needed for hashing. This is similar to dup_copy().
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_copy
+
+    >>> f = ZZ.map([1, 2, 3, 0])
+
+    >>> dup_copy([1, 2, 3, 0])
+    [1, 2, 3, 0]
+
+    """
+    return tuple(f)
+
+
+def dmp_to_tuple(f, u):
+    """
+    Convert `f` into a nested tuple of tuples.
+
+    This is needed for hashing.  This is similar to dmp_copy().
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_to_tuple
+
+    >>> f = ZZ.map([[1], [1, 2]])
+
+    >>> dmp_to_tuple(f, 1)
+    ((1,), (1, 2))
+
+    """
+    if not u:
+        return tuple(f)
+    v = u - 1
+
+    return tuple(dmp_to_tuple(c, v) for c in f)
+
+
+def dup_normal(f, K):
+    """
+    Normalize univariate polynomial in the given domain.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_normal
+
+    >>> dup_normal([0, 1, 2, 3], ZZ)
+    [1, 2, 3]
+
+    """
+    return dup_strip([ K.normal(c) for c in f ])
+
+
+def dmp_normal(f, u, K):
+    """
+    Normalize a multivariate polynomial in the given domain.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_normal
+
+    >>> dmp_normal([[], [0, 1, 2]], 1, ZZ)
+    [[1, 2]]
+
+    """
+    if not u:
+        return dup_normal(f, K)
+
+    v = u - 1
+
+    return dmp_strip([ dmp_normal(c, v, K) for c in f ], u)
+
+
+def dup_convert(f, K0, K1):
+    """
+    Convert the ground domain of ``f`` from ``K0`` to ``K1``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.rings import ring
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_convert
+
+    >>> R, x = ring("x", ZZ)
+
+    >>> dup_convert([R(1), R(2)], R.to_domain(), ZZ)
+    [1, 2]
+    >>> dup_convert([ZZ(1), ZZ(2)], ZZ, R.to_domain())
+    [1, 2]
+
+    """
+    if K0 is not None and K0 == K1:
+        return f
+    else:
+        return dup_strip([ K1.convert(c, K0) for c in f ])
+
+
+def dmp_convert(f, u, K0, K1):
+    """
+    Convert the ground domain of ``f`` from ``K0`` to ``K1``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.rings import ring
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_convert
+
+    >>> R, x = ring("x", ZZ)
+
+    >>> dmp_convert([[R(1)], [R(2)]], 1, R.to_domain(), ZZ)
+    [[1], [2]]
+    >>> dmp_convert([[ZZ(1)], [ZZ(2)]], 1, ZZ, R.to_domain())
+    [[1], [2]]
+
+    """
+    if not u:
+        return dup_convert(f, K0, K1)
+    if K0 is not None and K0 == K1:
+        return f
+
+    v = u - 1
+
+    return dmp_strip([ dmp_convert(c, v, K0, K1) for c in f ], u)
+
+
+def dup_from_sympy(f, K):
+    """
+    Convert the ground domain of ``f`` from SymPy to ``K``.
+
+    Examples
+    ========
+
+    >>> from sympy import S
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_from_sympy
+
+    >>> dup_from_sympy([S(1), S(2)], ZZ) == [ZZ(1), ZZ(2)]
+    True
+
+    """
+    return dup_strip([ K.from_sympy(c) for c in f ])
+
+
+def dmp_from_sympy(f, u, K):
+    """
+    Convert the ground domain of ``f`` from SymPy to ``K``.
+
+    Examples
+    ========
+
+    >>> from sympy import S
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_from_sympy
+
+    >>> dmp_from_sympy([[S(1)], [S(2)]], 1, ZZ) == [[ZZ(1)], [ZZ(2)]]
+    True
+
+    """
+    if not u:
+        return dup_from_sympy(f, K)
+
+    v = u - 1
+
+    return dmp_strip([ dmp_from_sympy(c, v, K) for c in f ], u)
+
+
+def dup_nth(f, n, K):
+    """
+    Return the ``n``-th coefficient of ``f`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_nth
+
+    >>> f = ZZ.map([1, 2, 3])
+
+    >>> dup_nth(f, 0, ZZ)
+    3
+    >>> dup_nth(f, 4, ZZ)
+    0
+
+    """
+    if n < 0:
+        raise IndexError("'n' must be non-negative, got %i" % n)
+    elif n >= len(f):
+        return K.zero
+    else:
+        return f[dup_degree(f) - n]
+
+
+def dmp_nth(f, n, u, K):
+    """
+    Return the ``n``-th coefficient of ``f`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_nth
+
+    >>> f = ZZ.map([[1], [2], [3]])
+
+    >>> dmp_nth(f, 0, 1, ZZ)
+    [3]
+    >>> dmp_nth(f, 4, 1, ZZ)
+    []
+
+    """
+    if n < 0:
+        raise IndexError("'n' must be non-negative, got %i" % n)
+    elif n >= len(f):
+        return dmp_zero(u - 1)
+    else:
+        return f[dmp_degree(f, u) - n]
+
+
+def dmp_ground_nth(f, N, u, K):
+    """
+    Return the ground ``n``-th coefficient of ``f`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_ground_nth
+
+    >>> f = ZZ.map([[1], [2, 3]])
+
+    >>> dmp_ground_nth(f, (0, 1), 1, ZZ)
+    2
+
+    """
+    v = u
+
+    for n in N:
+        if n < 0:
+            raise IndexError("`n` must be non-negative, got %i" % n)
+        elif n >= len(f):
+            return K.zero
+        else:
+            d = dmp_degree(f, v)
+            if d == ninf:
+                d = -1
+            f, v = f[d - n], v - 1
+
+    return f
+
+
+def dmp_zero_p(f, u):
+    """
+    Return ``True`` if ``f`` is zero in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.densebasic import dmp_zero_p
+
+    >>> dmp_zero_p([[[[[]]]]], 4)
+    True
+    >>> dmp_zero_p([[[[[1]]]]], 4)
+    False
+
+    """
+    while u:
+        if len(f) != 1:
+            return False
+
+        f = f[0]
+        u -= 1
+
+    return not f
+
+
+def dmp_zero(u):
+    """
+    Return a multivariate zero.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.densebasic import dmp_zero
+
+    >>> dmp_zero(4)
+    [[[[[]]]]]
+
+    """
+    r = []
+
+    for i in range(u):
+        r = [r]
+
+    return r
+
+
+def dmp_one_p(f, u, K):
+    """
+    Return ``True`` if ``f`` is one in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_one_p
+
+    >>> dmp_one_p([[[ZZ(1)]]], 2, ZZ)
+    True
+
+    """
+    return dmp_ground_p(f, K.one, u)
+
+
+def dmp_one(u, K):
+    """
+    Return a multivariate one over ``K``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_one
+
+    >>> dmp_one(2, ZZ)
+    [[[1]]]
+
+    """
+    return dmp_ground(K.one, u)
+
+
+def dmp_ground_p(f, c, u):
+    """
+    Return True if ``f`` is constant in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.densebasic import dmp_ground_p
+
+    >>> dmp_ground_p([[[3]]], 3, 2)
+    True
+    >>> dmp_ground_p([[[4]]], None, 2)
+    True
+
+    """
+    if c is not None and not c:
+        return dmp_zero_p(f, u)
+
+    while u:
+        if len(f) != 1:
+            return False
+        f = f[0]
+        u -= 1
+
+    if c is None:
+        return len(f) <= 1
+    else:
+        return f == [c]
+
+
+def dmp_ground(c, u):
+    """
+    Return a multivariate constant.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.densebasic import dmp_ground
+
+    >>> dmp_ground(3, 5)
+    [[[[[[3]]]]]]
+    >>> dmp_ground(1, -1)
+    1
+
+    """
+    if not c:
+        return dmp_zero(u)
+
+    for i in range(u + 1):
+        c = [c]
+
+    return c
+
+
+def dmp_zeros(n, u, K):
+    """
+    Return a list of multivariate zeros.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_zeros
+
+    >>> dmp_zeros(3, 2, ZZ)
+    [[[[]]], [[[]]], [[[]]]]
+    >>> dmp_zeros(3, -1, ZZ)
+    [0, 0, 0]
+
+    """
+    if not n:
+        return []
+
+    if u < 0:
+        return [K.zero]*n
+    else:
+        return [ dmp_zero(u) for i in range(n) ]
+
+
+def dmp_grounds(c, n, u):
+    """
+    Return a list of multivariate constants.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_grounds
+
+    >>> dmp_grounds(ZZ(4), 3, 2)
+    [[[[4]]], [[[4]]], [[[4]]]]
+    >>> dmp_grounds(ZZ(4), 3, -1)
+    [4, 4, 4]
+
+    """
+    if not n:
+        return []
+
+    if u < 0:
+        return [c]*n
+    else:
+        return [ dmp_ground(c, u) for i in range(n) ]
+
+
+def dmp_negative_p(f, u, K):
+    """
+    Return ``True`` if ``LC(f)`` is negative.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_negative_p
+
+    >>> dmp_negative_p([[ZZ(1)], [-ZZ(1)]], 1, ZZ)
+    False
+    >>> dmp_negative_p([[-ZZ(1)], [ZZ(1)]], 1, ZZ)
+    True
+
+    """
+    return K.is_negative(dmp_ground_LC(f, u, K))
+
+
+def dmp_positive_p(f, u, K):
+    """
+    Return ``True`` if ``LC(f)`` is positive.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_positive_p
+
+    >>> dmp_positive_p([[ZZ(1)], [-ZZ(1)]], 1, ZZ)
+    True
+    >>> dmp_positive_p([[-ZZ(1)], [ZZ(1)]], 1, ZZ)
+    False
+
+    """
+    return K.is_positive(dmp_ground_LC(f, u, K))
+
+
+def dup_from_dict(f, K):
+    """
+    Create a ``K[x]`` polynomial from a ``dict``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_from_dict
+
+    >>> dup_from_dict({(0,): ZZ(7), (2,): ZZ(5), (4,): ZZ(1)}, ZZ)
+    [1, 0, 5, 0, 7]
+    >>> dup_from_dict({}, ZZ)
+    []
+
+    """
+    if not f:
+        return []
+
+    n, h = max(f.keys()), []
+
+    if isinstance(n, int):
+        for k in range(n, -1, -1):
+            h.append(f.get(k, K.zero))
+    else:
+        (n,) = n
+
+        for k in range(n, -1, -1):
+            h.append(f.get((k,), K.zero))
+
+    return dup_strip(h)
+
+
+def dup_from_raw_dict(f, K):
+    """
+    Create a ``K[x]`` polynomial from a raw ``dict``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_from_raw_dict
+
+    >>> dup_from_raw_dict({0: ZZ(7), 2: ZZ(5), 4: ZZ(1)}, ZZ)
+    [1, 0, 5, 0, 7]
+
+    """
+    if not f:
+        return []
+
+    n, h = max(f.keys()), []
+
+    for k in range(n, -1, -1):
+        h.append(f.get(k, K.zero))
+
+    return dup_strip(h)
+
+
+def dmp_from_dict(f, u, K):
+    """
+    Create a ``K[X]`` polynomial from a ``dict``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_from_dict
+
+    >>> dmp_from_dict({(0, 0): ZZ(3), (0, 1): ZZ(2), (2, 1): ZZ(1)}, 1, ZZ)
+    [[1, 0], [], [2, 3]]
+    >>> dmp_from_dict({}, 0, ZZ)
+    []
+
+    """
+    if not u:
+        return dup_from_dict(f, K)
+    if not f:
+        return dmp_zero(u)
+
+    coeffs = {}
+
+    for monom, coeff in f.items():
+        head, tail = monom[0], monom[1:]
+
+        if head in coeffs:
+            coeffs[head][tail] = coeff
+        else:
+            coeffs[head] = { tail: coeff }
+
+    n, v, h = max(coeffs.keys()), u - 1, []
+
+    for k in range(n, -1, -1):
+        coeff = coeffs.get(k)
+
+        if coeff is not None:
+            h.append(dmp_from_dict(coeff, v, K))
+        else:
+            h.append(dmp_zero(v))
+
+    return dmp_strip(h, u)
+
+
+def dup_to_dict(f, K=None, zero=False):
+    """
+    Convert ``K[x]`` polynomial to a ``dict``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.densebasic import dup_to_dict
+
+    >>> dup_to_dict([1, 0, 5, 0, 7])
+    {(0,): 7, (2,): 5, (4,): 1}
+    >>> dup_to_dict([])
+    {}
+
+    """
+    if not f and zero:
+        return {(0,): K.zero}
+
+    n, result = len(f) - 1, {}
+
+    for k in range(0, n + 1):
+        if f[n - k]:
+            result[(k,)] = f[n - k]
+
+    return result
+
+
+def dup_to_raw_dict(f, K=None, zero=False):
+    """
+    Convert a ``K[x]`` polynomial to a raw ``dict``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.densebasic import dup_to_raw_dict
+
+    >>> dup_to_raw_dict([1, 0, 5, 0, 7])
+    {0: 7, 2: 5, 4: 1}
+
+    """
+    if not f and zero:
+        return {0: K.zero}
+
+    n, result = len(f) - 1, {}
+
+    for k in range(0, n + 1):
+        if f[n - k]:
+            result[k] = f[n - k]
+
+    return result
+
+
+def dmp_to_dict(f, u, K=None, zero=False):
+    """
+    Convert a ``K[X]`` polynomial to a ``dict````.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.densebasic import dmp_to_dict
+
+    >>> dmp_to_dict([[1, 0], [], [2, 3]], 1)
+    {(0, 0): 3, (0, 1): 2, (2, 1): 1}
+    >>> dmp_to_dict([], 0)
+    {}
+
+    """
+    if not u:
+        return dup_to_dict(f, K, zero=zero)
+
+    if dmp_zero_p(f, u) and zero:
+        return {(0,)*(u + 1): K.zero}
+
+    n, v, result = dmp_degree(f, u), u - 1, {}
+
+    if n == ninf:
+        n = -1
+
+    for k in range(0, n + 1):
+        h = dmp_to_dict(f[n - k], v)
+
+        for exp, coeff in h.items():
+            result[(k,) + exp] = coeff
+
+    return result
+
+
+def dmp_swap(f, i, j, u, K):
+    """
+    Transform ``K[..x_i..x_j..]`` to ``K[..x_j..x_i..]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_swap
+
+    >>> f = ZZ.map([[[2], [1, 0]], []])
+
+    >>> dmp_swap(f, 0, 1, 2, ZZ)
+    [[[2], []], [[1, 0], []]]
+    >>> dmp_swap(f, 1, 2, 2, ZZ)
+    [[[1], [2, 0]], [[]]]
+    >>> dmp_swap(f, 0, 2, 2, ZZ)
+    [[[1, 0]], [[2, 0], []]]
+
+    """
+    if i < 0 or j < 0 or i > u or j > u:
+        raise IndexError("0 <= i < j <= %s expected" % u)
+    elif i == j:
+        return f
+
+    F, H = dmp_to_dict(f, u), {}
+
+    for exp, coeff in F.items():
+        H[exp[:i] + (exp[j],) +
+          exp[i + 1:j] +
+          (exp[i],) + exp[j + 1:]] = coeff
+
+    return dmp_from_dict(H, u, K)
+
+
+def dmp_permute(f, P, u, K):
+    """
+    Return a polynomial in ``K[x_{P(1)},..,x_{P(n)}]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_permute
+
+    >>> f = ZZ.map([[[2], [1, 0]], []])
+
+    >>> dmp_permute(f, [1, 0, 2], 2, ZZ)
+    [[[2], []], [[1, 0], []]]
+    >>> dmp_permute(f, [1, 2, 0], 2, ZZ)
+    [[[1], []], [[2, 0], []]]
+
+    """
+    F, H = dmp_to_dict(f, u), {}
+
+    for exp, coeff in F.items():
+        new_exp = [0]*len(exp)
+
+        for e, p in zip(exp, P):
+            new_exp[p] = e
+
+        H[tuple(new_exp)] = coeff
+
+    return dmp_from_dict(H, u, K)
+
+
+def dmp_nest(f, l, K):
+    """
+    Return a multivariate value nested ``l``-levels.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_nest
+
+    >>> dmp_nest([[ZZ(1)]], 2, ZZ)
+    [[[[1]]]]
+
+    """
+    if not isinstance(f, list):
+        return dmp_ground(f, l)
+
+    for i in range(l):
+        f = [f]
+
+    return f
+
+
+def dmp_raise(f, l, u, K):
+    """
+    Return a multivariate polynomial raised ``l``-levels.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_raise
+
+    >>> f = ZZ.map([[], [1, 2]])
+
+    >>> dmp_raise(f, 2, 1, ZZ)
+    [[[[]]], [[[1]], [[2]]]]
+
+    """
+    if not l:
+        return f
+
+    if not u:
+        if not f:
+            return dmp_zero(l)
+
+        k = l - 1
+
+        return [ dmp_ground(c, k) for c in f ]
+
+    v = u - 1
+
+    return [ dmp_raise(c, l, v, K) for c in f ]
+
+
+def dup_deflate(f, K):
+    """
+    Map ``x**m`` to ``y`` in a polynomial in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_deflate
+
+    >>> f = ZZ.map([1, 0, 0, 1, 0, 0, 1])
+
+    >>> dup_deflate(f, ZZ)
+    (3, [1, 1, 1])
+
+    """
+    if dup_degree(f) <= 0:
+        return 1, f
+
+    g = 0
+
+    for i in range(len(f)):
+        if not f[-i - 1]:
+            continue
+
+        g = igcd(g, i)
+
+        if g == 1:
+            return 1, f
+
+    return g, f[::g]
+
+
+def dmp_deflate(f, u, K):
+    """
+    Map ``x_i**m_i`` to ``y_i`` in a polynomial in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_deflate
+
+    >>> f = ZZ.map([[1, 0, 0, 2], [], [3, 0, 0, 4]])
+
+    >>> dmp_deflate(f, 1, ZZ)
+    ((2, 3), [[1, 2], [3, 4]])
+
+    """
+    if dmp_zero_p(f, u):
+        return (1,)*(u + 1), f
+
+    F = dmp_to_dict(f, u)
+    B = [0]*(u + 1)
+
+    for M in F.keys():
+        for i, m in enumerate(M):
+            B[i] = igcd(B[i], m)
+
+    for i, b in enumerate(B):
+        if not b:
+            B[i] = 1
+
+    B = tuple(B)
+
+    if all(b == 1 for b in B):
+        return B, f
+
+    H = {}
+
+    for A, coeff in F.items():
+        N = [ a // b for a, b in zip(A, B) ]
+        H[tuple(N)] = coeff
+
+    return B, dmp_from_dict(H, u, K)
+
+
+def dup_multi_deflate(polys, K):
+    """
+    Map ``x**m`` to ``y`` in a set of polynomials in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_multi_deflate
+
+    >>> f = ZZ.map([1, 0, 2, 0, 3])
+    >>> g = ZZ.map([4, 0, 0])
+
+    >>> dup_multi_deflate((f, g), ZZ)
+    (2, ([1, 2, 3], [4, 0]))
+
+    """
+    G = 0
+
+    for p in polys:
+        if dup_degree(p) <= 0:
+            return 1, polys
+
+        g = 0
+
+        for i in range(len(p)):
+            if not p[-i - 1]:
+                continue
+
+            g = igcd(g, i)
+
+            if g == 1:
+                return 1, polys
+
+        G = igcd(G, g)
+
+    return G, tuple([ p[::G] for p in polys ])
+
+
+def dmp_multi_deflate(polys, u, K):
+    """
+    Map ``x_i**m_i`` to ``y_i`` in a set of polynomials in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_multi_deflate
+
+    >>> f = ZZ.map([[1, 0, 0, 2], [], [3, 0, 0, 4]])
+    >>> g = ZZ.map([[1, 0, 2], [], [3, 0, 4]])
+
+    >>> dmp_multi_deflate((f, g), 1, ZZ)
+    ((2, 1), ([[1, 0, 0, 2], [3, 0, 0, 4]], [[1, 0, 2], [3, 0, 4]]))
+
+    """
+    if not u:
+        M, H = dup_multi_deflate(polys, K)
+        return (M,), H
+
+    F, B = [], [0]*(u + 1)
+
+    for p in polys:
+        f = dmp_to_dict(p, u)
+
+        if not dmp_zero_p(p, u):
+            for M in f.keys():
+                for i, m in enumerate(M):
+                    B[i] = igcd(B[i], m)
+
+        F.append(f)
+
+    for i, b in enumerate(B):
+        if not b:
+            B[i] = 1
+
+    B = tuple(B)
+
+    if all(b == 1 for b in B):
+        return B, polys
+
+    H = []
+
+    for f in F:
+        h = {}
+
+        for A, coeff in f.items():
+            N = [ a // b for a, b in zip(A, B) ]
+            h[tuple(N)] = coeff
+
+        H.append(dmp_from_dict(h, u, K))
+
+    return B, tuple(H)
+
+
+def dup_inflate(f, m, K):
+    """
+    Map ``y`` to ``x**m`` in a polynomial in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_inflate
+
+    >>> f = ZZ.map([1, 1, 1])
+
+    >>> dup_inflate(f, 3, ZZ)
+    [1, 0, 0, 1, 0, 0, 1]
+
+    """
+    if m <= 0:
+        raise IndexError("'m' must be positive, got %s" % m)
+    if m == 1 or not f:
+        return f
+
+    result = [f[0]]
+
+    for coeff in f[1:]:
+        result.extend([K.zero]*(m - 1))
+        result.append(coeff)
+
+    return result
+
+
+def _rec_inflate(g, M, v, i, K):
+    """Recursive helper for :func:`dmp_inflate`."""
+    if not v:
+        return dup_inflate(g, M[i], K)
+    if M[i] <= 0:
+        raise IndexError("all M[i] must be positive, got %s" % M[i])
+
+    w, j = v - 1, i + 1
+
+    g = [ _rec_inflate(c, M, w, j, K) for c in g ]
+
+    result = [g[0]]
+
+    for coeff in g[1:]:
+        for _ in range(1, M[i]):
+            result.append(dmp_zero(w))
+
+        result.append(coeff)
+
+    return result
+
+
+def dmp_inflate(f, M, u, K):
+    """
+    Map ``y_i`` to ``x_i**k_i`` in a polynomial in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_inflate
+
+    >>> f = ZZ.map([[1, 2], [3, 4]])
+
+    >>> dmp_inflate(f, (2, 3), 1, ZZ)
+    [[1, 0, 0, 2], [], [3, 0, 0, 4]]
+
+    """
+    if not u:
+        return dup_inflate(f, M[0], K)
+
+    if all(m == 1 for m in M):
+        return f
+    else:
+        return _rec_inflate(f, M, u, 0, K)
+
+
+def dmp_exclude(f, u, K):
+    """
+    Exclude useless levels from ``f``.
+
+    Return the levels excluded, the new excluded ``f``, and the new ``u``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_exclude
+
+    >>> f = ZZ.map([[[1]], [[1], [2]]])
+
+    >>> dmp_exclude(f, 2, ZZ)
+    ([2], [[1], [1, 2]], 1)
+
+    """
+    if not u or dmp_ground_p(f, None, u):
+        return [], f, u
+
+    J, F = [], dmp_to_dict(f, u)
+
+    for j in range(0, u + 1):
+        for monom in F.keys():
+            if monom[j]:
+                break
+        else:
+            J.append(j)
+
+    if not J:
+        return [], f, u
+
+    f = {}
+
+    for monom, coeff in F.items():
+        monom = list(monom)
+
+        for j in reversed(J):
+            del monom[j]
+
+        f[tuple(monom)] = coeff
+
+    u -= len(J)
+
+    return J, dmp_from_dict(f, u, K), u
+
+
+def dmp_include(f, J, u, K):
+    """
+    Include useless levels in ``f``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_include
+
+    >>> f = ZZ.map([[1], [1, 2]])
+
+    >>> dmp_include(f, [2], 1, ZZ)
+    [[[1]], [[1], [2]]]
+
+    """
+    if not J:
+        return f
+
+    F, f = dmp_to_dict(f, u), {}
+
+    for monom, coeff in F.items():
+        monom = list(monom)
+
+        for j in J:
+            monom.insert(j, 0)
+
+        f[tuple(monom)] = coeff
+
+    u += len(J)
+
+    return dmp_from_dict(f, u, K)
+
+
+def dmp_inject(f, u, K, front=False):
+    """
+    Convert ``f`` from ``K[X][Y]`` to ``K[X,Y]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.rings import ring
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_inject
+
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> dmp_inject([R(1), x + 2], 0, R.to_domain())
+    ([[[1]], [[1], [2]]], 2)
+    >>> dmp_inject([R(1), x + 2], 0, R.to_domain(), front=True)
+    ([[[1]], [[1, 2]]], 2)
+
+    """
+    f, h = dmp_to_dict(f, u), {}
+
+    v = K.ngens - 1
+
+    for f_monom, g in f.items():
+        g = g.to_dict()
+
+        for g_monom, c in g.items():
+            if front:
+                h[g_monom + f_monom] = c
+            else:
+                h[f_monom + g_monom] = c
+
+    w = u + v + 1
+
+    return dmp_from_dict(h, w, K.dom), w
+
+
+def dmp_eject(f, u, K, front=False):
+    """
+    Convert ``f`` from ``K[X,Y]`` to ``K[X][Y]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_eject
+
+    >>> dmp_eject([[[1]], [[1], [2]]], 2, ZZ['x', 'y'])
+    [1, x + 2]
+
+    """
+    f, h = dmp_to_dict(f, u), {}
+
+    n = K.ngens
+    v = u - K.ngens + 1
+
+    for monom, c in f.items():
+        if front:
+            g_monom, f_monom = monom[:n], monom[n:]
+        else:
+            g_monom, f_monom = monom[-n:], monom[:-n]
+
+        if f_monom in h:
+            h[f_monom][g_monom] = c
+        else:
+            h[f_monom] = {g_monom: c}
+
+    for monom, c in h.items():
+        h[monom] = K(c)
+
+    return dmp_from_dict(h, v - 1, K)
+
+
+def dup_terms_gcd(f, K):
+    """
+    Remove GCD of terms from ``f`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_terms_gcd
+
+    >>> f = ZZ.map([1, 0, 1, 0, 0])
+
+    >>> dup_terms_gcd(f, ZZ)
+    (2, [1, 0, 1])
+
+    """
+    if dup_TC(f, K) or not f:
+        return 0, f
+
+    i = 0
+
+    for c in reversed(f):
+        if not c:
+            i += 1
+        else:
+            break
+
+    return i, f[:-i]
+
+
+def dmp_terms_gcd(f, u, K):
+    """
+    Remove GCD of terms from ``f`` in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_terms_gcd
+
+    >>> f = ZZ.map([[1, 0], [1, 0, 0], [], []])
+
+    >>> dmp_terms_gcd(f, 1, ZZ)
+    ((2, 1), [[1], [1, 0]])
+
+    """
+    if dmp_ground_TC(f, u, K) or dmp_zero_p(f, u):
+        return (0,)*(u + 1), f
+
+    F = dmp_to_dict(f, u)
+    G = monomial_min(*list(F.keys()))
+
+    if all(g == 0 for g in G):
+        return G, f
+
+    f = {}
+
+    for monom, coeff in F.items():
+        f[monomial_div(monom, G)] = coeff
+
+    return G, dmp_from_dict(f, u, K)
+
+
+def _rec_list_terms(g, v, monom):
+    """Recursive helper for :func:`dmp_list_terms`."""
+    d, terms = dmp_degree(g, v), []
+
+    if not v:
+        for i, c in enumerate(g):
+            if not c:
+                continue
+
+            terms.append((monom + (d - i,), c))
+    else:
+        w = v - 1
+
+        for i, c in enumerate(g):
+            terms.extend(_rec_list_terms(c, w, monom + (d - i,)))
+
+    return terms
+
+
+def dmp_list_terms(f, u, K, order=None):
+    """
+    List all non-zero terms from ``f`` in the given order ``order``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_list_terms
+
+    >>> f = ZZ.map([[1, 1], [2, 3]])
+
+    >>> dmp_list_terms(f, 1, ZZ)
+    [((1, 1), 1), ((1, 0), 1), ((0, 1), 2), ((0, 0), 3)]
+    >>> dmp_list_terms(f, 1, ZZ, order='grevlex')
+    [((1, 1), 1), ((1, 0), 1), ((0, 1), 2), ((0, 0), 3)]
+
+    """
+    def sort(terms, O):
+        return sorted(terms, key=lambda term: O(term[0]), reverse=True)
+
+    terms = _rec_list_terms(f, u, ())
+
+    if not terms:
+        return [((0,)*(u + 1), K.zero)]
+
+    if order is None:
+        return terms
+    else:
+        return sort(terms, monomial_key(order))
+
+
+def dup_apply_pairs(f, g, h, args, K):
+    """
+    Apply ``h`` to pairs of coefficients of ``f`` and ``g``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_apply_pairs
+
+    >>> h = lambda x, y, z: 2*x + y - z
+
+    >>> dup_apply_pairs([1, 2, 3], [3, 2, 1], h, (1,), ZZ)
+    [4, 5, 6]
+
+    """
+    n, m = len(f), len(g)
+
+    if n != m:
+        if n > m:
+            g = [K.zero]*(n - m) + g
+        else:
+            f = [K.zero]*(m - n) + f
+
+    result = []
+
+    for a, b in zip(f, g):
+        result.append(h(a, b, *args))
+
+    return dup_strip(result)
+
+
+def dmp_apply_pairs(f, g, h, args, u, K):
+    """
+    Apply ``h`` to pairs of coefficients of ``f`` and ``g``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_apply_pairs
+
+    >>> h = lambda x, y, z: 2*x + y - z
+
+    >>> dmp_apply_pairs([[1], [2, 3]], [[3], [2, 1]], h, (1,), 1, ZZ)
+    [[4], [5, 6]]
+
+    """
+    if not u:
+        return dup_apply_pairs(f, g, h, args, K)
+
+    n, m, v = len(f), len(g), u - 1
+
+    if n != m:
+        if n > m:
+            g = dmp_zeros(n - m, v, K) + g
+        else:
+            f = dmp_zeros(m - n, v, K) + f
+
+    result = []
+
+    for a, b in zip(f, g):
+        result.append(dmp_apply_pairs(a, b, h, args, v, K))
+
+    return dmp_strip(result, u)
+
+
+def dup_slice(f, m, n, K):
+    """Take a continuous subsequence of terms of ``f`` in ``K[x]``. """
+    k = len(f)
+
+    if k >= m:
+        M = k - m
+    else:
+        M = 0
+    if k >= n:
+        N = k - n
+    else:
+        N = 0
+
+    f = f[N:M]
+
+    while f and f[0] == K.zero:
+        f.pop(0)
+
+    if not f:
+        return []
+    else:
+        return f + [K.zero]*m
+
+
+def dmp_slice(f, m, n, u, K):
+    """Take a continuous subsequence of terms of ``f`` in ``K[X]``. """
+    return dmp_slice_in(f, m, n, 0, u, K)
+
+
+def dmp_slice_in(f, m, n, j, u, K):
+    """Take a continuous subsequence of terms of ``f`` in ``x_j`` in ``K[X]``. """
+    if j < 0 or j > u:
+        raise IndexError("-%s <= j < %s expected, got %s" % (u, u, j))
+
+    if not u:
+        return dup_slice(f, m, n, K)
+
+    f, g = dmp_to_dict(f, u), {}
+
+    for monom, coeff in f.items():
+        k = monom[j]
+
+        if k < m or k >= n:
+            monom = monom[:j] + (0,) + monom[j + 1:]
+
+        if monom in g:
+            g[monom] += coeff
+        else:
+            g[monom] = coeff
+
+    return dmp_from_dict(g, u, K)
+
+
+def dup_random(n, a, b, K):
+    """
+    Return a polynomial of degree ``n`` with coefficients in ``[a, b]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_random
+
+    >>> dup_random(3, -10, 10, ZZ) #doctest: +SKIP
+    [-2, -8, 9, -4]
+
+    """
+    f = [ K.convert(random.randint(a, b)) for _ in range(0, n + 1) ]
+
+    while not f[0]:
+        f[0] = K.convert(random.randint(a, b))
+
+    return f
diff --git a/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/domainmatrix.py b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/domainmatrix.py
new file mode 100644
index 0000000000000000000000000000000000000000..c0ccaaa4cb96e0c49da58d8e9128c1b6fa551ade
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/domainmatrix.py
@@ -0,0 +1,12 @@
+"""
+Stub module to expose DomainMatrix which has now moved to
+sympy.polys.matrices package. It should now be imported as:
+
+    >>> from sympy.polys.matrices import DomainMatrix
+
+This module might be removed in future.
+"""
+
+from sympy.polys.matrices.domainmatrix import DomainMatrix
+
+__all__ = ['DomainMatrix']
diff --git a/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/euclidtools.py b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/euclidtools.py
new file mode 100644
index 0000000000000000000000000000000000000000..768a44a94930f05e701e9f27a8b0f570a3312314
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/euclidtools.py
@@ -0,0 +1,1912 @@
+"""Euclidean algorithms, GCDs, LCMs and polynomial remainder sequences. """
+
+
+from sympy.polys.densearith import (
+    dup_sub_mul,
+    dup_neg, dmp_neg,
+    dmp_add,
+    dmp_sub,
+    dup_mul, dmp_mul,
+    dmp_pow,
+    dup_div, dmp_div,
+    dup_rem,
+    dup_quo, dmp_quo,
+    dup_prem, dmp_prem,
+    dup_mul_ground, dmp_mul_ground,
+    dmp_mul_term,
+    dup_quo_ground, dmp_quo_ground,
+    dup_max_norm, dmp_max_norm)
+from sympy.polys.densebasic import (
+    dup_strip, dmp_raise,
+    dmp_zero, dmp_one, dmp_ground,
+    dmp_one_p, dmp_zero_p,
+    dmp_zeros,
+    dup_degree, dmp_degree, dmp_degree_in,
+    dup_LC, dmp_LC, dmp_ground_LC,
+    dmp_multi_deflate, dmp_inflate,
+    dup_convert, dmp_convert,
+    dmp_apply_pairs)
+from sympy.polys.densetools import (
+    dup_clear_denoms, dmp_clear_denoms,
+    dup_diff, dmp_diff,
+    dup_eval, dmp_eval, dmp_eval_in,
+    dup_trunc, dmp_ground_trunc,
+    dup_monic, dmp_ground_monic,
+    dup_primitive, dmp_ground_primitive,
+    dup_extract, dmp_ground_extract)
+from sympy.polys.galoistools import (
+    gf_int, gf_crt)
+from sympy.polys.polyconfig import query
+from sympy.polys.polyerrors import (
+    MultivariatePolynomialError,
+    HeuristicGCDFailed,
+    HomomorphismFailed,
+    NotInvertible,
+    DomainError)
+
+
+
+
+def dup_half_gcdex(f, g, K):
+    """
+    Half extended Euclidean algorithm in `F[x]`.
+
+    Returns ``(s, h)`` such that ``h = gcd(f, g)`` and ``s*f = h (mod g)``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x = ring("x", QQ)
+
+    >>> f = x**4 - 2*x**3 - 6*x**2 + 12*x + 15
+    >>> g = x**3 + x**2 - 4*x - 4
+
+    >>> R.dup_half_gcdex(f, g)
+    (-1/5*x + 3/5, x + 1)
+
+    """
+    if not K.is_Field:
+        raise DomainError("Cannot compute half extended GCD over %s" % K)
+
+    a, b = [K.one], []
+
+    while g:
+        q, r = dup_div(f, g, K)
+        f, g = g, r
+        a, b = b, dup_sub_mul(a, q, b, K)
+
+    a = dup_quo_ground(a, dup_LC(f, K), K)
+    f = dup_monic(f, K)
+
+    return a, f
+
+
+def dmp_half_gcdex(f, g, u, K):
+    """
+    Half extended Euclidean algorithm in `F[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    """
+    if not u:
+        return dup_half_gcdex(f, g, K)
+    else:
+        raise MultivariatePolynomialError(f, g)
+
+
+def dup_gcdex(f, g, K):
+    """
+    Extended Euclidean algorithm in `F[x]`.
+
+    Returns ``(s, t, h)`` such that ``h = gcd(f, g)`` and ``s*f + t*g = h``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x = ring("x", QQ)
+
+    >>> f = x**4 - 2*x**3 - 6*x**2 + 12*x + 15
+    >>> g = x**3 + x**2 - 4*x - 4
+
+    >>> R.dup_gcdex(f, g)
+    (-1/5*x + 3/5, 1/5*x**2 - 6/5*x + 2, x + 1)
+
+    """
+    s, h = dup_half_gcdex(f, g, K)
+
+    F = dup_sub_mul(h, s, f, K)
+    t = dup_quo(F, g, K)
+
+    return s, t, h
+
+
+def dmp_gcdex(f, g, u, K):
+    """
+    Extended Euclidean algorithm in `F[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    """
+    if not u:
+        return dup_gcdex(f, g, K)
+    else:
+        raise MultivariatePolynomialError(f, g)
+
+
+def dup_invert(f, g, K):
+    """
+    Compute multiplicative inverse of `f` modulo `g` in `F[x]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x = ring("x", QQ)
+
+    >>> f = x**2 - 1
+    >>> g = 2*x - 1
+    >>> h = x - 1
+
+    >>> R.dup_invert(f, g)
+    -4/3
+
+    >>> R.dup_invert(f, h)
+    Traceback (most recent call last):
+    ...
+    NotInvertible: zero divisor
+
+    """
+    s, h = dup_half_gcdex(f, g, K)
+
+    if h == [K.one]:
+        return dup_rem(s, g, K)
+    else:
+        raise NotInvertible("zero divisor")
+
+
+def dmp_invert(f, g, u, K):
+    """
+    Compute multiplicative inverse of `f` modulo `g` in `F[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x = ring("x", QQ)
+
+    """
+    if not u:
+        return dup_invert(f, g, K)
+    else:
+        raise MultivariatePolynomialError(f, g)
+
+
+def dup_euclidean_prs(f, g, K):
+    """
+    Euclidean polynomial remainder sequence (PRS) in `K[x]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x = ring("x", QQ)
+
+    >>> f = x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5
+    >>> g = 3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21
+
+    >>> prs = R.dup_euclidean_prs(f, g)
+
+    >>> prs[0]
+    x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5
+    >>> prs[1]
+    3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21
+    >>> prs[2]
+    -5/9*x**4 + 1/9*x**2 - 1/3
+    >>> prs[3]
+    -117/25*x**2 - 9*x + 441/25
+    >>> prs[4]
+    233150/19773*x - 102500/6591
+    >>> prs[5]
+    -1288744821/543589225
+
+    """
+    prs = [f, g]
+    h = dup_rem(f, g, K)
+
+    while h:
+        prs.append(h)
+        f, g = g, h
+        h = dup_rem(f, g, K)
+
+    return prs
+
+
+def dmp_euclidean_prs(f, g, u, K):
+    """
+    Euclidean polynomial remainder sequence (PRS) in `K[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    """
+    if not u:
+        return dup_euclidean_prs(f, g, K)
+    else:
+        raise MultivariatePolynomialError(f, g)
+
+
+def dup_primitive_prs(f, g, K):
+    """
+    Primitive polynomial remainder sequence (PRS) in `K[x]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> f = x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5
+    >>> g = 3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21
+
+    >>> prs = R.dup_primitive_prs(f, g)
+
+    >>> prs[0]
+    x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5
+    >>> prs[1]
+    3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21
+    >>> prs[2]
+    -5*x**4 + x**2 - 3
+    >>> prs[3]
+    13*x**2 + 25*x - 49
+    >>> prs[4]
+    4663*x - 6150
+    >>> prs[5]
+    1
+
+    """
+    prs = [f, g]
+    _, h = dup_primitive(dup_prem(f, g, K), K)
+
+    while h:
+        prs.append(h)
+        f, g = g, h
+        _, h = dup_primitive(dup_prem(f, g, K), K)
+
+    return prs
+
+
+def dmp_primitive_prs(f, g, u, K):
+    """
+    Primitive polynomial remainder sequence (PRS) in `K[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    """
+    if not u:
+        return dup_primitive_prs(f, g, K)
+    else:
+        raise MultivariatePolynomialError(f, g)
+
+
+def dup_inner_subresultants(f, g, K):
+    """
+    Subresultant PRS algorithm in `K[x]`.
+
+    Computes the subresultant polynomial remainder sequence (PRS)
+    and the non-zero scalar subresultants of `f` and `g`.
+    By [1] Thm. 3, these are the constants '-c' (- to optimize
+    computation of sign).
+    The first subdeterminant is set to 1 by convention to match
+    the polynomial and the scalar subdeterminants.
+    If 'deg(f) < deg(g)', the subresultants of '(g,f)' are computed.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_inner_subresultants(x**2 + 1, x**2 - 1)
+    ([x**2 + 1, x**2 - 1, -2], [1, 1, 4])
+
+    References
+    ==========
+
+    .. [1] W.S. Brown, The Subresultant PRS Algorithm.
+           ACM Transaction of Mathematical Software 4 (1978) 237-249
+
+    """
+    n = dup_degree(f)
+    m = dup_degree(g)
+
+    if n < m:
+        f, g = g, f
+        n, m = m, n
+
+    if not f:
+        return [], []
+
+    if not g:
+        return [f], [K.one]
+
+    R = [f, g]
+    d = n - m
+
+    b = (-K.one)**(d + 1)
+
+    h = dup_prem(f, g, K)
+    h = dup_mul_ground(h, b, K)
+
+    lc = dup_LC(g, K)
+    c = lc**d
+
+    # Conventional first scalar subdeterminant is 1
+    S = [K.one, c]
+    c = -c
+
+    while h:
+        k = dup_degree(h)
+        R.append(h)
+
+        f, g, m, d = g, h, k, m - k
+
+        b = -lc * c**d
+
+        h = dup_prem(f, g, K)
+        h = dup_quo_ground(h, b, K)
+
+        lc = dup_LC(g, K)
+
+        if d > 1:        # abnormal case
+            q = c**(d - 1)
+            c = K.quo((-lc)**d, q)
+        else:
+            c = -lc
+
+        S.append(-c)
+
+    return R, S
+
+
+def dup_subresultants(f, g, K):
+    """
+    Computes subresultant PRS of two polynomials in `K[x]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_subresultants(x**2 + 1, x**2 - 1)
+    [x**2 + 1, x**2 - 1, -2]
+
+    """
+    return dup_inner_subresultants(f, g, K)[0]
+
+
+def dup_prs_resultant(f, g, K):
+    """
+    Resultant algorithm in `K[x]` using subresultant PRS.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_prs_resultant(x**2 + 1, x**2 - 1)
+    (4, [x**2 + 1, x**2 - 1, -2])
+
+    """
+    if not f or not g:
+        return (K.zero, [])
+
+    R, S = dup_inner_subresultants(f, g, K)
+
+    if dup_degree(R[-1]) > 0:
+        return (K.zero, R)
+
+    return S[-1], R
+
+
+def dup_resultant(f, g, K, includePRS=False):
+    """
+    Computes resultant of two polynomials in `K[x]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_resultant(x**2 + 1, x**2 - 1)
+    4
+
+    """
+    if includePRS:
+        return dup_prs_resultant(f, g, K)
+    return dup_prs_resultant(f, g, K)[0]
+
+
+def dmp_inner_subresultants(f, g, u, K):
+    """
+    Subresultant PRS algorithm in `K[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> f = 3*x**2*y - y**3 - 4
+    >>> g = x**2 + x*y**3 - 9
+
+    >>> a = 3*x*y**4 + y**3 - 27*y + 4
+    >>> b = -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16
+
+    >>> prs = [f, g, a, b]
+    >>> sres = [[1], [1], [3, 0, 0, 0, 0], [-3, 0, 0, -12, 1, 0, -54, 8, 729, -216, 16]]
+
+    >>> R.dmp_inner_subresultants(f, g) == (prs, sres)
+    True
+
+    """
+    if not u:
+        return dup_inner_subresultants(f, g, K)
+
+    n = dmp_degree(f, u)
+    m = dmp_degree(g, u)
+
+    if n < m:
+        f, g = g, f
+        n, m = m, n
+
+    if dmp_zero_p(f, u):
+        return [], []
+
+    v = u - 1
+    if dmp_zero_p(g, u):
+        return [f], [dmp_ground(K.one, v)]
+
+    R = [f, g]
+    d = n - m
+
+    b = dmp_pow(dmp_ground(-K.one, v), d + 1, v, K)
+
+    h = dmp_prem(f, g, u, K)
+    h = dmp_mul_term(h, b, 0, u, K)
+
+    lc = dmp_LC(g, K)
+    c = dmp_pow(lc, d, v, K)
+
+    S = [dmp_ground(K.one, v), c]
+    c = dmp_neg(c, v, K)
+
+    while not dmp_zero_p(h, u):
+        k = dmp_degree(h, u)
+        R.append(h)
+
+        f, g, m, d = g, h, k, m - k
+
+        b = dmp_mul(dmp_neg(lc, v, K),
+                    dmp_pow(c, d, v, K), v, K)
+
+        h = dmp_prem(f, g, u, K)
+        h = [ dmp_quo(ch, b, v, K) for ch in h ]
+
+        lc = dmp_LC(g, K)
+
+        if d > 1:
+            p = dmp_pow(dmp_neg(lc, v, K), d, v, K)
+            q = dmp_pow(c, d - 1, v, K)
+            c = dmp_quo(p, q, v, K)
+        else:
+            c = dmp_neg(lc, v, K)
+
+        S.append(dmp_neg(c, v, K))
+
+    return R, S
+
+
+def dmp_subresultants(f, g, u, K):
+    """
+    Computes subresultant PRS of two polynomials in `K[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> f = 3*x**2*y - y**3 - 4
+    >>> g = x**2 + x*y**3 - 9
+
+    >>> a = 3*x*y**4 + y**3 - 27*y + 4
+    >>> b = -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16
+
+    >>> R.dmp_subresultants(f, g) == [f, g, a, b]
+    True
+
+    """
+    return dmp_inner_subresultants(f, g, u, K)[0]
+
+
+def dmp_prs_resultant(f, g, u, K):
+    """
+    Resultant algorithm in `K[X]` using subresultant PRS.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> f = 3*x**2*y - y**3 - 4
+    >>> g = x**2 + x*y**3 - 9
+
+    >>> a = 3*x*y**4 + y**3 - 27*y + 4
+    >>> b = -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16
+
+    >>> res, prs = R.dmp_prs_resultant(f, g)
+
+    >>> res == b             # resultant has n-1 variables
+    False
+    >>> res == b.drop(x)
+    True
+    >>> prs == [f, g, a, b]
+    True
+
+    """
+    if not u:
+        return dup_prs_resultant(f, g, K)
+
+    if dmp_zero_p(f, u) or dmp_zero_p(g, u):
+        return (dmp_zero(u - 1), [])
+
+    R, S = dmp_inner_subresultants(f, g, u, K)
+
+    if dmp_degree(R[-1], u) > 0:
+        return (dmp_zero(u - 1), R)
+
+    return S[-1], R
+
+
+def dmp_zz_modular_resultant(f, g, p, u, K):
+    """
+    Compute resultant of `f` and `g` modulo a prime `p`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> f = x + y + 2
+    >>> g = 2*x*y + x + 3
+
+    >>> R.dmp_zz_modular_resultant(f, g, 5)
+    -2*y**2 + 1
+
+    """
+    if not u:
+        return gf_int(dup_prs_resultant(f, g, K)[0] % p, p)
+
+    v = u - 1
+
+    n = dmp_degree(f, u)
+    m = dmp_degree(g, u)
+
+    N = dmp_degree_in(f, 1, u)
+    M = dmp_degree_in(g, 1, u)
+
+    B = n*M + m*N
+
+    D, a = [K.one], -K.one
+    r = dmp_zero(v)
+
+    while dup_degree(D) <= B:
+        while True:
+            a += K.one
+
+            if a == p:
+                raise HomomorphismFailed('no luck')
+
+            F = dmp_eval_in(f, gf_int(a, p), 1, u, K)
+
+            if dmp_degree(F, v) == n:
+                G = dmp_eval_in(g, gf_int(a, p), 1, u, K)
+
+                if dmp_degree(G, v) == m:
+                    break
+
+        R = dmp_zz_modular_resultant(F, G, p, v, K)
+        e = dmp_eval(r, a, v, K)
+
+        if not v:
+            R = dup_strip([R])
+            e = dup_strip([e])
+        else:
+            R = [R]
+            e = [e]
+
+        d = K.invert(dup_eval(D, a, K), p)
+        d = dup_mul_ground(D, d, K)
+        d = dmp_raise(d, v, 0, K)
+
+        c = dmp_mul(d, dmp_sub(R, e, v, K), v, K)
+        r = dmp_add(r, c, v, K)
+
+        r = dmp_ground_trunc(r, p, v, K)
+
+        D = dup_mul(D, [K.one, -a], K)
+        D = dup_trunc(D, p, K)
+
+    return r
+
+
+def _collins_crt(r, R, P, p, K):
+    """Wrapper of CRT for Collins's resultant algorithm. """
+    return gf_int(gf_crt([r, R], [P, p], K), P*p)
+
+
+def dmp_zz_collins_resultant(f, g, u, K):
+    """
+    Collins's modular resultant algorithm in `Z[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> f = x + y + 2
+    >>> g = 2*x*y + x + 3
+
+    >>> R.dmp_zz_collins_resultant(f, g)
+    -2*y**2 - 5*y + 1
+
+    """
+
+    n = dmp_degree(f, u)
+    m = dmp_degree(g, u)
+
+    if n < 0 or m < 0:
+        return dmp_zero(u - 1)
+
+    A = dmp_max_norm(f, u, K)
+    B = dmp_max_norm(g, u, K)
+
+    a = dmp_ground_LC(f, u, K)
+    b = dmp_ground_LC(g, u, K)
+
+    v = u - 1
+
+    B = K(2)*K.factorial(K(n + m))*A**m*B**n
+    r, p, P = dmp_zero(v), K.one, K.one
+
+    from sympy.ntheory import nextprime
+
+    while P <= B:
+        p = K(nextprime(p))
+
+        while not (a % p) or not (b % p):
+            p = K(nextprime(p))
+
+        F = dmp_ground_trunc(f, p, u, K)
+        G = dmp_ground_trunc(g, p, u, K)
+
+        try:
+            R = dmp_zz_modular_resultant(F, G, p, u, K)
+        except HomomorphismFailed:
+            continue
+
+        if K.is_one(P):
+            r = R
+        else:
+            r = dmp_apply_pairs(r, R, _collins_crt, (P, p, K), v, K)
+
+        P *= p
+
+    return r
+
+
+def dmp_qq_collins_resultant(f, g, u, K0):
+    """
+    Collins's modular resultant algorithm in `Q[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x,y = ring("x,y", QQ)
+
+    >>> f = QQ(1,2)*x + y + QQ(2,3)
+    >>> g = 2*x*y + x + 3
+
+    >>> R.dmp_qq_collins_resultant(f, g)
+    -2*y**2 - 7/3*y + 5/6
+
+    """
+    n = dmp_degree(f, u)
+    m = dmp_degree(g, u)
+
+    if n < 0 or m < 0:
+        return dmp_zero(u - 1)
+
+    K1 = K0.get_ring()
+
+    cf, f = dmp_clear_denoms(f, u, K0, K1)
+    cg, g = dmp_clear_denoms(g, u, K0, K1)
+
+    f = dmp_convert(f, u, K0, K1)
+    g = dmp_convert(g, u, K0, K1)
+
+    r = dmp_zz_collins_resultant(f, g, u, K1)
+    r = dmp_convert(r, u - 1, K1, K0)
+
+    c = K0.convert(cf**m * cg**n, K1)
+
+    return dmp_quo_ground(r, c, u - 1, K0)
+
+
+def dmp_resultant(f, g, u, K, includePRS=False):
+    """
+    Computes resultant of two polynomials in `K[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> f = 3*x**2*y - y**3 - 4
+    >>> g = x**2 + x*y**3 - 9
+
+    >>> R.dmp_resultant(f, g)
+    -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16
+
+    """
+    if not u:
+        return dup_resultant(f, g, K, includePRS=includePRS)
+
+    if includePRS:
+        return dmp_prs_resultant(f, g, u, K)
+
+    if K.is_Field:
+        if K.is_QQ and query('USE_COLLINS_RESULTANT'):
+            return dmp_qq_collins_resultant(f, g, u, K)
+    else:
+        if K.is_ZZ and query('USE_COLLINS_RESULTANT'):
+            return dmp_zz_collins_resultant(f, g, u, K)
+
+    return dmp_prs_resultant(f, g, u, K)[0]
+
+
+def dup_discriminant(f, K):
+    """
+    Computes discriminant of a polynomial in `K[x]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_discriminant(x**2 + 2*x + 3)
+    -8
+
+    """
+    d = dup_degree(f)
+
+    if d <= 0:
+        return K.zero
+    else:
+        s = (-1)**((d*(d - 1)) // 2)
+        c = dup_LC(f, K)
+
+        r = dup_resultant(f, dup_diff(f, 1, K), K)
+
+        return K.quo(r, c*K(s))
+
+
+def dmp_discriminant(f, u, K):
+    """
+    Computes discriminant of a polynomial in `K[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y,z,t = ring("x,y,z,t", ZZ)
+
+    >>> R.dmp_discriminant(x**2*y + x*z + t)
+    -4*y*t + z**2
+
+    """
+    if not u:
+        return dup_discriminant(f, K)
+
+    d, v = dmp_degree(f, u), u - 1
+
+    if d <= 0:
+        return dmp_zero(v)
+    else:
+        s = (-1)**((d*(d - 1)) // 2)
+        c = dmp_LC(f, K)
+
+        r = dmp_resultant(f, dmp_diff(f, 1, u, K), u, K)
+        c = dmp_mul_ground(c, K(s), v, K)
+
+        return dmp_quo(r, c, v, K)
+
+
+def _dup_rr_trivial_gcd(f, g, K):
+    """Handle trivial cases in GCD algorithm over a ring. """
+    if not (f or g):
+        return [], [], []
+    elif not f:
+        if K.is_nonnegative(dup_LC(g, K)):
+            return g, [], [K.one]
+        else:
+            return dup_neg(g, K), [], [-K.one]
+    elif not g:
+        if K.is_nonnegative(dup_LC(f, K)):
+            return f, [K.one], []
+        else:
+            return dup_neg(f, K), [-K.one], []
+
+    return None
+
+
+def _dup_ff_trivial_gcd(f, g, K):
+    """Handle trivial cases in GCD algorithm over a field. """
+    if not (f or g):
+        return [], [], []
+    elif not f:
+        return dup_monic(g, K), [], [dup_LC(g, K)]
+    elif not g:
+        return dup_monic(f, K), [dup_LC(f, K)], []
+    else:
+        return None
+
+
+def _dmp_rr_trivial_gcd(f, g, u, K):
+    """Handle trivial cases in GCD algorithm over a ring. """
+    zero_f = dmp_zero_p(f, u)
+    zero_g = dmp_zero_p(g, u)
+    if_contain_one = dmp_one_p(f, u, K) or dmp_one_p(g, u, K)
+
+    if zero_f and zero_g:
+        return tuple(dmp_zeros(3, u, K))
+    elif zero_f:
+        if K.is_nonnegative(dmp_ground_LC(g, u, K)):
+            return g, dmp_zero(u), dmp_one(u, K)
+        else:
+            return dmp_neg(g, u, K), dmp_zero(u), dmp_ground(-K.one, u)
+    elif zero_g:
+        if K.is_nonnegative(dmp_ground_LC(f, u, K)):
+            return f, dmp_one(u, K), dmp_zero(u)
+        else:
+            return dmp_neg(f, u, K), dmp_ground(-K.one, u), dmp_zero(u)
+    elif if_contain_one:
+        return dmp_one(u, K), f, g
+    elif query('USE_SIMPLIFY_GCD'):
+        return _dmp_simplify_gcd(f, g, u, K)
+    else:
+        return None
+
+
+def _dmp_ff_trivial_gcd(f, g, u, K):
+    """Handle trivial cases in GCD algorithm over a field. """
+    zero_f = dmp_zero_p(f, u)
+    zero_g = dmp_zero_p(g, u)
+
+    if zero_f and zero_g:
+        return tuple(dmp_zeros(3, u, K))
+    elif zero_f:
+        return (dmp_ground_monic(g, u, K),
+                dmp_zero(u),
+                dmp_ground(dmp_ground_LC(g, u, K), u))
+    elif zero_g:
+        return (dmp_ground_monic(f, u, K),
+                dmp_ground(dmp_ground_LC(f, u, K), u),
+                dmp_zero(u))
+    elif query('USE_SIMPLIFY_GCD'):
+        return _dmp_simplify_gcd(f, g, u, K)
+    else:
+        return None
+
+
+def _dmp_simplify_gcd(f, g, u, K):
+    """Try to eliminate `x_0` from GCD computation in `K[X]`. """
+    df = dmp_degree(f, u)
+    dg = dmp_degree(g, u)
+
+    if df > 0 and dg > 0:
+        return None
+
+    if not (df or dg):
+        F = dmp_LC(f, K)
+        G = dmp_LC(g, K)
+    else:
+        if not df:
+            F = dmp_LC(f, K)
+            G = dmp_content(g, u, K)
+        else:
+            F = dmp_content(f, u, K)
+            G = dmp_LC(g, K)
+
+    v = u - 1
+    h = dmp_gcd(F, G, v, K)
+
+    cff = [ dmp_quo(cf, h, v, K) for cf in f ]
+    cfg = [ dmp_quo(cg, h, v, K) for cg in g ]
+
+    return [h], cff, cfg
+
+
+def dup_rr_prs_gcd(f, g, K):
+    """
+    Computes polynomial GCD using subresultants over a ring.
+
+    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``, ``cff = quo(f, h)``,
+    and ``cfg = quo(g, h)``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_rr_prs_gcd(x**2 - 1, x**2 - 3*x + 2)
+    (x - 1, x + 1, x - 2)
+
+    """
+    result = _dup_rr_trivial_gcd(f, g, K)
+
+    if result is not None:
+        return result
+
+    fc, F = dup_primitive(f, K)
+    gc, G = dup_primitive(g, K)
+
+    c = K.gcd(fc, gc)
+
+    h = dup_subresultants(F, G, K)[-1]
+    _, h = dup_primitive(h, K)
+
+    c *= K.canonical_unit(dup_LC(h, K))
+
+    h = dup_mul_ground(h, c, K)
+
+    cff = dup_quo(f, h, K)
+    cfg = dup_quo(g, h, K)
+
+    return h, cff, cfg
+
+
+def dup_ff_prs_gcd(f, g, K):
+    """
+    Computes polynomial GCD using subresultants over a field.
+
+    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``, ``cff = quo(f, h)``,
+    and ``cfg = quo(g, h)``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x = ring("x", QQ)
+
+    >>> R.dup_ff_prs_gcd(x**2 - 1, x**2 - 3*x + 2)
+    (x - 1, x + 1, x - 2)
+
+    """
+    result = _dup_ff_trivial_gcd(f, g, K)
+
+    if result is not None:
+        return result
+
+    h = dup_subresultants(f, g, K)[-1]
+    h = dup_monic(h, K)
+
+    cff = dup_quo(f, h, K)
+    cfg = dup_quo(g, h, K)
+
+    return h, cff, cfg
+
+
+def dmp_rr_prs_gcd(f, g, u, K):
+    """
+    Computes polynomial GCD using subresultants over a ring.
+
+    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``, ``cff = quo(f, h)``,
+    and ``cfg = quo(g, h)``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y, = ring("x,y", ZZ)
+
+    >>> f = x**2 + 2*x*y + y**2
+    >>> g = x**2 + x*y
+
+    >>> R.dmp_rr_prs_gcd(f, g)
+    (x + y, x + y, x)
+
+    """
+    if not u:
+        return dup_rr_prs_gcd(f, g, K)
+
+    result = _dmp_rr_trivial_gcd(f, g, u, K)
+
+    if result is not None:
+        return result
+
+    fc, F = dmp_primitive(f, u, K)
+    gc, G = dmp_primitive(g, u, K)
+
+    h = dmp_subresultants(F, G, u, K)[-1]
+    c, _, _ = dmp_rr_prs_gcd(fc, gc, u - 1, K)
+
+    _, h = dmp_primitive(h, u, K)
+    h = dmp_mul_term(h, c, 0, u, K)
+
+    unit = K.canonical_unit(dmp_ground_LC(h, u, K))
+
+    if unit != K.one:
+        h = dmp_mul_ground(h, unit, u, K)
+
+    cff = dmp_quo(f, h, u, K)
+    cfg = dmp_quo(g, h, u, K)
+
+    return h, cff, cfg
+
+
+def dmp_ff_prs_gcd(f, g, u, K):
+    """
+    Computes polynomial GCD using subresultants over a field.
+
+    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``, ``cff = quo(f, h)``,
+    and ``cfg = quo(g, h)``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x,y, = ring("x,y", QQ)
+
+    >>> f = QQ(1,2)*x**2 + x*y + QQ(1,2)*y**2
+    >>> g = x**2 + x*y
+
+    >>> R.dmp_ff_prs_gcd(f, g)
+    (x + y, 1/2*x + 1/2*y, x)
+
+    """
+    if not u:
+        return dup_ff_prs_gcd(f, g, K)
+
+    result = _dmp_ff_trivial_gcd(f, g, u, K)
+
+    if result is not None:
+        return result
+
+    fc, F = dmp_primitive(f, u, K)
+    gc, G = dmp_primitive(g, u, K)
+
+    h = dmp_subresultants(F, G, u, K)[-1]
+    c, _, _ = dmp_ff_prs_gcd(fc, gc, u - 1, K)
+
+    _, h = dmp_primitive(h, u, K)
+    h = dmp_mul_term(h, c, 0, u, K)
+    h = dmp_ground_monic(h, u, K)
+
+    cff = dmp_quo(f, h, u, K)
+    cfg = dmp_quo(g, h, u, K)
+
+    return h, cff, cfg
+
+HEU_GCD_MAX = 6
+
+
+def _dup_zz_gcd_interpolate(h, x, K):
+    """Interpolate polynomial GCD from integer GCD. """
+    f = []
+
+    while h:
+        g = h % x
+
+        if g > x // 2:
+            g -= x
+
+        f.insert(0, g)
+        h = (h - g) // x
+
+    return f
+
+
+def dup_zz_heu_gcd(f, g, K):
+    """
+    Heuristic polynomial GCD in `Z[x]`.
+
+    Given univariate polynomials `f` and `g` in `Z[x]`, returns
+    their GCD and cofactors, i.e. polynomials ``h``, ``cff`` and ``cfg``
+    such that::
+
+          h = gcd(f, g), cff = quo(f, h) and cfg = quo(g, h)
+
+    The algorithm is purely heuristic which means it may fail to compute
+    the GCD. This will be signaled by raising an exception. In this case
+    you will need to switch to another GCD method.
+
+    The algorithm computes the polynomial GCD by evaluating polynomials
+    f and g at certain points and computing (fast) integer GCD of those
+    evaluations. The polynomial GCD is recovered from the integer image
+    by interpolation.  The final step is to verify if the result is the
+    correct GCD. This gives cofactors as a side effect.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_zz_heu_gcd(x**2 - 1, x**2 - 3*x + 2)
+    (x - 1, x + 1, x - 2)
+
+    References
+    ==========
+
+    .. [1] [Liao95]_
+
+    """
+    result = _dup_rr_trivial_gcd(f, g, K)
+
+    if result is not None:
+        return result
+
+    df = dup_degree(f)
+    dg = dup_degree(g)
+
+    gcd, f, g = dup_extract(f, g, K)
+
+    if df == 0 or dg == 0:
+        return [gcd], f, g
+
+    f_norm = dup_max_norm(f, K)
+    g_norm = dup_max_norm(g, K)
+
+    B = K(2*min(f_norm, g_norm) + 29)
+
+    x = max(min(B, 99*K.sqrt(B)),
+            2*min(f_norm // abs(dup_LC(f, K)),
+                  g_norm // abs(dup_LC(g, K))) + 4)
+
+    for i in range(0, HEU_GCD_MAX):
+        ff = dup_eval(f, x, K)
+        gg = dup_eval(g, x, K)
+
+        if ff and gg:
+            h = K.gcd(ff, gg)
+
+            cff = ff // h
+            cfg = gg // h
+
+            h = _dup_zz_gcd_interpolate(h, x, K)
+            h = dup_primitive(h, K)[1]
+
+            cff_, r = dup_div(f, h, K)
+
+            if not r:
+                cfg_, r = dup_div(g, h, K)
+
+                if not r:
+                    h = dup_mul_ground(h, gcd, K)
+                    return h, cff_, cfg_
+
+            cff = _dup_zz_gcd_interpolate(cff, x, K)
+
+            h, r = dup_div(f, cff, K)
+
+            if not r:
+                cfg_, r = dup_div(g, h, K)
+
+                if not r:
+                    h = dup_mul_ground(h, gcd, K)
+                    return h, cff, cfg_
+
+            cfg = _dup_zz_gcd_interpolate(cfg, x, K)
+
+            h, r = dup_div(g, cfg, K)
+
+            if not r:
+                cff_, r = dup_div(f, h, K)
+
+                if not r:
+                    h = dup_mul_ground(h, gcd, K)
+                    return h, cff_, cfg
+
+        x = 73794*x * K.sqrt(K.sqrt(x)) // 27011
+
+    raise HeuristicGCDFailed('no luck')
+
+
+def _dmp_zz_gcd_interpolate(h, x, v, K):
+    """Interpolate polynomial GCD from integer GCD. """
+    f = []
+
+    while not dmp_zero_p(h, v):
+        g = dmp_ground_trunc(h, x, v, K)
+        f.insert(0, g)
+
+        h = dmp_sub(h, g, v, K)
+        h = dmp_quo_ground(h, x, v, K)
+
+    if K.is_negative(dmp_ground_LC(f, v + 1, K)):
+        return dmp_neg(f, v + 1, K)
+    else:
+        return f
+
+
+def dmp_zz_heu_gcd(f, g, u, K):
+    """
+    Heuristic polynomial GCD in `Z[X]`.
+
+    Given univariate polynomials `f` and `g` in `Z[X]`, returns
+    their GCD and cofactors, i.e. polynomials ``h``, ``cff`` and ``cfg``
+    such that::
+
+          h = gcd(f, g), cff = quo(f, h) and cfg = quo(g, h)
+
+    The algorithm is purely heuristic which means it may fail to compute
+    the GCD. This will be signaled by raising an exception. In this case
+    you will need to switch to another GCD method.
+
+    The algorithm computes the polynomial GCD by evaluating polynomials
+    f and g at certain points and computing (fast) integer GCD of those
+    evaluations. The polynomial GCD is recovered from the integer image
+    by interpolation. The evaluation process reduces f and g variable by
+    variable into a large integer.  The final step is to verify if the
+    interpolated polynomial is the correct GCD. This gives cofactors of
+    the input polynomials as a side effect.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y, = ring("x,y", ZZ)
+
+    >>> f = x**2 + 2*x*y + y**2
+    >>> g = x**2 + x*y
+
+    >>> R.dmp_zz_heu_gcd(f, g)
+    (x + y, x + y, x)
+
+    References
+    ==========
+
+    .. [1] [Liao95]_
+
+    """
+    if not u:
+        return dup_zz_heu_gcd(f, g, K)
+
+    result = _dmp_rr_trivial_gcd(f, g, u, K)
+
+    if result is not None:
+        return result
+
+    gcd, f, g = dmp_ground_extract(f, g, u, K)
+
+    f_norm = dmp_max_norm(f, u, K)
+    g_norm = dmp_max_norm(g, u, K)
+
+    B = K(2*min(f_norm, g_norm) + 29)
+
+    x = max(min(B, 99*K.sqrt(B)),
+            2*min(f_norm // abs(dmp_ground_LC(f, u, K)),
+                  g_norm // abs(dmp_ground_LC(g, u, K))) + 4)
+
+    for i in range(0, HEU_GCD_MAX):
+        ff = dmp_eval(f, x, u, K)
+        gg = dmp_eval(g, x, u, K)
+
+        v = u - 1
+
+        if not (dmp_zero_p(ff, v) or dmp_zero_p(gg, v)):
+            h, cff, cfg = dmp_zz_heu_gcd(ff, gg, v, K)
+
+            h = _dmp_zz_gcd_interpolate(h, x, v, K)
+            h = dmp_ground_primitive(h, u, K)[1]
+
+            cff_, r = dmp_div(f, h, u, K)
+
+            if dmp_zero_p(r, u):
+                cfg_, r = dmp_div(g, h, u, K)
+
+                if dmp_zero_p(r, u):
+                    h = dmp_mul_ground(h, gcd, u, K)
+                    return h, cff_, cfg_
+
+            cff = _dmp_zz_gcd_interpolate(cff, x, v, K)
+
+            h, r = dmp_div(f, cff, u, K)
+
+            if dmp_zero_p(r, u):
+                cfg_, r = dmp_div(g, h, u, K)
+
+                if dmp_zero_p(r, u):
+                    h = dmp_mul_ground(h, gcd, u, K)
+                    return h, cff, cfg_
+
+            cfg = _dmp_zz_gcd_interpolate(cfg, x, v, K)
+
+            h, r = dmp_div(g, cfg, u, K)
+
+            if dmp_zero_p(r, u):
+                cff_, r = dmp_div(f, h, u, K)
+
+                if dmp_zero_p(r, u):
+                    h = dmp_mul_ground(h, gcd, u, K)
+                    return h, cff_, cfg
+
+        x = 73794*x * K.sqrt(K.sqrt(x)) // 27011
+
+    raise HeuristicGCDFailed('no luck')
+
+
+def dup_qq_heu_gcd(f, g, K0):
+    """
+    Heuristic polynomial GCD in `Q[x]`.
+
+    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``,
+    ``cff = quo(f, h)``, and ``cfg = quo(g, h)``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x = ring("x", QQ)
+
+    >>> f = QQ(1,2)*x**2 + QQ(7,4)*x + QQ(3,2)
+    >>> g = QQ(1,2)*x**2 + x
+
+    >>> R.dup_qq_heu_gcd(f, g)
+    (x + 2, 1/2*x + 3/4, 1/2*x)
+
+    """
+    result = _dup_ff_trivial_gcd(f, g, K0)
+
+    if result is not None:
+        return result
+
+    K1 = K0.get_ring()
+
+    cf, f = dup_clear_denoms(f, K0, K1)
+    cg, g = dup_clear_denoms(g, K0, K1)
+
+    f = dup_convert(f, K0, K1)
+    g = dup_convert(g, K0, K1)
+
+    h, cff, cfg = dup_zz_heu_gcd(f, g, K1)
+
+    h = dup_convert(h, K1, K0)
+
+    c = dup_LC(h, K0)
+    h = dup_monic(h, K0)
+
+    cff = dup_convert(cff, K1, K0)
+    cfg = dup_convert(cfg, K1, K0)
+
+    cff = dup_mul_ground(cff, K0.quo(c, cf), K0)
+    cfg = dup_mul_ground(cfg, K0.quo(c, cg), K0)
+
+    return h, cff, cfg
+
+
+def dmp_qq_heu_gcd(f, g, u, K0):
+    """
+    Heuristic polynomial GCD in `Q[X]`.
+
+    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``,
+    ``cff = quo(f, h)``, and ``cfg = quo(g, h)``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x,y, = ring("x,y", QQ)
+
+    >>> f = QQ(1,4)*x**2 + x*y + y**2
+    >>> g = QQ(1,2)*x**2 + x*y
+
+    >>> R.dmp_qq_heu_gcd(f, g)
+    (x + 2*y, 1/4*x + 1/2*y, 1/2*x)
+
+    """
+    result = _dmp_ff_trivial_gcd(f, g, u, K0)
+
+    if result is not None:
+        return result
+
+    K1 = K0.get_ring()
+
+    cf, f = dmp_clear_denoms(f, u, K0, K1)
+    cg, g = dmp_clear_denoms(g, u, K0, K1)
+
+    f = dmp_convert(f, u, K0, K1)
+    g = dmp_convert(g, u, K0, K1)
+
+    h, cff, cfg = dmp_zz_heu_gcd(f, g, u, K1)
+
+    h = dmp_convert(h, u, K1, K0)
+
+    c = dmp_ground_LC(h, u, K0)
+    h = dmp_ground_monic(h, u, K0)
+
+    cff = dmp_convert(cff, u, K1, K0)
+    cfg = dmp_convert(cfg, u, K1, K0)
+
+    cff = dmp_mul_ground(cff, K0.quo(c, cf), u, K0)
+    cfg = dmp_mul_ground(cfg, K0.quo(c, cg), u, K0)
+
+    return h, cff, cfg
+
+
+def dup_inner_gcd(f, g, K):
+    """
+    Computes polynomial GCD and cofactors of `f` and `g` in `K[x]`.
+
+    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``,
+    ``cff = quo(f, h)``, and ``cfg = quo(g, h)``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_inner_gcd(x**2 - 1, x**2 - 3*x + 2)
+    (x - 1, x + 1, x - 2)
+
+    """
+    # XXX: This used to check for K.is_Exact but leads to awkward results when
+    # the domain is something like RR[z] e.g.:
+    #
+    # >>> g, p, q = Poly(1, x).cancel(Poly(51.05*x*y - 1.0, x))
+    # >>> g
+    # 1.0
+    # >>> p
+    # Poly(17592186044421.0, x, domain='RR[y]')
+    # >>> q
+    # Poly(898081097567692.0*y*x - 17592186044421.0, x, domain='RR[y]'))
+    #
+    # Maybe it would be better to flatten into multivariate polynomials first.
+    if K.is_RR or K.is_CC:
+        try:
+            exact = K.get_exact()
+        except DomainError:
+            return [K.one], f, g
+
+        f = dup_convert(f, K, exact)
+        g = dup_convert(g, K, exact)
+
+        h, cff, cfg = dup_inner_gcd(f, g, exact)
+
+        h = dup_convert(h, exact, K)
+        cff = dup_convert(cff, exact, K)
+        cfg = dup_convert(cfg, exact, K)
+
+        return h, cff, cfg
+    elif K.is_Field:
+        if K.is_QQ and query('USE_HEU_GCD'):
+            try:
+                return dup_qq_heu_gcd(f, g, K)
+            except HeuristicGCDFailed:
+                pass
+
+        return dup_ff_prs_gcd(f, g, K)
+    else:
+        if K.is_ZZ and query('USE_HEU_GCD'):
+            try:
+                return dup_zz_heu_gcd(f, g, K)
+            except HeuristicGCDFailed:
+                pass
+
+        return dup_rr_prs_gcd(f, g, K)
+
+
+def _dmp_inner_gcd(f, g, u, K):
+    """Helper function for `dmp_inner_gcd()`. """
+    if not K.is_Exact:
+        try:
+            exact = K.get_exact()
+        except DomainError:
+            return dmp_one(u, K), f, g
+
+        f = dmp_convert(f, u, K, exact)
+        g = dmp_convert(g, u, K, exact)
+
+        h, cff, cfg = _dmp_inner_gcd(f, g, u, exact)
+
+        h = dmp_convert(h, u, exact, K)
+        cff = dmp_convert(cff, u, exact, K)
+        cfg = dmp_convert(cfg, u, exact, K)
+
+        return h, cff, cfg
+    elif K.is_Field:
+        if K.is_QQ and query('USE_HEU_GCD'):
+            try:
+                return dmp_qq_heu_gcd(f, g, u, K)
+            except HeuristicGCDFailed:
+                pass
+
+        return dmp_ff_prs_gcd(f, g, u, K)
+    else:
+        if K.is_ZZ and query('USE_HEU_GCD'):
+            try:
+                return dmp_zz_heu_gcd(f, g, u, K)
+            except HeuristicGCDFailed:
+                pass
+
+        return dmp_rr_prs_gcd(f, g, u, K)
+
+
+def dmp_inner_gcd(f, g, u, K):
+    """
+    Computes polynomial GCD and cofactors of `f` and `g` in `K[X]`.
+
+    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``,
+    ``cff = quo(f, h)``, and ``cfg = quo(g, h)``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y, = ring("x,y", ZZ)
+
+    >>> f = x**2 + 2*x*y + y**2
+    >>> g = x**2 + x*y
+
+    >>> R.dmp_inner_gcd(f, g)
+    (x + y, x + y, x)
+
+    """
+    if not u:
+        return dup_inner_gcd(f, g, K)
+
+    J, (f, g) = dmp_multi_deflate((f, g), u, K)
+    h, cff, cfg = _dmp_inner_gcd(f, g, u, K)
+
+    return (dmp_inflate(h, J, u, K),
+            dmp_inflate(cff, J, u, K),
+            dmp_inflate(cfg, J, u, K))
+
+
+def dup_gcd(f, g, K):
+    """
+    Computes polynomial GCD of `f` and `g` in `K[x]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_gcd(x**2 - 1, x**2 - 3*x + 2)
+    x - 1
+
+    """
+    return dup_inner_gcd(f, g, K)[0]
+
+
+def dmp_gcd(f, g, u, K):
+    """
+    Computes polynomial GCD of `f` and `g` in `K[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y, = ring("x,y", ZZ)
+
+    >>> f = x**2 + 2*x*y + y**2
+    >>> g = x**2 + x*y
+
+    >>> R.dmp_gcd(f, g)
+    x + y
+
+    """
+    return dmp_inner_gcd(f, g, u, K)[0]
+
+
+def dup_rr_lcm(f, g, K):
+    """
+    Computes polynomial LCM over a ring in `K[x]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_rr_lcm(x**2 - 1, x**2 - 3*x + 2)
+    x**3 - 2*x**2 - x + 2
+
+    """
+    if not f or not g:
+        return dmp_zero(0)
+
+    fc, f = dup_primitive(f, K)
+    gc, g = dup_primitive(g, K)
+
+    c = K.lcm(fc, gc)
+
+    h = dup_quo(dup_mul(f, g, K),
+                dup_gcd(f, g, K), K)
+
+    u = K.canonical_unit(dup_LC(h, K))
+
+    return dup_mul_ground(h, c*u, K)
+
+
+def dup_ff_lcm(f, g, K):
+    """
+    Computes polynomial LCM over a field in `K[x]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x = ring("x", QQ)
+
+    >>> f = QQ(1,2)*x**2 + QQ(7,4)*x + QQ(3,2)
+    >>> g = QQ(1,2)*x**2 + x
+
+    >>> R.dup_ff_lcm(f, g)
+    x**3 + 7/2*x**2 + 3*x
+
+    """
+    h = dup_quo(dup_mul(f, g, K),
+                dup_gcd(f, g, K), K)
+
+    return dup_monic(h, K)
+
+
+def dup_lcm(f, g, K):
+    """
+    Computes polynomial LCM of `f` and `g` in `K[x]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_lcm(x**2 - 1, x**2 - 3*x + 2)
+    x**3 - 2*x**2 - x + 2
+
+    """
+    if K.is_Field:
+        return dup_ff_lcm(f, g, K)
+    else:
+        return dup_rr_lcm(f, g, K)
+
+
+def dmp_rr_lcm(f, g, u, K):
+    """
+    Computes polynomial LCM over a ring in `K[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y, = ring("x,y", ZZ)
+
+    >>> f = x**2 + 2*x*y + y**2
+    >>> g = x**2 + x*y
+
+    >>> R.dmp_rr_lcm(f, g)
+    x**3 + 2*x**2*y + x*y**2
+
+    """
+    fc, f = dmp_ground_primitive(f, u, K)
+    gc, g = dmp_ground_primitive(g, u, K)
+
+    c = K.lcm(fc, gc)
+
+    h = dmp_quo(dmp_mul(f, g, u, K),
+                dmp_gcd(f, g, u, K), u, K)
+
+    return dmp_mul_ground(h, c, u, K)
+
+
+def dmp_ff_lcm(f, g, u, K):
+    """
+    Computes polynomial LCM over a field in `K[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x,y, = ring("x,y", QQ)
+
+    >>> f = QQ(1,4)*x**2 + x*y + y**2
+    >>> g = QQ(1,2)*x**2 + x*y
+
+    >>> R.dmp_ff_lcm(f, g)
+    x**3 + 4*x**2*y + 4*x*y**2
+
+    """
+    h = dmp_quo(dmp_mul(f, g, u, K),
+                dmp_gcd(f, g, u, K), u, K)
+
+    return dmp_ground_monic(h, u, K)
+
+
+def dmp_lcm(f, g, u, K):
+    """
+    Computes polynomial LCM of `f` and `g` in `K[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y, = ring("x,y", ZZ)
+
+    >>> f = x**2 + 2*x*y + y**2
+    >>> g = x**2 + x*y
+
+    >>> R.dmp_lcm(f, g)
+    x**3 + 2*x**2*y + x*y**2
+
+    """
+    if not u:
+        return dup_lcm(f, g, K)
+
+    if K.is_Field:
+        return dmp_ff_lcm(f, g, u, K)
+    else:
+        return dmp_rr_lcm(f, g, u, K)
+
+
+def dmp_content(f, u, K):
+    """
+    Returns GCD of multivariate coefficients.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y, = ring("x,y", ZZ)
+
+    >>> R.dmp_content(2*x*y + 6*x + 4*y + 12)
+    2*y + 6
+
+    """
+    cont, v = dmp_LC(f, K), u - 1
+
+    if dmp_zero_p(f, u):
+        return cont
+
+    for c in f[1:]:
+        cont = dmp_gcd(cont, c, v, K)
+
+        if dmp_one_p(cont, v, K):
+            break
+
+    if K.is_negative(dmp_ground_LC(cont, v, K)):
+        return dmp_neg(cont, v, K)
+    else:
+        return cont
+
+
+def dmp_primitive(f, u, K):
+    """
+    Returns multivariate content and a primitive polynomial.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y, = ring("x,y", ZZ)
+
+    >>> R.dmp_primitive(2*x*y + 6*x + 4*y + 12)
+    (2*y + 6, x + 2)
+
+    """
+    cont, v = dmp_content(f, u, K), u - 1
+
+    if dmp_zero_p(f, u) or dmp_one_p(cont, v, K):
+        return cont, f
+    else:
+        return cont, [ dmp_quo(c, cont, v, K) for c in f ]
+
+
+def dup_cancel(f, g, K, include=True):
+    """
+    Cancel common factors in a rational function `f/g`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_cancel(2*x**2 - 2, x**2 - 2*x + 1)
+    (2*x + 2, x - 1)
+
+    """
+    return dmp_cancel(f, g, 0, K, include=include)
+
+
+def dmp_cancel(f, g, u, K, include=True):
+    """
+    Cancel common factors in a rational function `f/g`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_cancel(2*x**2 - 2, x**2 - 2*x + 1)
+    (2*x + 2, x - 1)
+
+    """
+    K0 = None
+
+    if K.is_Field and K.has_assoc_Ring:
+        K0, K = K, K.get_ring()
+
+        cq, f = dmp_clear_denoms(f, u, K0, K, convert=True)
+        cp, g = dmp_clear_denoms(g, u, K0, K, convert=True)
+    else:
+        cp, cq = K.one, K.one
+
+    _, p, q = dmp_inner_gcd(f, g, u, K)
+
+    if K0 is not None:
+        _, cp, cq = K.cofactors(cp, cq)
+
+        p = dmp_convert(p, u, K, K0)
+        q = dmp_convert(q, u, K, K0)
+
+        K = K0
+
+    p_neg = K.is_negative(dmp_ground_LC(p, u, K))
+    q_neg = K.is_negative(dmp_ground_LC(q, u, K))
+
+    if p_neg and q_neg:
+        p, q = dmp_neg(p, u, K), dmp_neg(q, u, K)
+    elif p_neg:
+        cp, p = -cp, dmp_neg(p, u, K)
+    elif q_neg:
+        cp, q = -cp, dmp_neg(q, u, K)
+
+    if not include:
+        return cp, cq, p, q
+
+    p = dmp_mul_ground(p, cp, u, K)
+    q = dmp_mul_ground(q, cq, u, K)
+
+    return p, q
diff --git a/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/fglmtools.py b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/fglmtools.py
new file mode 100644
index 0000000000000000000000000000000000000000..d68fe5bc2a40741e39b89163d393f7b57e6b1c49
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/fglmtools.py
@@ -0,0 +1,153 @@
+"""Implementation of matrix FGLM Groebner basis conversion algorithm. """
+
+
+from sympy.polys.monomials import monomial_mul, monomial_div
+
+def matrix_fglm(F, ring, O_to):
+    """
+    Converts the reduced Groebner basis ``F`` of a zero-dimensional
+    ideal w.r.t. ``O_from`` to a reduced Groebner basis
+    w.r.t. ``O_to``.
+
+    References
+    ==========
+
+    .. [1] J.C. Faugere, P. Gianni, D. Lazard, T. Mora (1994). Efficient
+           Computation of Zero-dimensional Groebner Bases by Change of
+           Ordering
+    """
+    domain = ring.domain
+    ngens = ring.ngens
+
+    ring_to = ring.clone(order=O_to)
+
+    old_basis = _basis(F, ring)
+    M = _representing_matrices(old_basis, F, ring)
+
+    # V contains the normalforms (wrt O_from) of S
+    S = [ring.zero_monom]
+    V = [[domain.one] + [domain.zero] * (len(old_basis) - 1)]
+    G = []
+
+    L = [(i, 0) for i in range(ngens)]  # (i, j) corresponds to x_i * S[j]
+    L.sort(key=lambda k_l: O_to(_incr_k(S[k_l[1]], k_l[0])), reverse=True)
+    t = L.pop()
+
+    P = _identity_matrix(len(old_basis), domain)
+
+    while True:
+        s = len(S)
+        v = _matrix_mul(M[t[0]], V[t[1]])
+        _lambda = _matrix_mul(P, v)
+
+        if all(_lambda[i] == domain.zero for i in range(s, len(old_basis))):
+            # there is a linear combination of v by V
+            lt = ring.term_new(_incr_k(S[t[1]], t[0]), domain.one)
+            rest = ring.from_dict({S[i]: _lambda[i] for i in range(s)})
+
+            g = (lt - rest).set_ring(ring_to)
+            if g:
+                G.append(g)
+        else:
+            # v is linearly independent from V
+            P = _update(s, _lambda, P)
+            S.append(_incr_k(S[t[1]], t[0]))
+            V.append(v)
+
+            L.extend([(i, s) for i in range(ngens)])
+            L = list(set(L))
+            L.sort(key=lambda k_l: O_to(_incr_k(S[k_l[1]], k_l[0])), reverse=True)
+
+        L = [(k, l) for (k, l) in L if all(monomial_div(_incr_k(S[l], k), g.LM) is None for g in G)]
+
+        if not L:
+            G = [ g.monic() for g in G ]
+            return sorted(G, key=lambda g: O_to(g.LM), reverse=True)
+
+        t = L.pop()
+
+
+def _incr_k(m, k):
+    return tuple(list(m[:k]) + [m[k] + 1] + list(m[k + 1:]))
+
+
+def _identity_matrix(n, domain):
+    M = [[domain.zero]*n for _ in range(n)]
+
+    for i in range(n):
+        M[i][i] = domain.one
+
+    return M
+
+
+def _matrix_mul(M, v):
+    return [sum(row[i] * v[i] for i in range(len(v))) for row in M]
+
+
+def _update(s, _lambda, P):
+    """
+    Update ``P`` such that for the updated `P'` `P' v = e_{s}`.
+    """
+    k = min(j for j in range(s, len(_lambda)) if _lambda[j] != 0)
+
+    for r in range(len(_lambda)):
+        if r != k:
+            P[r] = [P[r][j] - (P[k][j] * _lambda[r]) / _lambda[k] for j in range(len(P[r]))]
+
+    P[k] = [P[k][j] / _lambda[k] for j in range(len(P[k]))]
+    P[k], P[s] = P[s], P[k]
+
+    return P
+
+
+def _representing_matrices(basis, G, ring):
+    r"""
+    Compute the matrices corresponding to the linear maps `m \mapsto
+    x_i m` for all variables `x_i`.
+    """
+    domain = ring.domain
+    u = ring.ngens-1
+
+    def var(i):
+        return tuple([0] * i + [1] + [0] * (u - i))
+
+    def representing_matrix(m):
+        M = [[domain.zero] * len(basis) for _ in range(len(basis))]
+
+        for i, v in enumerate(basis):
+            r = ring.term_new(monomial_mul(m, v), domain.one).rem(G)
+
+            for monom, coeff in r.terms():
+                j = basis.index(monom)
+                M[j][i] = coeff
+
+        return M
+
+    return [representing_matrix(var(i)) for i in range(u + 1)]
+
+
+def _basis(G, ring):
+    r"""
+    Computes a list of monomials which are not divisible by the leading
+    monomials wrt to ``O`` of ``G``. These monomials are a basis of
+    `K[X_1, \ldots, X_n]/(G)`.
+    """
+    order = ring.order
+
+    leading_monomials = [g.LM for g in G]
+    candidates = [ring.zero_monom]
+    basis = []
+
+    while candidates:
+        t = candidates.pop()
+        basis.append(t)
+
+        new_candidates = [_incr_k(t, k) for k in range(ring.ngens)
+            if all(monomial_div(_incr_k(t, k), lmg) is None
+            for lmg in leading_monomials)]
+        candidates.extend(new_candidates)
+        candidates.sort(key=order, reverse=True)
+
+    basis = list(set(basis))
+
+    return sorted(basis, key=order)
diff --git a/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/_dfm.py b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/_dfm.py
new file mode 100644
index 0000000000000000000000000000000000000000..d84fe136e6db146a2570739aaa968ae94473f665
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/_dfm.py
@@ -0,0 +1,898 @@
+#
+# sympy.polys.matrices.dfm
+#
+# This modules defines the DFM class which is a wrapper for dense flint
+# matrices as found in python-flint.
+#
+# As of python-flint 0.4.1 matrices over the following domains can be supported
+# by python-flint:
+#
+#   ZZ: flint.fmpz_mat
+#   QQ: flint.fmpq_mat
+#   GF(p): flint.nmod_mat (p prime and p < ~2**62)
+#
+# The underlying flint library has many more domains, but these are not yet
+# supported by python-flint.
+#
+# The DFM class is a wrapper for the flint matrices and provides a common
+# interface for all supported domains that is interchangeable with the DDM
+# and SDM classes so that DomainMatrix can be used with any as its internal
+# matrix representation.
+#
+
+# TODO:
+#
+# Implement the following methods that are provided by python-flint:
+#
+# - hnf (Hermite normal form)
+# - snf (Smith normal form)
+# - minpoly
+# - is_hnf
+# - is_snf
+# - rank
+#
+# The other types DDM and SDM do not have these methods and the algorithms
+# for hnf, snf and rank are already implemented. Algorithms for minpoly,
+# is_hnf and is_snf would need to be added.
+#
+# Add more methods to python-flint to expose more of Flint's functionality
+# and also to make some of the above methods simpler or more efficient e.g.
+# slicing, fancy indexing etc.
+
+from sympy.external.gmpy import GROUND_TYPES
+from sympy.external.importtools import import_module
+from sympy.utilities.decorator import doctest_depends_on
+
+from sympy.polys.domains import ZZ, QQ
+
+from .exceptions import (
+    DMBadInputError,
+    DMDomainError,
+    DMNonSquareMatrixError,
+    DMNonInvertibleMatrixError,
+    DMRankError,
+    DMShapeError,
+    DMValueError,
+)
+
+
+if GROUND_TYPES != 'flint':
+    __doctest_skip__ = ['*']
+
+
+flint = import_module('flint')
+
+
+__all__ = ['DFM']
+
+
+@doctest_depends_on(ground_types=['flint'])
+class DFM:
+    """
+    Dense FLINT matrix. This class is a wrapper for matrices from python-flint.
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.matrices.dfm import DFM
+    >>> dfm = DFM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    >>> dfm
+    [[1, 2], [3, 4]]
+    >>> dfm.rep
+    [1, 2]
+    [3, 4]
+    >>> type(dfm.rep)  # doctest: +SKIP
+    <class 'flint._flint.fmpz_mat'>
+
+    Usually, the DFM class is not instantiated directly, but is created as the
+    internal representation of :class:`~.DomainMatrix`. When
+    `SYMPY_GROUND_TYPES` is set to `flint` and `python-flint` is installed, the
+    :class:`DFM` class is used automatically as the internal representation of
+    :class:`~.DomainMatrix` in dense format if the domain is supported by
+    python-flint.
+
+    >>> from sympy.polys.matrices.domainmatrix import DM
+    >>> dM = DM([[1, 2], [3, 4]], ZZ)
+    >>> dM.rep
+    [[1, 2], [3, 4]]
+
+    A :class:`~.DomainMatrix` can be converted to :class:`DFM` by calling the
+    :meth:`to_dfm` method:
+
+    >>> dM.to_dfm()
+    [[1, 2], [3, 4]]
+
+    """
+
+    fmt = 'dense'
+    is_DFM = True
+    is_DDM = False
+
+    def __new__(cls, rowslist, shape, domain):
+        """Construct from a nested list."""
+        flint_mat = cls._get_flint_func(domain)
+
+        if 0 not in shape:
+            try:
+                rep = flint_mat(rowslist)
+            except (ValueError, TypeError):
+                raise DMBadInputError(f"Input should be a list of list of {domain}")
+        else:
+            rep = flint_mat(*shape)
+
+        return cls._new(rep, shape, domain)
+
+    @classmethod
+    def _new(cls, rep, shape, domain):
+        """Internal constructor from a flint matrix."""
+        cls._check(rep, shape, domain)
+        obj = object.__new__(cls)
+        obj.rep = rep
+        obj.shape = obj.rows, obj.cols = shape
+        obj.domain = domain
+        return obj
+
+    def _new_rep(self, rep):
+        """Create a new DFM with the same shape and domain but a new rep."""
+        return self._new(rep, self.shape, self.domain)
+
+    @classmethod
+    def _check(cls, rep, shape, domain):
+        repshape = (rep.nrows(), rep.ncols())
+        if repshape != shape:
+            raise DMBadInputError("Shape of rep does not match shape of DFM")
+        if domain == ZZ and not isinstance(rep, flint.fmpz_mat):
+            raise RuntimeError("Rep is not a flint.fmpz_mat")
+        elif domain == QQ and not isinstance(rep, flint.fmpq_mat):
+            raise RuntimeError("Rep is not a flint.fmpq_mat")
+        elif domain not in (ZZ, QQ):
+            raise NotImplementedError("Only ZZ and QQ are supported by DFM")
+
+    @classmethod
+    def _supports_domain(cls, domain):
+        """Return True if the given domain is supported by DFM."""
+        return domain in (ZZ, QQ)
+
+    @classmethod
+    def _get_flint_func(cls, domain):
+        """Return the flint matrix class for the given domain."""
+        if domain == ZZ:
+            return flint.fmpz_mat
+        elif domain == QQ:
+            return flint.fmpq_mat
+        else:
+            raise NotImplementedError("Only ZZ and QQ are supported by DFM")
+
+    @property
+    def _func(self):
+        """Callable to create a flint matrix of the same domain."""
+        return self._get_flint_func(self.domain)
+
+    def __str__(self):
+        """Return ``str(self)``."""
+        return str(self.to_ddm())
+
+    def __repr__(self):
+        """Return ``repr(self)``."""
+        return f'DFM{repr(self.to_ddm())[3:]}'
+
+    def __eq__(self, other):
+        """Return ``self == other``."""
+        if not isinstance(other, DFM):
+            return NotImplemented
+        # Compare domains first because we do *not* want matrices with
+        # different domains to be equal but e.g. a flint fmpz_mat and fmpq_mat
+        # with the same entries will compare equal.
+        return self.domain == other.domain and self.rep == other.rep
+
+    @classmethod
+    def from_list(cls, rowslist, shape, domain):
+        """Construct from a nested list."""
+        return cls(rowslist, shape, domain)
+
+    def to_list(self):
+        """Convert to a nested list."""
+        return self.rep.tolist()
+
+    def copy(self):
+        """Return a copy of self."""
+        return self._new_rep(self._func(self.rep))
+
+    def to_ddm(self):
+        """Convert to a DDM."""
+        return DDM.from_list(self.to_list(), self.shape, self.domain)
+
+    def to_sdm(self):
+        """Convert to a SDM."""
+        return SDM.from_list(self.to_list(), self.shape, self.domain)
+
+    def to_dfm(self):
+        """Return self."""
+        return self
+
+    def to_dfm_or_ddm(self):
+        """
+        Convert to a :class:`DFM`.
+
+        This :class:`DFM` method exists to parallel the :class:`~.DDM` and
+        :class:`~.SDM` methods. For :class:`DFM` it will always return self.
+
+        See Also
+        ========
+
+        to_ddm
+        to_sdm
+        sympy.polys.matrices.domainmatrix.DomainMatrix.to_dfm_or_ddm
+        """
+        return self
+
+    @classmethod
+    def from_ddm(cls, ddm):
+        """Convert from a DDM."""
+        return cls.from_list(ddm.to_list(), ddm.shape, ddm.domain)
+
+    @classmethod
+    def from_list_flat(cls, elements, shape, domain):
+        """Inverse of :meth:`to_list_flat`."""
+        func = cls._get_flint_func(domain)
+        try:
+            rep = func(*shape, elements)
+        except ValueError:
+            raise DMBadInputError(f"Incorrect number of elements for shape {shape}")
+        except TypeError:
+            raise DMBadInputError(f"Input should be a list of {domain}")
+        return cls(rep, shape, domain)
+
+    def to_list_flat(self):
+        """Convert to a flat list."""
+        return self.rep.entries()
+
+    def to_flat_nz(self):
+        """Convert to a flat list of non-zeros."""
+        return self.to_ddm().to_flat_nz()
+
+    @classmethod
+    def from_flat_nz(cls, elements, data, domain):
+        """Inverse of :meth:`to_flat_nz`."""
+        return DDM.from_flat_nz(elements, data, domain).to_dfm()
+
+    def to_dod(self):
+        """Convert to a DOD."""
+        return self.to_ddm().to_dod()
+
+    @classmethod
+    def from_dod(cls, dod, shape, domain):
+        """Inverse of :meth:`to_dod`."""
+        return DDM.from_dod(dod, shape, domain).to_dfm()
+
+    def to_dok(self):
+        """Convert to a DOK."""
+        return self.to_ddm().to_dok()
+
+    @classmethod
+    def from_dok(cls, dok, shape, domain):
+        """Inverse of :math:`to_dod`."""
+        return DDM.from_dok(dok, shape, domain).to_dfm()
+
+    def iter_values(self):
+        """Iterater over the non-zero values of the matrix."""
+        m, n = self.shape
+        rep = self.rep
+        for i in range(m):
+            for j in range(n):
+                repij = rep[i, j]
+                if repij:
+                    yield rep[i, j]
+
+    def iter_items(self):
+        """Iterate over indices and values of nonzero elements of the matrix."""
+        m, n = self.shape
+        rep = self.rep
+        for i in range(m):
+            for j in range(n):
+                repij = rep[i, j]
+                if repij:
+                    yield ((i, j), repij)
+
+    def convert_to(self, domain):
+        """Convert to a new domain."""
+        if domain == self.domain:
+            return self.copy()
+        elif domain == QQ and self.domain == ZZ:
+            return self._new(flint.fmpq_mat(self.rep), self.shape, domain)
+        elif domain == ZZ and self.domain == QQ:
+            # XXX: python-flint has no fmpz_mat.from_fmpq_mat
+            return self.to_ddm().convert_to(domain).to_dfm()
+        else:
+            # It is the callers responsibility to convert to DDM before calling
+            # this method if the domain is not supported by DFM.
+            raise NotImplementedError("Only ZZ and QQ are supported by DFM")
+
+    def getitem(self, i, j):
+        """Get the ``(i, j)``-th entry."""
+        # XXX: flint matrices do not support negative indices
+        # XXX: They also raise ValueError instead of IndexError
+        m, n = self.shape
+        if i < 0:
+            i += m
+        if j < 0:
+            j += n
+        try:
+            return self.rep[i, j]
+        except ValueError:
+            raise IndexError(f"Invalid indices ({i}, {j}) for Matrix of shape {self.shape}")
+
+    def setitem(self, i, j, value):
+        """Set the ``(i, j)``-th entry."""
+        # XXX: flint matrices do not support negative indices
+        # XXX: They also raise ValueError instead of IndexError
+        m, n = self.shape
+        if i < 0:
+            i += m
+        if j < 0:
+            j += n
+        try:
+            self.rep[i, j] = value
+        except ValueError:
+            raise IndexError(f"Invalid indices ({i}, {j}) for Matrix of shape {self.shape}")
+
+    def _extract(self, i_indices, j_indices):
+        """Extract a submatrix with no checking."""
+        # Indices must be positive and in range.
+        M = self.rep
+        lol = [[M[i, j] for j in j_indices] for i in i_indices]
+        shape = (len(i_indices), len(j_indices))
+        return self.from_list(lol, shape, self.domain)
+
+    def extract(self, rowslist, colslist):
+        """Extract a submatrix."""
+        # XXX: flint matrices do not support fancy indexing or negative indices
+        #
+        # Check and convert negative indices before calling _extract.
+        m, n = self.shape
+
+        new_rows = []
+        new_cols = []
+
+        for i in rowslist:
+            if i < 0:
+                i_pos = i + m
+            else:
+                i_pos = i
+            if not 0 <= i_pos < m:
+                raise IndexError(f"Invalid row index {i} for Matrix of shape {self.shape}")
+            new_rows.append(i_pos)
+
+        for j in colslist:
+            if j < 0:
+                j_pos = j + n
+            else:
+                j_pos = j
+            if not 0 <= j_pos < n:
+                raise IndexError(f"Invalid column index {j} for Matrix of shape {self.shape}")
+            new_cols.append(j_pos)
+
+        return self._extract(new_rows, new_cols)
+
+    def extract_slice(self, rowslice, colslice):
+        """Slice a DFM."""
+        # XXX: flint matrices do not support slicing
+        m, n = self.shape
+        i_indices = range(m)[rowslice]
+        j_indices = range(n)[colslice]
+        return self._extract(i_indices, j_indices)
+
+    def neg(self):
+        """Negate a DFM matrix."""
+        return self._new_rep(-self.rep)
+
+    def add(self, other):
+        """Add two DFM matrices."""
+        return self._new_rep(self.rep + other.rep)
+
+    def sub(self, other):
+        """Subtract two DFM matrices."""
+        return self._new_rep(self.rep - other.rep)
+
+    def mul(self, other):
+        """Multiply a DFM matrix from the right by a scalar."""
+        return self._new_rep(self.rep * other)
+
+    def rmul(self, other):
+        """Multiply a DFM matrix from the left by a scalar."""
+        return self._new_rep(other * self.rep)
+
+    def mul_elementwise(self, other):
+        """Elementwise multiplication of two DFM matrices."""
+        # XXX: flint matrices do not support elementwise multiplication
+        return self.to_ddm().mul_elementwise(other.to_ddm()).to_dfm()
+
+    def matmul(self, other):
+        """Multiply two DFM matrices."""
+        shape = (self.rows, other.cols)
+        return self._new(self.rep * other.rep, shape, self.domain)
+
+    # XXX: For the most part DomainMatrix does not expect DDM, SDM, or DFM to
+    # have arithmetic operators defined. The only exception is negation.
+    # Perhaps that should be removed.
+
+    def __neg__(self):
+        """Negate a DFM matrix."""
+        return self.neg()
+
+    @classmethod
+    def zeros(cls, shape, domain):
+        """Return a zero DFM matrix."""
+        func = cls._get_flint_func(domain)
+        return cls._new(func(*shape), shape, domain)
+
+    # XXX: flint matrices do not have anything like ones or eye
+    # In the methods below we convert to DDM and then back to DFM which is
+    # probably about as efficient as implementing these methods directly.
+
+    @classmethod
+    def ones(cls, shape, domain):
+        """Return a one DFM matrix."""
+        # XXX: flint matrices do not have anything like ones
+        return DDM.ones(shape, domain).to_dfm()
+
+    @classmethod
+    def eye(cls, n, domain):
+        """Return the identity matrix of size n."""
+        # XXX: flint matrices do not have anything like eye
+        return DDM.eye(n, domain).to_dfm()
+
+    @classmethod
+    def diag(cls, elements, domain):
+        """Return a diagonal matrix."""
+        return DDM.diag(elements, domain).to_dfm()
+
+    def applyfunc(self, func, domain):
+        """Apply a function to each entry of a DFM matrix."""
+        return self.to_ddm().applyfunc(func, domain).to_dfm()
+
+    def transpose(self):
+        """Transpose a DFM matrix."""
+        return self._new(self.rep.transpose(), (self.cols, self.rows), self.domain)
+
+    def hstack(self, *others):
+        """Horizontally stack matrices."""
+        return self.to_ddm().hstack(*[o.to_ddm() for o in others]).to_dfm()
+
+    def vstack(self, *others):
+        """Vertically stack matrices."""
+        return self.to_ddm().vstack(*[o.to_ddm() for o in others]).to_dfm()
+
+    def diagonal(self):
+        """Return the diagonal of a DFM matrix."""
+        M = self.rep
+        m, n = self.shape
+        return [M[i, i] for i in range(min(m, n))]
+
+    def is_upper(self):
+        """Return ``True`` if the matrix is upper triangular."""
+        M = self.rep
+        for i in range(self.rows):
+            for j in range(i):
+                if M[i, j]:
+                    return False
+        return True
+
+    def is_lower(self):
+        """Return ``True`` if the matrix is lower triangular."""
+        M = self.rep
+        for i in range(self.rows):
+            for j in range(i + 1, self.cols):
+                if M[i, j]:
+                    return False
+        return True
+
+    def is_diagonal(self):
+        """Return ``True`` if the matrix is diagonal."""
+        return self.is_upper() and self.is_lower()
+
+    def is_zero_matrix(self):
+        """Return ``True`` if the matrix is the zero matrix."""
+        M = self.rep
+        for i in range(self.rows):
+            for j in range(self.cols):
+                if M[i, j]:
+                    return False
+        return True
+
+    def nnz(self):
+        """Return the number of non-zero elements in the matrix."""
+        return self.to_ddm().nnz()
+
+    def scc(self):
+        """Return the strongly connected components of the matrix."""
+        return self.to_ddm().scc()
+
+    @doctest_depends_on(ground_types='flint')
+    def det(self):
+        """
+        Compute the determinant of the matrix using FLINT.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> M = Matrix([[1, 2], [3, 4]])
+        >>> dfm = M.to_DM().to_dfm()
+        >>> dfm
+        [[1, 2], [3, 4]]
+        >>> dfm.det()
+        -2
+
+        Notes
+        =====
+
+        Calls the ``.det()`` method of the underlying FLINT matrix.
+
+        For :ref:`ZZ` or :ref:`QQ` this calls ``fmpz_mat_det`` or
+        ``fmpq_mat_det`` respectively.
+
+        At the time of writing the implementation of ``fmpz_mat_det`` uses one
+        of several algorithms depending on the size of the matrix and bit size
+        of the entries. The algorithms used are:
+
+        - Cofactor for very small (up to 4x4) matrices.
+        - Bareiss for small (up to 25x25) matrices.
+        - Modular algorithms for larger matrices (up to 60x60) or for larger
+          matrices with large bit sizes.
+        - Modular "accelerated" for larger matrices (60x60 upwards) if the bit
+          size is smaller than the dimensions of the matrix.
+
+        The implementation of ``fmpq_mat_det`` clears denominators from each
+        row (not the whole matrix) and then calls ``fmpz_mat_det`` and divides
+        by the product of the denominators.
+
+        See Also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.det
+            Higher level interface to compute the determinant of a matrix.
+        """
+        # XXX: At least the first three algorithms described above should also
+        # be implemented in the pure Python DDM and SDM classes which at the
+        # time of writng just use Bareiss for all matrices and domains.
+        # Probably in Python the thresholds would be different though.
+        return self.rep.det()
+
+    @doctest_depends_on(ground_types='flint')
+    def charpoly(self):
+        """
+        Compute the characteristic polynomial of the matrix using FLINT.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> M = Matrix([[1, 2], [3, 4]])
+        >>> dfm = M.to_DM().to_dfm()  # need ground types = 'flint'
+        >>> dfm
+        [[1, 2], [3, 4]]
+        >>> dfm.charpoly()
+        [1, -5, -2]
+
+        Notes
+        =====
+
+        Calls the ``.charpoly()`` method of the underlying FLINT matrix.
+
+        For :ref:`ZZ` or :ref:`QQ` this calls ``fmpz_mat_charpoly`` or
+        ``fmpq_mat_charpoly`` respectively.
+
+        At the time of writing the implementation of ``fmpq_mat_charpoly``
+        clears a denominator from the whole matrix and then calls
+        ``fmpz_mat_charpoly``. The coefficients of the characteristic
+        polynomial are then multiplied by powers of the denominator.
+
+        The ``fmpz_mat_charpoly`` method uses a modular algorithm with CRT
+        reconstruction. The modular algorithm uses ``nmod_mat_charpoly`` which
+        uses Berkowitz for small matrices and non-prime moduli or otherwise
+        the Danilevsky method.
+
+        See Also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.charpoly
+            Higher level interface to compute the characteristic polynomial of
+            a matrix.
+        """
+        # FLINT polynomial coefficients are in reverse order compared to SymPy.
+        return self.rep.charpoly().coeffs()[::-1]
+
+    @doctest_depends_on(ground_types='flint')
+    def inv(self):
+        """
+        Compute the inverse of a matrix using FLINT.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, QQ
+        >>> M = Matrix([[1, 2], [3, 4]])
+        >>> dfm = M.to_DM().to_dfm().convert_to(QQ)
+        >>> dfm
+        [[1, 2], [3, 4]]
+        >>> dfm.inv()
+        [[-2, 1], [3/2, -1/2]]
+        >>> dfm.matmul(dfm.inv())
+        [[1, 0], [0, 1]]
+
+        Notes
+        =====
+
+        Calls the ``.inv()`` method of the underlying FLINT matrix.
+
+        For now this will raise an error if the domain is :ref:`ZZ` but will
+        use the FLINT method for :ref:`QQ`.
+
+        The FLINT methods for :ref:`ZZ` and :ref:`QQ` are ``fmpz_mat_inv`` and
+        ``fmpq_mat_inv`` respectively. The ``fmpz_mat_inv`` method computes an
+        inverse with denominator. This is implemented by calling
+        ``fmpz_mat_solve`` (see notes in :meth:`lu_solve` about the algorithm).
+
+        The ``fmpq_mat_inv`` method clears denominators from each row and then
+        multiplies those into the rhs identity matrix before calling
+        ``fmpz_mat_solve``.
+
+        See Also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.inv
+            Higher level method for computing the inverse of a matrix.
+        """
+        # TODO: Implement similar algorithms for DDM and SDM.
+        #
+        # XXX: The flint fmpz_mat and fmpq_mat inv methods both return fmpq_mat
+        # by default. The fmpz_mat method has an optional argument to return
+        # fmpz_mat instead for unimodular matrices.
+        #
+        # The convention in DomainMatrix is to raise an error if the matrix is
+        # not over a field regardless of whether the matrix is invertible over
+        # its domain or over any associated field. Maybe DomainMatrix.inv
+        # should be changed to always return a matrix over an associated field
+        # except with a unimodular argument for returning an inverse over a
+        # ring if possible.
+        #
+        # For now we follow the existing DomainMatrix convention...
+        K = self.domain
+        m, n = self.shape
+
+        if m != n:
+            raise DMNonSquareMatrixError("cannot invert a non-square matrix")
+
+        if K == ZZ:
+            raise DMDomainError("field expected, got %s" % K)
+        elif K == QQ:
+            try:
+                return self._new_rep(self.rep.inv())
+            except ZeroDivisionError:
+                raise DMNonInvertibleMatrixError("matrix is not invertible")
+        else:
+            # If more domains are added for DFM then we will need to consider
+            # what happens here.
+            raise NotImplementedError("DFM.inv() is not implemented for %s" % K)
+
+    def lu(self):
+        """Return the LU decomposition of the matrix."""
+        L, U, swaps = self.to_ddm().lu()
+        return L.to_dfm(), U.to_dfm(), swaps
+
+    # XXX: The lu_solve function should be renamed to solve. Whether or not it
+    # uses an LU decomposition is an implementation detail. A method called
+    # lu_solve would make sense for a situation in which an LU decomposition is
+    # reused several times to solve iwth different rhs but that would imply a
+    # different call signature.
+    #
+    # The underlying python-flint method has an algorithm= argument so we could
+    # use that and have e.g. solve_lu and solve_modular or perhaps also a
+    # method= argument to choose between the two. Flint itself has more
+    # possible algorithms to choose from than are exposed by python-flint.
+
+    @doctest_depends_on(ground_types='flint')
+    def lu_solve(self, rhs):
+        """
+        Solve a matrix equation using FLINT.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, QQ
+        >>> M = Matrix([[1, 2], [3, 4]])
+        >>> dfm = M.to_DM().to_dfm().convert_to(QQ)
+        >>> dfm
+        [[1, 2], [3, 4]]
+        >>> rhs = Matrix([1, 2]).to_DM().to_dfm().convert_to(QQ)
+        >>> dfm.lu_solve(rhs)
+        [[0], [1/2]]
+
+        Notes
+        =====
+
+        Calls the ``.solve()`` method of the underlying FLINT matrix.
+
+        For now this will raise an error if the domain is :ref:`ZZ` but will
+        use the FLINT method for :ref:`QQ`.
+
+        The FLINT methods for :ref:`ZZ` and :ref:`QQ` are ``fmpz_mat_solve``
+        and ``fmpq_mat_solve`` respectively. The ``fmpq_mat_solve`` method
+        uses one of two algorithms:
+
+        - For small matrices (<25 rows) it clears denominators between the
+          matrix and rhs and uses ``fmpz_mat_solve``.
+        - For larger matrices it uses ``fmpq_mat_solve_dixon`` which is a
+          modular approach with CRT reconstruction over :ref:`QQ`.
+
+        The ``fmpz_mat_solve`` method uses one of four algorithms:
+
+        - For very small (<= 3x3) matrices it uses a Cramer's rule.
+        - For small (<= 15x15) matrices it uses a fraction-free LU solve.
+        - Otherwise it uses either Dixon or another multimodular approach.
+
+        See Also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.lu_solve
+            Higher level interface to solve a matrix equation.
+        """
+        if not self.domain == rhs.domain:
+            raise DMDomainError("Domains must match: %s != %s" % (self.domain, rhs.domain))
+
+        # XXX: As for inv we should consider whether to return a matrix over
+        # over an associated field or attempt to find a solution in the ring.
+        # For now we follow the existing DomainMatrix convention...
+        if not self.domain.is_Field:
+            raise DMDomainError("Field expected, got %s" % self.domain)
+
+        m, n = self.shape
+        j, k = rhs.shape
+        if m != j:
+            raise DMShapeError("Matrix size mismatch: %s * %s vs %s * %s" % (m, n, j, k))
+        sol_shape = (n, k)
+
+        # XXX: The Flint solve method only handles square matrices. Probably
+        # Flint has functions that could be used to solve non-square systems
+        # but they are not exposed in python-flint yet. Alternatively we could
+        # put something here using the features that are available like rref.
+        if m != n:
+            return self.to_ddm().lu_solve(rhs.to_ddm()).to_dfm()
+
+        try:
+            sol = self.rep.solve(rhs.rep)
+        except ZeroDivisionError:
+            raise DMNonInvertibleMatrixError("Matrix det == 0; not invertible.")
+
+        return self._new(sol, sol_shape, self.domain)
+
+    def nullspace(self):
+        """Return a basis for the nullspace of the matrix."""
+        # Code to compute nullspace using flint:
+        #
+        # V, nullity = self.rep.nullspace()
+        # V_dfm = self._new_rep(V)._extract(range(self.rows), range(nullity))
+        #
+        # XXX: That gives the nullspace but does not give us nonpivots. So we
+        # use the slower DDM method anyway. It would be better to change the
+        # signature of the nullspace method to not return nonpivots.
+        #
+        # XXX: Also python-flint exposes a nullspace method for fmpz_mat but
+        # not for fmpq_mat. This is the reverse of the situation for DDM etc
+        # which only allow nullspace over a field. The nullspace method for
+        # DDM, SDM etc should be changed to allow nullspace over ZZ as well.
+        # The DomainMatrix nullspace method does allow the domain to be a ring
+        # but does not directly call the lower-level nullspace methods and uses
+        # rref_den instead. Nullspace methods should also be added to all
+        # matrix types in python-flint.
+        ddm, nonpivots = self.to_ddm().nullspace()
+        return ddm.to_dfm(), nonpivots
+
+    def nullspace_from_rref(self, pivots=None):
+        """Return a basis for the nullspace of the matrix."""
+        # XXX: Use the flint nullspace method!!!
+        sdm, nonpivots = self.to_sdm().nullspace_from_rref(pivots=pivots)
+        return sdm.to_dfm(), nonpivots
+
+    def particular(self):
+        """Return a particular solution to the system."""
+        return self.to_ddm().particular().to_dfm()
+
+    def _lll(self, transform=False, delta=0.99, eta=0.51, rep='zbasis', gram='approx'):
+        """Call the fmpz_mat.lll() method but check rank to avoid segfaults."""
+
+        # XXX: There are tests that pass e.g. QQ(5,6) for delta. That fails
+        # with a TypeError in flint because if QQ is fmpq then conversion with
+        # float fails. We handle that here but there are two better fixes:
+        #
+        # - Make python-flint's fmpq convert with float(x)
+        # - Change the tests because delta should just be a float.
+
+        def to_float(x):
+            if QQ.of_type(x):
+                return float(x.numerator) / float(x.denominator)
+            else:
+                return float(x)
+
+        delta = to_float(delta)
+        eta = to_float(eta)
+
+        if not 0.25 < delta < 1:
+            raise DMValueError("delta must be between 0.25 and 1")
+
+        # XXX: The flint lll method segfaults if the matrix is not full rank.
+        m, n = self.shape
+        if self.rep.rank() != m:
+            raise DMRankError("Matrix must have full row rank for Flint LLL.")
+
+        # Actually call the flint method.
+        return self.rep.lll(transform=transform, delta=delta, eta=eta, rep=rep, gram=gram)
+
+    @doctest_depends_on(ground_types='flint')
+    def lll(self, delta=0.75):
+        """Compute LLL-reduced basis using FLINT.
+
+        See :meth:`lll_transform` for more information.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> M = Matrix([[1, 2, 3], [4, 5, 6]])
+        >>> M.to_DM().to_dfm().lll()
+        [[2, 1, 0], [-1, 1, 3]]
+
+        See Also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.lll
+            Higher level interface to compute LLL-reduced basis.
+        lll_transform
+            Compute LLL-reduced basis and transform matrix.
+        """
+        if self.domain != ZZ:
+            raise DMDomainError("ZZ expected, got %s" % self.domain)
+        elif self.rows > self.cols:
+            raise DMShapeError("Matrix must not have more rows than columns.")
+
+        rep = self._lll(delta=delta)
+        return self._new_rep(rep)
+
+    @doctest_depends_on(ground_types='flint')
+    def lll_transform(self, delta=0.75):
+        """Compute LLL-reduced basis and transform using FLINT.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> M = Matrix([[1, 2, 3], [4, 5, 6]]).to_DM().to_dfm()
+        >>> M_lll, T = M.lll_transform()
+        >>> M_lll
+        [[2, 1, 0], [-1, 1, 3]]
+        >>> T
+        [[-2, 1], [3, -1]]
+        >>> T.matmul(M) == M_lll
+        True
+
+        See Also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.lll
+            Higher level interface to compute LLL-reduced basis.
+        lll
+            Compute LLL-reduced basis without transform matrix.
+        """
+        if self.domain != ZZ:
+            raise DMDomainError("ZZ expected, got %s" % self.domain)
+        elif self.rows > self.cols:
+            raise DMShapeError("Matrix must not have more rows than columns.")
+
+        rep, T = self._lll(transform=True, delta=delta)
+        basis = self._new_rep(rep)
+        T_dfm = self._new(T, (self.rows, self.rows), self.domain)
+        return basis, T_dfm
+
+
+# Avoid circular imports
+from sympy.polys.matrices.ddm import DDM
+from sympy.polys.matrices.ddm import SDM
diff --git a/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/_typing.py b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/_typing.py
new file mode 100644
index 0000000000000000000000000000000000000000..fc7c3b601fe85d591ddf853acbf33f5bba64b11c
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/_typing.py
@@ -0,0 +1,16 @@
+from typing import TypeVar, Protocol
+
+
+T = TypeVar('T')
+
+
+class RingElement(Protocol):
+    """A ring element.
+
+    Must support ``+``, ``-``, ``*``, ``**`` and ``-``.
+    """
+    def __add__(self: T, other: T, /) -> T: ...
+    def __sub__(self: T, other: T, /) -> T: ...
+    def __mul__(self: T, other: T, /) -> T: ...
+    def __pow__(self: T, other: int, /) -> T: ...
+    def __neg__(self: T, /) -> T: ...
diff --git a/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/dense.py b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/dense.py
new file mode 100644
index 0000000000000000000000000000000000000000..47ab2d6897c6d9f3781af23ccb68f96f15c7e859
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/dense.py
@@ -0,0 +1,824 @@
+"""
+
+Module for the ddm_* routines for operating on a matrix in list of lists
+matrix representation.
+
+These routines are used internally by the DDM class which also provides a
+friendlier interface for them. The idea here is to implement core matrix
+routines in a way that can be applied to any simple list representation
+without the need to use any particular matrix class. For example we can
+compute the RREF of a matrix like:
+
+    >>> from sympy.polys.matrices.dense import ddm_irref
+    >>> M = [[1, 2, 3], [4, 5, 6]]
+    >>> pivots = ddm_irref(M)
+    >>> M
+    [[1.0, 0.0, -1.0], [0, 1.0, 2.0]]
+
+These are lower-level routines that work mostly in place.The routines at this
+level should not need to know what the domain of the elements is but should
+ideally document what operations they will use and what functions they need to
+be provided with.
+
+The next-level up is the DDM class which uses these routines but wraps them up
+with an interface that handles copying etc and keeps track of the Domain of
+the elements of the matrix:
+
+    >>> from sympy.polys.domains import QQ
+    >>> from sympy.polys.matrices.ddm import DDM
+    >>> M = DDM([[QQ(1), QQ(2), QQ(3)], [QQ(4), QQ(5), QQ(6)]], (2, 3), QQ)
+    >>> M
+    [[1, 2, 3], [4, 5, 6]]
+    >>> Mrref, pivots = M.rref()
+    >>> Mrref
+    [[1, 0, -1], [0, 1, 2]]
+
+"""
+from __future__ import annotations
+from operator import mul
+from .exceptions import (
+    DMShapeError,
+    DMDomainError,
+    DMNonInvertibleMatrixError,
+    DMNonSquareMatrixError,
+)
+from typing import Sequence, TypeVar
+from sympy.polys.matrices._typing import RingElement
+
+
+#: Type variable for the elements of the matrix
+T = TypeVar('T')
+
+#: Type variable for the elements of the matrix that are in a ring
+R = TypeVar('R', bound=RingElement)
+
+
+def ddm_transpose(matrix: Sequence[Sequence[T]]) -> list[list[T]]:
+    """matrix transpose"""
+    return list(map(list, zip(*matrix)))
+
+
+def ddm_iadd(a: list[list[R]], b: Sequence[Sequence[R]]) -> None:
+    """a += b"""
+    for ai, bi in zip(a, b):
+        for j, bij in enumerate(bi):
+            ai[j] += bij
+
+
+def ddm_isub(a: list[list[R]], b: Sequence[Sequence[R]]) -> None:
+    """a -= b"""
+    for ai, bi in zip(a, b):
+        for j, bij in enumerate(bi):
+            ai[j] -= bij
+
+
+def ddm_ineg(a: list[list[R]]) -> None:
+    """a <-- -a"""
+    for ai in a:
+        for j, aij in enumerate(ai):
+            ai[j] = -aij
+
+
+def ddm_imul(a: list[list[R]], b: R) -> None:
+    """a <-- a*b"""
+    for ai in a:
+        for j, aij in enumerate(ai):
+            ai[j] = aij * b
+
+
+def ddm_irmul(a: list[list[R]], b: R) -> None:
+    """a <-- b*a"""
+    for ai in a:
+        for j, aij in enumerate(ai):
+            ai[j] = b * aij
+
+
+def ddm_imatmul(
+    a: list[list[R]], b: Sequence[Sequence[R]], c: Sequence[Sequence[R]]
+) -> None:
+    """a += b @ c"""
+    cT = list(zip(*c))
+
+    for bi, ai in zip(b, a):
+        for j, cTj in enumerate(cT):
+            ai[j] = sum(map(mul, bi, cTj), ai[j])
+
+
+def ddm_irref(a, _partial_pivot=False):
+    """In-place reduced row echelon form of a matrix.
+
+    Compute the reduced row echelon form of $a$. Modifies $a$ in place and
+    returns a list of the pivot columns.
+
+    Uses naive Gauss-Jordan elimination in the ground domain which must be a
+    field.
+
+    This routine is only really suitable for use with simple field domains like
+    :ref:`GF(p)`, :ref:`QQ` and :ref:`QQ(a)` although even for :ref:`QQ` with
+    larger matrices it is possibly more efficient to use fraction free
+    approaches.
+
+    This method is not suitable for use with rational function fields
+    (:ref:`K(x)`) because the elements will blowup leading to costly gcd
+    operations. In this case clearing denominators and using fraction free
+    approaches is likely to be more efficient.
+
+    For inexact numeric domains like :ref:`RR` and :ref:`CC` pass
+    ``_partial_pivot=True`` to use partial pivoting to control rounding errors.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.matrices.dense import ddm_irref
+    >>> from sympy import QQ
+    >>> M = [[QQ(1), QQ(2), QQ(3)], [QQ(4), QQ(5), QQ(6)]]
+    >>> pivots = ddm_irref(M)
+    >>> M
+    [[1, 0, -1], [0, 1, 2]]
+    >>> pivots
+    [0, 1]
+
+    See Also
+    ========
+
+    sympy.polys.matrices.domainmatrix.DomainMatrix.rref
+        Higher level interface to this routine.
+    ddm_irref_den
+        The fraction free version of this routine.
+    sdm_irref
+        A sparse version of this routine.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Row_echelon_form#Reduced_row_echelon_form
+    """
+    # We compute aij**-1 below and then use multiplication instead of division
+    # in the innermost loop. The domain here is a field so either operation is
+    # defined. There are significant performance differences for some domains
+    # though. In the case of e.g. QQ or QQ(x) inversion is free but
+    # multiplication and division have the same cost so it makes no difference.
+    # In cases like GF(p), QQ<sqrt(2)>, RR or CC though multiplication is
+    # faster than division so reusing a precomputed inverse for many
+    # multiplications can be a lot faster. The biggest win is QQ<a> when
+    # deg(minpoly(a)) is large.
+    #
+    # With domains like QQ(x) this can perform badly for other reasons.
+    # Typically the initial matrix has simple denominators and the
+    # fraction-free approach with exquo (ddm_irref_den) will preserve that
+    # property throughout. The method here causes denominator blowup leading to
+    # expensive gcd reductions in the intermediate expressions. With many
+    # generators like QQ(x,y,z,...) this is extremely bad.
+    #
+    # TODO: Use a nontrivial pivoting strategy to control intermediate
+    # expression growth. Rearranging rows and/or columns could defer the most
+    # complicated elements until the end. If the first pivot is a
+    # complicated/large element then the first round of reduction will
+    # immediately introduce expression blowup across the whole matrix.
+
+    # a is (m x n)
+    m = len(a)
+    if not m:
+        return []
+    n = len(a[0])
+
+    i = 0
+    pivots = []
+
+    for j in range(n):
+        # Proper pivoting should be used for all domains for performance
+        # reasons but it is only strictly needed for RR and CC (and possibly
+        # other domains like RR(x)). This path is used by DDM.rref() if the
+        # domain is RR or CC. It uses partial (row) pivoting based on the
+        # absolute value of the pivot candidates.
+        if _partial_pivot:
+            ip = max(range(i, m), key=lambda ip: abs(a[ip][j]))
+            a[i], a[ip] = a[ip], a[i]
+
+        # pivot
+        aij = a[i][j]
+
+        # zero-pivot
+        if not aij:
+            for ip in range(i+1, m):
+                aij = a[ip][j]
+                # row-swap
+                if aij:
+                    a[i], a[ip] = a[ip], a[i]
+                    break
+            else:
+                # next column
+                continue
+
+        # normalise row
+        ai = a[i]
+        aijinv = aij**-1
+        for l in range(j, n):
+            ai[l] *= aijinv # ai[j] = one
+
+        # eliminate above and below to the right
+        for k, ak in enumerate(a):
+            if k == i or not ak[j]:
+                continue
+            akj = ak[j]
+            ak[j] -= akj # ak[j] = zero
+            for l in range(j+1, n):
+                ak[l] -= akj * ai[l]
+
+        # next row
+        pivots.append(j)
+        i += 1
+
+        # no more rows?
+        if i >= m:
+            break
+
+    return pivots
+
+
+def ddm_irref_den(a, K):
+    """a  <--  rref(a); return (den, pivots)
+
+    Compute the fraction-free reduced row echelon form (RREF) of $a$. Modifies
+    $a$ in place and returns a tuple containing the denominator of the RREF and
+    a list of the pivot columns.
+
+    Explanation
+    ===========
+
+    The algorithm used is the fraction-free version of Gauss-Jordan elimination
+    described as FFGJ in [1]_. Here it is modified to handle zero or missing
+    pivots and to avoid redundant arithmetic.
+
+    The domain $K$ must support exact division (``K.exquo``) but does not need
+    to be a field. This method is suitable for most exact rings and fields like
+    :ref:`ZZ`, :ref:`QQ` and :ref:`QQ(a)`. In the case of :ref:`QQ` or
+    :ref:`K(x)` it might be more efficient to clear denominators and use
+    :ref:`ZZ` or :ref:`K[x]` instead.
+
+    For inexact domains like :ref:`RR` and :ref:`CC` use ``ddm_irref`` instead.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.matrices.dense import ddm_irref_den
+    >>> from sympy import ZZ, Matrix
+    >>> M = [[ZZ(1), ZZ(2), ZZ(3)], [ZZ(4), ZZ(5), ZZ(6)]]
+    >>> den, pivots = ddm_irref_den(M, ZZ)
+    >>> M
+    [[-3, 0, 3], [0, -3, -6]]
+    >>> den
+    -3
+    >>> pivots
+    [0, 1]
+    >>> Matrix(M).rref()[0]
+    Matrix([
+    [1, 0, -1],
+    [0, 1,  2]])
+
+    See Also
+    ========
+
+    ddm_irref
+        A version of this routine that uses field division.
+    sdm_irref
+        A sparse version of :func:`ddm_irref`.
+    sdm_rref_den
+        A sparse version of :func:`ddm_irref_den`.
+    sympy.polys.matrices.domainmatrix.DomainMatrix.rref_den
+        Higher level interface.
+
+    References
+    ==========
+
+    .. [1] Fraction-free algorithms for linear and polynomial equations.
+        George C. Nakos , Peter R. Turner , Robert M. Williams.
+        https://dl.acm.org/doi/10.1145/271130.271133
+    """
+    #
+    # A simpler presentation of this algorithm is given in [1]:
+    #
+    # Given an n x n matrix A and n x 1 matrix b:
+    #
+    #   for i in range(n):
+    #       if i != 0:
+    #           d = a[i-1][i-1]
+    #       for j in range(n):
+    #           if j == i:
+    #               continue
+    #           b[j] = a[i][i]*b[j] - a[j][i]*b[i]
+    #           for k in range(n):
+    #               a[j][k] = a[i][i]*a[j][k] - a[j][i]*a[i][k]
+    #               if i != 0:
+    #                   a[j][k] /= d
+    #
+    # Our version here is a bit more complicated because:
+    #
+    #  1. We use row-swaps to avoid zero pivots.
+    #  2. We allow for some columns to be missing pivots.
+    #  3. We avoid a lot of redundant arithmetic.
+    #
+    # TODO: Use a non-trivial pivoting strategy. Even just row swapping makes a
+    # big difference to performance if e.g. the upper-left entry of the matrix
+    # is a huge polynomial.
+
+    # a is (m x n)
+    m = len(a)
+    if not m:
+        return K.one, []
+    n = len(a[0])
+
+    d = None
+    pivots = []
+    no_pivots = []
+
+    # i, j will be the row and column indices of the current pivot
+    i = 0
+    for j in range(n):
+        # next pivot?
+        aij = a[i][j]
+
+        # swap rows if zero
+        if not aij:
+            for ip in range(i+1, m):
+                aij = a[ip][j]
+                # row-swap
+                if aij:
+                    a[i], a[ip] = a[ip], a[i]
+                    break
+            else:
+                # go to next column
+                no_pivots.append(j)
+                continue
+
+        # Now aij is the pivot and i,j are the row and column. We need to clear
+        # the column above and below but we also need to keep track of the
+        # denominator of the RREF which means also multiplying everything above
+        # and to the left by the current pivot aij and dividing by d (which we
+        # multiplied everything by in the previous iteration so this is an
+        # exact division).
+        #
+        # First handle the upper left corner which is usually already diagonal
+        # with all diagonal entries equal to the current denominator but there
+        # can be other non-zero entries in any column that has no pivot.
+
+        # Update previous pivots in the matrix
+        if pivots:
+            pivot_val = aij * a[0][pivots[0]]
+            # Divide out the common factor
+            if d is not None:
+                pivot_val = K.exquo(pivot_val, d)
+
+            # Could defer this until the end but it is pretty cheap and
+            # helps when debugging.
+            for ip, jp in enumerate(pivots):
+                a[ip][jp] = pivot_val
+
+        # Update columns without pivots
+        for jnp in no_pivots:
+            for ip in range(i):
+                aijp = a[ip][jnp]
+                if aijp:
+                    aijp *= aij
+                    if d is not None:
+                        aijp = K.exquo(aijp, d)
+                    a[ip][jnp] = aijp
+
+        # Eliminate above, below and to the right as in ordinary division free
+        # Gauss-Jordan elmination except also dividing out d from every entry.
+
+        for jp, aj in enumerate(a):
+
+            # Skip the current row
+            if jp == i:
+                continue
+
+            # Eliminate to the right in all rows
+            for kp in range(j+1, n):
+                ajk = aij * aj[kp] - aj[j] * a[i][kp]
+                if d is not None:
+                    ajk = K.exquo(ajk, d)
+                aj[kp] = ajk
+
+            # Set to zero above and below the pivot
+            aj[j] = K.zero
+
+        # next row
+        pivots.append(j)
+        i += 1
+
+        # no more rows left?
+        if i >= m:
+            break
+
+        if not K.is_one(aij):
+            d = aij
+        else:
+            d = None
+
+    if not pivots:
+        denom = K.one
+    else:
+        denom = a[0][pivots[0]]
+
+    return denom, pivots
+
+
+def ddm_idet(a, K):
+    """a  <--  echelon(a); return det
+
+    Explanation
+    ===========
+
+    Compute the determinant of $a$ using the Bareiss fraction-free algorithm.
+    The matrix $a$ is modified in place. Its diagonal elements are the
+    determinants of the leading principal minors. The determinant of $a$ is
+    returned.
+
+    The domain $K$ must support exact division (``K.exquo``). This method is
+    suitable for most exact rings and fields like :ref:`ZZ`, :ref:`QQ` and
+    :ref:`QQ(a)` but not for inexact domains like :ref:`RR` and :ref:`CC`.
+
+    Examples
+    ========
+
+    >>> from sympy import ZZ
+    >>> from sympy.polys.matrices.ddm import ddm_idet
+    >>> a = [[ZZ(1), ZZ(2), ZZ(3)], [ZZ(4), ZZ(5), ZZ(6)], [ZZ(7), ZZ(8), ZZ(9)]]
+    >>> a
+    [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+    >>> ddm_idet(a, ZZ)
+    0
+    >>> a
+    [[1, 2, 3], [4, -3, -6], [7, -6, 0]]
+    >>> [a[i][i] for i in range(len(a))]
+    [1, -3, 0]
+
+    See Also
+    ========
+
+    sympy.polys.matrices.domainmatrix.DomainMatrix.det
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Bareiss_algorithm
+    .. [2] https://www.math.usm.edu/perry/Research/Thesis_DRL.pdf
+    """
+    # Bareiss algorithm
+    # https://www.math.usm.edu/perry/Research/Thesis_DRL.pdf
+
+    # a is (m x n)
+    m = len(a)
+    if not m:
+        return K.one
+    n = len(a[0])
+
+    exquo = K.exquo
+    # uf keeps track of the sign change from row swaps
+    uf = K.one
+
+    for k in range(n-1):
+        if not a[k][k]:
+            for i in range(k+1, n):
+                if a[i][k]:
+                    a[k], a[i] = a[i], a[k]
+                    uf = -uf
+                    break
+            else:
+                return K.zero
+
+        akkm1 = a[k-1][k-1] if k else K.one
+
+        for i in range(k+1, n):
+            for j in range(k+1, n):
+                a[i][j] = exquo(a[i][j]*a[k][k] - a[i][k]*a[k][j], akkm1)
+
+    return uf * a[-1][-1]
+
+
+def ddm_iinv(ainv, a, K):
+    """ainv  <--  inv(a)
+
+    Compute the inverse of a matrix $a$ over a field $K$ using Gauss-Jordan
+    elimination. The result is stored in $ainv$.
+
+    Uses division in the ground domain which should be an exact field.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.matrices.ddm import ddm_iinv, ddm_imatmul
+    >>> from sympy import QQ
+    >>> a = [[QQ(1), QQ(2)], [QQ(3), QQ(4)]]
+    >>> ainv = [[None, None], [None, None]]
+    >>> ddm_iinv(ainv, a, QQ)
+    >>> ainv
+    [[-2, 1], [3/2, -1/2]]
+    >>> result = [[QQ(0), QQ(0)], [QQ(0), QQ(0)]]
+    >>> ddm_imatmul(result, a, ainv)
+    >>> result
+    [[1, 0], [0, 1]]
+
+    See Also
+    ========
+
+    ddm_irref: the underlying routine.
+    """
+    if not K.is_Field:
+        raise DMDomainError('Not a field')
+
+    # a is (m x n)
+    m = len(a)
+    if not m:
+        return
+    n = len(a[0])
+    if m != n:
+        raise DMNonSquareMatrixError
+
+    eye = [[K.one if i==j else K.zero for j in range(n)] for i in range(n)]
+    Aaug = [row + eyerow for row, eyerow in zip(a, eye)]
+    pivots = ddm_irref(Aaug)
+    if pivots != list(range(n)):
+        raise DMNonInvertibleMatrixError('Matrix det == 0; not invertible.')
+    ainv[:] = [row[n:] for row in Aaug]
+
+
+def ddm_ilu_split(L, U, K):
+    """L, U  <--  LU(U)
+
+    Compute the LU decomposition of a matrix $L$ in place and store the lower
+    and upper triangular matrices in $L$ and $U$, respectively. Returns a list
+    of row swaps that were performed.
+
+    Uses division in the ground domain which should be an exact field.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.matrices.ddm import ddm_ilu_split
+    >>> from sympy import QQ
+    >>> L = [[QQ(0), QQ(0)], [QQ(0), QQ(0)]]
+    >>> U = [[QQ(1), QQ(2)], [QQ(3), QQ(4)]]
+    >>> swaps = ddm_ilu_split(L, U, QQ)
+    >>> swaps
+    []
+    >>> L
+    [[0, 0], [3, 0]]
+    >>> U
+    [[1, 2], [0, -2]]
+
+    See Also
+    ========
+
+    ddm_ilu
+    ddm_ilu_solve
+    """
+    m = len(U)
+    if not m:
+        return []
+    n = len(U[0])
+
+    swaps = ddm_ilu(U)
+
+    zeros = [K.zero] * min(m, n)
+    for i in range(1, m):
+        j = min(i, n)
+        L[i][:j] = U[i][:j]
+        U[i][:j] = zeros[:j]
+
+    return swaps
+
+
+def ddm_ilu(a):
+    """a  <--  LU(a)
+
+    Computes the LU decomposition of a matrix in place. Returns a list of
+    row swaps that were performed.
+
+    Uses division in the ground domain which should be an exact field.
+
+    This is only suitable for domains like :ref:`GF(p)`, :ref:`QQ`, :ref:`QQ_I`
+    and :ref:`QQ(a)`. With a rational function field like :ref:`K(x)` it is
+    better to clear denominators and use division-free algorithms. Pivoting is
+    used to avoid exact zeros but not for floating point accuracy so :ref:`RR`
+    and :ref:`CC` are not suitable (use :func:`ddm_irref` instead).
+
+    Examples
+    ========
+
+    >>> from sympy.polys.matrices.dense import ddm_ilu
+    >>> from sympy import QQ
+    >>> a = [[QQ(1, 2), QQ(1, 3)], [QQ(1, 4), QQ(1, 5)]]
+    >>> swaps = ddm_ilu(a)
+    >>> swaps
+    []
+    >>> a
+    [[1/2, 1/3], [1/2, 1/30]]
+
+    The same example using ``Matrix``:
+
+    >>> from sympy import Matrix, S
+    >>> M = Matrix([[S(1)/2, S(1)/3], [S(1)/4, S(1)/5]])
+    >>> L, U, swaps = M.LUdecomposition()
+    >>> L
+    Matrix([
+    [  1, 0],
+    [1/2, 1]])
+    >>> U
+    Matrix([
+    [1/2,  1/3],
+    [  0, 1/30]])
+    >>> swaps
+    []
+
+    See Also
+    ========
+
+    ddm_irref
+    ddm_ilu_solve
+    sympy.matrices.matrixbase.MatrixBase.LUdecomposition
+    """
+    m = len(a)
+    if not m:
+        return []
+    n = len(a[0])
+
+    swaps = []
+
+    for i in range(min(m, n)):
+        if not a[i][i]:
+            for ip in range(i+1, m):
+                if a[ip][i]:
+                    swaps.append((i, ip))
+                    a[i], a[ip] = a[ip], a[i]
+                    break
+            else:
+                # M = Matrix([[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 1, 1], [0, 0, 1, 2]])
+                continue
+        for j in range(i+1, m):
+            l_ji = a[j][i] / a[i][i]
+            a[j][i] = l_ji
+            for k in range(i+1, n):
+                a[j][k] -= l_ji * a[i][k]
+
+    return swaps
+
+
+def ddm_ilu_solve(x, L, U, swaps, b):
+    """x  <--  solve(L*U*x = swaps(b))
+
+    Solve a linear system, $A*x = b$, given an LU factorization of $A$.
+
+    Uses division in the ground domain which must be a field.
+
+    Modifies $x$ in place.
+
+    Examples
+    ========
+
+    Compute the LU decomposition of $A$ (in place):
+
+    >>> from sympy import QQ
+    >>> from sympy.polys.matrices.dense import ddm_ilu, ddm_ilu_solve
+    >>> A = [[QQ(1), QQ(2)], [QQ(3), QQ(4)]]
+    >>> swaps = ddm_ilu(A)
+    >>> A
+    [[1, 2], [3, -2]]
+    >>> L = U = A
+
+    Solve the linear system:
+
+    >>> b = [[QQ(5)], [QQ(6)]]
+    >>> x = [[None], [None]]
+    >>> ddm_ilu_solve(x, L, U, swaps, b)
+    >>> x
+    [[-4], [9/2]]
+
+    See Also
+    ========
+
+    ddm_ilu
+        Compute the LU decomposition of a matrix in place.
+    ddm_ilu_split
+        Compute the LU decomposition of a matrix and separate $L$ and $U$.
+    sympy.polys.matrices.domainmatrix.DomainMatrix.lu_solve
+        Higher level interface to this function.
+    """
+    m = len(U)
+    if not m:
+        return
+    n = len(U[0])
+
+    m2 = len(b)
+    if not m2:
+        raise DMShapeError("Shape mismtch")
+    o = len(b[0])
+
+    if m != m2:
+        raise DMShapeError("Shape mismtch")
+    if m < n:
+        raise NotImplementedError("Underdetermined")
+
+    if swaps:
+        b = [row[:] for row in b]
+        for i1, i2 in swaps:
+            b[i1], b[i2] = b[i2], b[i1]
+
+    # solve Ly = b
+    y = [[None] * o for _ in range(m)]
+    for k in range(o):
+        for i in range(m):
+            rhs = b[i][k]
+            for j in range(i):
+                rhs -= L[i][j] * y[j][k]
+            y[i][k] = rhs
+
+    if m > n:
+        for i in range(n, m):
+            for j in range(o):
+                if y[i][j]:
+                    raise DMNonInvertibleMatrixError
+
+    # Solve Ux = y
+    for k in range(o):
+        for i in reversed(range(n)):
+            if not U[i][i]:
+                raise DMNonInvertibleMatrixError
+            rhs = y[i][k]
+            for j in range(i+1, n):
+                rhs -= U[i][j] * x[j][k]
+            x[i][k] = rhs / U[i][i]
+
+
+def ddm_berk(M, K):
+    """
+    Berkowitz algorithm for computing the characteristic polynomial.
+
+    Explanation
+    ===========
+
+    The Berkowitz algorithm is a division-free algorithm for computing the
+    characteristic polynomial of a matrix over any commutative ring using only
+    arithmetic in the coefficient ring.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> from sympy.polys.matrices.dense import ddm_berk
+    >>> from sympy.polys.domains import ZZ
+    >>> M = [[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]]
+    >>> ddm_berk(M, ZZ)
+    [[1], [-5], [-2]]
+    >>> Matrix(M).charpoly()
+    PurePoly(lambda**2 - 5*lambda - 2, lambda, domain='ZZ')
+
+    See Also
+    ========
+
+    sympy.polys.matrices.domainmatrix.DomainMatrix.charpoly
+        The high-level interface to this function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Samuelson%E2%80%93Berkowitz_algorithm
+    """
+    m = len(M)
+    if not m:
+        return [[K.one]]
+    n = len(M[0])
+
+    if m != n:
+        raise DMShapeError("Not square")
+
+    if n == 1:
+        return [[K.one], [-M[0][0]]]
+
+    a = M[0][0]
+    R = [M[0][1:]]
+    C = [[row[0]] for row in M[1:]]
+    A = [row[1:] for row in M[1:]]
+
+    q = ddm_berk(A, K)
+
+    T = [[K.zero] * n for _ in range(n+1)]
+    for i in range(n):
+        T[i][i] = K.one
+        T[i+1][i] = -a
+    for i in range(2, n+1):
+        if i == 2:
+            AnC = C
+        else:
+            C = AnC
+            AnC = [[K.zero] for row in C]
+            ddm_imatmul(AnC, A, C)
+        RAnC = [[K.zero]]
+        ddm_imatmul(RAnC, R, AnC)
+        for j in range(0, n+1-i):
+            T[i+j][j] = -RAnC[0][0]
+
+    qout = [[K.zero] for _ in range(n+1)]
+    ddm_imatmul(qout, T, q)
+    return qout
diff --git a/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/dfm.py b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/dfm.py
new file mode 100644
index 0000000000000000000000000000000000000000..22938b7004654121f74b020bd6649bee84909e1e
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/dfm.py
@@ -0,0 +1,35 @@
+"""
+sympy.polys.matrices.dfm
+
+Provides the :class:`DFM` class if ``GROUND_TYPES=flint'``. Otherwise, ``DFM``
+is a placeholder class that raises NotImplementedError when instantiated.
+"""
+
+from sympy.external.gmpy import GROUND_TYPES
+
+if GROUND_TYPES == "flint":  # pragma: no cover
+    # When python-flint is installed we will try to use it for dense matrices
+    # if the domain is supported by python-flint.
+    from ._dfm import DFM
+
+else: # pragma: no cover
+    # Other code should be able to import this and it should just present as a
+    # version of DFM that does not support any domains.
+    class DFM_dummy:
+        """
+        Placeholder class for DFM when python-flint is not installed.
+        """
+        def __init__(*args, **kwargs):
+            raise NotImplementedError("DFM requires GROUND_TYPES=flint.")
+
+        @classmethod
+        def _supports_domain(cls, domain):
+            return False
+
+        @classmethod
+        def _get_flint_func(cls, domain):
+            raise NotImplementedError("DFM requires GROUND_TYPES=flint.")
+
+    # mypy really struggles with this kind of conditional type assignment.
+    # Maybe there is a better way to annotate this rather than type: ignore.
+    DFM = DFM_dummy # type: ignore
diff --git a/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/domainmatrix.py b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/domainmatrix.py
new file mode 100644
index 0000000000000000000000000000000000000000..b91bef314d16364cdbfc18f5f7470d958468a23a
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/domainmatrix.py
@@ -0,0 +1,3850 @@
+"""
+
+Module for the DomainMatrix class.
+
+A DomainMatrix represents a matrix with elements that are in a particular
+Domain. Each DomainMatrix internally wraps a DDM which is used for the
+lower-level operations. The idea is that the DomainMatrix class provides the
+convenience routines for converting between Expr and the poly domains as well
+as unifying matrices with different domains.
+
+"""
+from collections import Counter
+from functools import reduce
+from typing import Union as tUnion, Tuple as tTuple
+
+from sympy.external.gmpy import GROUND_TYPES
+from sympy.utilities.decorator import doctest_depends_on
+
+from sympy.core.sympify import _sympify
+
+from ..domains import Domain
+
+from ..constructor import construct_domain
+
+from .exceptions import (
+    DMFormatError,
+    DMBadInputError,
+    DMShapeError,
+    DMDomainError,
+    DMNotAField,
+    DMNonSquareMatrixError,
+    DMNonInvertibleMatrixError
+)
+
+from .domainscalar import DomainScalar
+
+from sympy.polys.domains import ZZ, EXRAW, QQ
+
+from sympy.polys.densearith import dup_mul
+from sympy.polys.densebasic import dup_convert
+from sympy.polys.densetools import (
+    dup_mul_ground,
+    dup_quo_ground,
+    dup_content,
+    dup_clear_denoms,
+    dup_primitive,
+    dup_transform,
+)
+from sympy.polys.factortools import dup_factor_list
+from sympy.polys.polyutils import _sort_factors
+
+from .ddm import DDM
+
+from .sdm import SDM
+
+from .dfm import DFM
+
+from .rref import _dm_rref, _dm_rref_den
+
+
+if GROUND_TYPES != 'flint':
+    __doctest_skip__ = ['DomainMatrix.to_dfm', 'DomainMatrix.to_dfm_or_ddm']
+else:
+    __doctest_skip__ = ['DomainMatrix.from_list']
+
+
+def DM(rows, domain):
+    """Convenient alias for DomainMatrix.from_list
+
+    Examples
+    ========
+
+    >>> from sympy import ZZ
+    >>> from sympy.polys.matrices import DM
+    >>> DM([[1, 2], [3, 4]], ZZ)
+    DomainMatrix([[1, 2], [3, 4]], (2, 2), ZZ)
+
+    See Also
+    ========
+
+    DomainMatrix.from_list
+    """
+    return DomainMatrix.from_list(rows, domain)
+
+
+class DomainMatrix:
+    r"""
+    Associate Matrix with :py:class:`~.Domain`
+
+    Explanation
+    ===========
+
+    DomainMatrix uses :py:class:`~.Domain` for its internal representation
+    which makes it faster than the SymPy Matrix class (currently) for many
+    common operations, but this advantage makes it not entirely compatible
+    with Matrix. DomainMatrix are analogous to numpy arrays with "dtype".
+    In the DomainMatrix, each element has a domain such as :ref:`ZZ`
+    or  :ref:`QQ(a)`.
+
+
+    Examples
+    ========
+
+    Creating a DomainMatrix from the existing Matrix class:
+
+    >>> from sympy import Matrix
+    >>> from sympy.polys.matrices import DomainMatrix
+    >>> Matrix1 = Matrix([
+    ...    [1, 2],
+    ...    [3, 4]])
+    >>> A = DomainMatrix.from_Matrix(Matrix1)
+    >>> A
+    DomainMatrix({0: {0: 1, 1: 2}, 1: {0: 3, 1: 4}}, (2, 2), ZZ)
+
+    Directly forming a DomainMatrix:
+
+    >>> from sympy import ZZ
+    >>> from sympy.polys.matrices import DomainMatrix
+    >>> A = DomainMatrix([
+    ...    [ZZ(1), ZZ(2)],
+    ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    >>> A
+    DomainMatrix([[1, 2], [3, 4]], (2, 2), ZZ)
+
+    See Also
+    ========
+
+    DDM
+    SDM
+    Domain
+    Poly
+
+    """
+    rep: tUnion[SDM, DDM, DFM]
+    shape: tTuple[int, int]
+    domain: Domain
+
+    def __new__(cls, rows, shape, domain, *, fmt=None):
+        """
+        Creates a :py:class:`~.DomainMatrix`.
+
+        Parameters
+        ==========
+
+        rows : Represents elements of DomainMatrix as list of lists
+        shape : Represents dimension of DomainMatrix
+        domain : Represents :py:class:`~.Domain` of DomainMatrix
+
+        Raises
+        ======
+
+        TypeError
+            If any of rows, shape and domain are not provided
+
+        """
+        if isinstance(rows, (DDM, SDM, DFM)):
+            raise TypeError("Use from_rep to initialise from SDM/DDM")
+        elif isinstance(rows, list):
+            rep = DDM(rows, shape, domain)
+        elif isinstance(rows, dict):
+            rep = SDM(rows, shape, domain)
+        else:
+            msg = "Input should be list-of-lists or dict-of-dicts"
+            raise TypeError(msg)
+
+        if fmt is not None:
+            if fmt == 'sparse':
+                rep = rep.to_sdm()
+            elif fmt == 'dense':
+                rep = rep.to_ddm()
+            else:
+                raise ValueError("fmt should be 'sparse' or 'dense'")
+
+        # Use python-flint for dense matrices if possible
+        if rep.fmt == 'dense' and DFM._supports_domain(domain):
+            rep = rep.to_dfm()
+
+        return cls.from_rep(rep)
+
+    def __reduce__(self):
+        rep = self.rep
+        if rep.fmt == 'dense':
+            arg = self.to_list()
+        elif rep.fmt == 'sparse':
+            arg = dict(rep)
+        else:
+            raise RuntimeError # pragma: no cover
+        args = (arg, rep.shape, rep.domain)
+        return (self.__class__, args)
+
+    def __getitem__(self, key):
+        i, j = key
+        m, n = self.shape
+        if not (isinstance(i, slice) or isinstance(j, slice)):
+            return DomainScalar(self.rep.getitem(i, j), self.domain)
+
+        if not isinstance(i, slice):
+            if not -m <= i < m:
+                raise IndexError("Row index out of range")
+            i = i % m
+            i = slice(i, i+1)
+        if not isinstance(j, slice):
+            if not -n <= j < n:
+                raise IndexError("Column index out of range")
+            j = j % n
+            j = slice(j, j+1)
+
+        return self.from_rep(self.rep.extract_slice(i, j))
+
+    def getitem_sympy(self, i, j):
+        return self.domain.to_sympy(self.rep.getitem(i, j))
+
+    def extract(self, rowslist, colslist):
+        return self.from_rep(self.rep.extract(rowslist, colslist))
+
+    def __setitem__(self, key, value):
+        i, j = key
+        if not self.domain.of_type(value):
+            raise TypeError
+        if isinstance(i, int) and isinstance(j, int):
+            self.rep.setitem(i, j, value)
+        else:
+            raise NotImplementedError
+
+    @classmethod
+    def from_rep(cls, rep):
+        """Create a new DomainMatrix efficiently from DDM/SDM.
+
+        Examples
+        ========
+
+        Create a :py:class:`~.DomainMatrix` with an dense internal
+        representation as :py:class:`~.DDM`:
+
+        >>> from sympy.polys.domains import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy.polys.matrices.ddm import DDM
+        >>> drep = DDM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> dM = DomainMatrix.from_rep(drep)
+        >>> dM
+        DomainMatrix([[1, 2], [3, 4]], (2, 2), ZZ)
+
+        Create a :py:class:`~.DomainMatrix` with a sparse internal
+        representation as :py:class:`~.SDM`:
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import ZZ
+        >>> drep = SDM({0:{1:ZZ(1)},1:{0:ZZ(2)}}, (2, 2), ZZ)
+        >>> dM = DomainMatrix.from_rep(drep)
+        >>> dM
+        DomainMatrix({0: {1: 1}, 1: {0: 2}}, (2, 2), ZZ)
+
+        Parameters
+        ==========
+
+        rep: SDM or DDM
+            The internal sparse or dense representation of the matrix.
+
+        Returns
+        =======
+
+        DomainMatrix
+            A :py:class:`~.DomainMatrix` wrapping *rep*.
+
+        Notes
+        =====
+
+        This takes ownership of rep as its internal representation. If rep is
+        being mutated elsewhere then a copy should be provided to
+        ``from_rep``. Only minimal verification or checking is done on *rep*
+        as this is supposed to be an efficient internal routine.
+
+        """
+        if not (isinstance(rep, (DDM, SDM)) or (DFM is not None and isinstance(rep, DFM))):
+            raise TypeError("rep should be of type DDM or SDM")
+        self = super().__new__(cls)
+        self.rep = rep
+        self.shape = rep.shape
+        self.domain = rep.domain
+        return self
+
+    @classmethod
+    @doctest_depends_on(ground_types=['python', 'gmpy'])
+    def from_list(cls, rows, domain):
+        r"""
+        Convert a list of lists into a DomainMatrix
+
+        Parameters
+        ==========
+
+        rows: list of lists
+            Each element of the inner lists should be either the single arg,
+            or tuple of args, that would be passed to the domain constructor
+            in order to form an element of the domain. See examples.
+
+        Returns
+        =======
+
+        DomainMatrix containing elements defined in rows
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import FF, QQ, ZZ
+        >>> A = DomainMatrix.from_list([[1, 0, 1], [0, 0, 1]], ZZ)
+        >>> A
+        DomainMatrix([[1, 0, 1], [0, 0, 1]], (2, 3), ZZ)
+        >>> B = DomainMatrix.from_list([[1, 0, 1], [0, 0, 1]], FF(7))
+        >>> B
+        DomainMatrix([[1 mod 7, 0 mod 7, 1 mod 7], [0 mod 7, 0 mod 7, 1 mod 7]], (2, 3), GF(7))
+        >>> C = DomainMatrix.from_list([[(1, 2), (3, 1)], [(1, 4), (5, 1)]], QQ)
+        >>> C
+        DomainMatrix([[1/2, 3], [1/4, 5]], (2, 2), QQ)
+
+        See Also
+        ========
+
+        from_list_sympy
+
+        """
+        nrows = len(rows)
+        ncols = 0 if not nrows else len(rows[0])
+        conv = lambda e: domain(*e) if isinstance(e, tuple) else domain(e)
+        domain_rows = [[conv(e) for e in row] for row in rows]
+        return DomainMatrix(domain_rows, (nrows, ncols), domain)
+
+    @classmethod
+    def from_list_sympy(cls, nrows, ncols, rows, **kwargs):
+        r"""
+        Convert a list of lists of Expr into a DomainMatrix using construct_domain
+
+        Parameters
+        ==========
+
+        nrows: number of rows
+        ncols: number of columns
+        rows: list of lists
+
+        Returns
+        =======
+
+        DomainMatrix containing elements of rows
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy.abc import x, y, z
+        >>> A = DomainMatrix.from_list_sympy(1, 3, [[x, y, z]])
+        >>> A
+        DomainMatrix([[x, y, z]], (1, 3), ZZ[x,y,z])
+
+        See Also
+        ========
+
+        sympy.polys.constructor.construct_domain, from_dict_sympy
+
+        """
+        assert len(rows) == nrows
+        assert all(len(row) == ncols for row in rows)
+
+        items_sympy = [_sympify(item) for row in rows for item in row]
+
+        domain, items_domain = cls.get_domain(items_sympy, **kwargs)
+
+        domain_rows = [[items_domain[ncols*r + c] for c in range(ncols)] for r in range(nrows)]
+
+        return DomainMatrix(domain_rows, (nrows, ncols), domain)
+
+    @classmethod
+    def from_dict_sympy(cls, nrows, ncols, elemsdict, **kwargs):
+        """
+
+        Parameters
+        ==========
+
+        nrows: number of rows
+        ncols: number of cols
+        elemsdict: dict of dicts containing non-zero elements of the DomainMatrix
+
+        Returns
+        =======
+
+        DomainMatrix containing elements of elemsdict
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy.abc import x,y,z
+        >>> elemsdict = {0: {0:x}, 1:{1: y}, 2: {2: z}}
+        >>> A = DomainMatrix.from_dict_sympy(3, 3, elemsdict)
+        >>> A
+        DomainMatrix({0: {0: x}, 1: {1: y}, 2: {2: z}}, (3, 3), ZZ[x,y,z])
+
+        See Also
+        ========
+
+        from_list_sympy
+
+        """
+        if not all(0 <= r < nrows for r in elemsdict):
+            raise DMBadInputError("Row out of range")
+        if not all(0 <= c < ncols for row in elemsdict.values() for c in row):
+            raise DMBadInputError("Column out of range")
+
+        items_sympy = [_sympify(item) for row in elemsdict.values() for item in row.values()]
+        domain, items_domain = cls.get_domain(items_sympy, **kwargs)
+
+        idx = 0
+        items_dict = {}
+        for i, row in elemsdict.items():
+            items_dict[i] = {}
+            for j in row:
+                items_dict[i][j] = items_domain[idx]
+                idx += 1
+
+        return DomainMatrix(items_dict, (nrows, ncols), domain)
+
+    @classmethod
+    def from_Matrix(cls, M, fmt='sparse',**kwargs):
+        r"""
+        Convert Matrix to DomainMatrix
+
+        Parameters
+        ==========
+
+        M: Matrix
+
+        Returns
+        =======
+
+        Returns DomainMatrix with identical elements as M
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> M = Matrix([
+        ...    [1.0, 3.4],
+        ...    [2.4, 1]])
+        >>> A = DomainMatrix.from_Matrix(M)
+        >>> A
+        DomainMatrix({0: {0: 1.0, 1: 3.4}, 1: {0: 2.4, 1: 1.0}}, (2, 2), RR)
+
+        We can keep internal representation as ddm using fmt='dense'
+        >>> from sympy import Matrix, QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix.from_Matrix(Matrix([[QQ(1, 2), QQ(3, 4)], [QQ(0, 1), QQ(0, 1)]]), fmt='dense')
+        >>> A.rep
+        [[1/2, 3/4], [0, 0]]
+
+        See Also
+        ========
+
+        Matrix
+
+        """
+        if fmt == 'dense':
+            return cls.from_list_sympy(*M.shape, M.tolist(), **kwargs)
+
+        return cls.from_dict_sympy(*M.shape, M.todod(), **kwargs)
+
+    @classmethod
+    def get_domain(cls, items_sympy, **kwargs):
+        K, items_K = construct_domain(items_sympy, **kwargs)
+        return K, items_K
+
+    def choose_domain(self, **opts):
+        """Convert to a domain found by :func:`~.construct_domain`.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DM
+        >>> M = DM([[1, 2], [3, 4]], ZZ)
+        >>> M
+        DomainMatrix([[1, 2], [3, 4]], (2, 2), ZZ)
+        >>> M.choose_domain(field=True)
+        DomainMatrix([[1, 2], [3, 4]], (2, 2), QQ)
+
+        >>> from sympy.abc import x
+        >>> M = DM([[1, x], [x**2, x**3]], ZZ[x])
+        >>> M.choose_domain(field=True).domain
+        ZZ(x)
+
+        Keyword arguments are passed to :func:`~.construct_domain`.
+
+        See Also
+        ========
+
+        construct_domain
+        convert_to
+        """
+        elements, data = self.to_sympy().to_flat_nz()
+        dom, elements_dom = construct_domain(elements, **opts)
+        return self.from_flat_nz(elements_dom, data, dom)
+
+    def copy(self):
+        return self.from_rep(self.rep.copy())
+
+    def convert_to(self, K):
+        r"""
+        Change the domain of DomainMatrix to desired domain or field
+
+        Parameters
+        ==========
+
+        K : Represents the desired domain or field.
+            Alternatively, ``None`` may be passed, in which case this method
+            just returns a copy of this DomainMatrix.
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix with the desired domain or field
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ, ZZ_I
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+
+        >>> A.convert_to(ZZ_I)
+        DomainMatrix([[1, 2], [3, 4]], (2, 2), ZZ_I)
+
+        """
+        if K == self.domain:
+            return self.copy()
+
+        rep = self.rep
+
+        # The DFM, DDM and SDM types do not do any implicit conversions so we
+        # manage switching between DDM and DFM here.
+        if rep.is_DFM and not DFM._supports_domain(K):
+            rep_K = rep.to_ddm().convert_to(K)
+        elif rep.is_DDM and DFM._supports_domain(K):
+            rep_K = rep.convert_to(K).to_dfm()
+        else:
+            rep_K = rep.convert_to(K)
+
+        return self.from_rep(rep_K)
+
+    def to_sympy(self):
+        return self.convert_to(EXRAW)
+
+    def to_field(self):
+        r"""
+        Returns a DomainMatrix with the appropriate field
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix with the appropriate field
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+
+        >>> A.to_field()
+        DomainMatrix([[1, 2], [3, 4]], (2, 2), QQ)
+
+        """
+        K = self.domain.get_field()
+        return self.convert_to(K)
+
+    def to_sparse(self):
+        """
+        Return a sparse DomainMatrix representation of *self*.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import QQ
+        >>> A = DomainMatrix([[1, 0],[0, 2]], (2, 2), QQ)
+        >>> A.rep
+        [[1, 0], [0, 2]]
+        >>> B = A.to_sparse()
+        >>> B.rep
+        {0: {0: 1}, 1: {1: 2}}
+        """
+        if self.rep.fmt == 'sparse':
+            return self
+
+        return self.from_rep(self.rep.to_sdm())
+
+    def to_dense(self):
+        """
+        Return a dense DomainMatrix representation of *self*.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import QQ
+        >>> A = DomainMatrix({0: {0: 1}, 1: {1: 2}}, (2, 2), QQ)
+        >>> A.rep
+        {0: {0: 1}, 1: {1: 2}}
+        >>> B = A.to_dense()
+        >>> B.rep
+        [[1, 0], [0, 2]]
+
+        """
+        rep = self.rep
+
+        if rep.fmt == 'dense':
+            return self
+
+        return self.from_rep(rep.to_dfm_or_ddm())
+
+    def to_ddm(self):
+        """
+        Return a :class:`~.DDM` representation of *self*.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import QQ
+        >>> A = DomainMatrix({0: {0: 1}, 1: {1: 2}}, (2, 2), QQ)
+        >>> ddm = A.to_ddm()
+        >>> ddm
+        [[1, 0], [0, 2]]
+        >>> type(ddm)
+        <class 'sympy.polys.matrices.ddm.DDM'>
+
+        See Also
+        ========
+
+        to_sdm
+        to_dense
+        sympy.polys.matrices.ddm.DDM.to_sdm
+        """
+        return self.rep.to_ddm()
+
+    def to_sdm(self):
+        """
+        Return a :class:`~.SDM` representation of *self*.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import QQ
+        >>> A = DomainMatrix([[1, 0],[0, 2]], (2, 2), QQ)
+        >>> sdm = A.to_sdm()
+        >>> sdm
+        {0: {0: 1}, 1: {1: 2}}
+        >>> type(sdm)
+        <class 'sympy.polys.matrices.sdm.SDM'>
+
+        See Also
+        ========
+
+        to_ddm
+        to_sparse
+        sympy.polys.matrices.sdm.SDM.to_ddm
+        """
+        return self.rep.to_sdm()
+
+    @doctest_depends_on(ground_types=['flint'])
+    def to_dfm(self):
+        """
+        Return a :class:`~.DFM` representation of *self*.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import QQ
+        >>> A = DomainMatrix([[1, 0],[0, 2]], (2, 2), QQ)
+        >>> dfm = A.to_dfm()
+        >>> dfm
+        [[1, 0], [0, 2]]
+        >>> type(dfm)
+        <class 'sympy.polys.matrices._dfm.DFM'>
+
+        See Also
+        ========
+
+        to_ddm
+        to_dense
+        DFM
+        """
+        return self.rep.to_dfm()
+
+    @doctest_depends_on(ground_types=['flint'])
+    def to_dfm_or_ddm(self):
+        """
+        Return a :class:`~.DFM` or :class:`~.DDM` representation of *self*.
+
+        Explanation
+        ===========
+
+        The :class:`~.DFM` representation can only be used if the ground types
+        are ``flint`` and the ground domain is supported by ``python-flint``.
+        This method will return a :class:`~.DFM` representation if possible,
+        but will return a :class:`~.DDM` representation otherwise.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import QQ
+        >>> A = DomainMatrix([[1, 0],[0, 2]], (2, 2), QQ)
+        >>> dfm = A.to_dfm_or_ddm()
+        >>> dfm
+        [[1, 0], [0, 2]]
+        >>> type(dfm)  # Depends on the ground domain and ground types
+        <class 'sympy.polys.matrices._dfm.DFM'>
+
+        See Also
+        ========
+
+        to_ddm: Always return a :class:`~.DDM` representation.
+        to_dfm: Returns a :class:`~.DFM` representation or raise an error.
+        to_dense: Convert internally to a :class:`~.DFM` or :class:`~.DDM`
+        DFM: The :class:`~.DFM` dense FLINT matrix representation.
+        DDM: The Python :class:`~.DDM` dense domain matrix representation.
+        """
+        return self.rep.to_dfm_or_ddm()
+
+    @classmethod
+    def _unify_domain(cls, *matrices):
+        """Convert matrices to a common domain"""
+        domains = {matrix.domain for matrix in matrices}
+        if len(domains) == 1:
+            return matrices
+        domain = reduce(lambda x, y: x.unify(y), domains)
+        return tuple(matrix.convert_to(domain) for matrix in matrices)
+
+    @classmethod
+    def _unify_fmt(cls, *matrices, fmt=None):
+        """Convert matrices to the same format.
+
+        If all matrices have the same format, then return unmodified.
+        Otherwise convert both to the preferred format given as *fmt* which
+        should be 'dense' or 'sparse'.
+        """
+        formats = {matrix.rep.fmt for matrix in matrices}
+        if len(formats) == 1:
+            return matrices
+        if fmt == 'sparse':
+            return tuple(matrix.to_sparse() for matrix in matrices)
+        elif fmt == 'dense':
+            return tuple(matrix.to_dense() for matrix in matrices)
+        else:
+            raise ValueError("fmt should be 'sparse' or 'dense'")
+
+    def unify(self, *others, fmt=None):
+        """
+        Unifies the domains and the format of self and other
+        matrices.
+
+        Parameters
+        ==========
+
+        others : DomainMatrix
+
+        fmt: string 'dense', 'sparse' or `None` (default)
+            The preferred format to convert to if self and other are not
+            already in the same format. If `None` or not specified then no
+            conversion if performed.
+
+        Returns
+        =======
+
+        Tuple[DomainMatrix]
+            Matrices with unified domain and format
+
+        Examples
+        ========
+
+        Unify the domain of DomainMatrix that have different domains:
+
+        >>> from sympy import ZZ, QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([[ZZ(1), ZZ(2)]], (1, 2), ZZ)
+        >>> B = DomainMatrix([[QQ(1, 2), QQ(2)]], (1, 2), QQ)
+        >>> Aq, Bq = A.unify(B)
+        >>> Aq
+        DomainMatrix([[1, 2]], (1, 2), QQ)
+        >>> Bq
+        DomainMatrix([[1/2, 2]], (1, 2), QQ)
+
+        Unify the format (dense or sparse):
+
+        >>> A = DomainMatrix([[ZZ(1), ZZ(2)]], (1, 2), ZZ)
+        >>> B = DomainMatrix({0:{0: ZZ(1)}}, (2, 2), ZZ)
+        >>> B.rep
+        {0: {0: 1}}
+
+        >>> A2, B2 = A.unify(B, fmt='dense')
+        >>> B2.rep
+        [[1, 0], [0, 0]]
+
+        See Also
+        ========
+
+        convert_to, to_dense, to_sparse
+
+        """
+        matrices = (self,) + others
+        matrices = DomainMatrix._unify_domain(*matrices)
+        if fmt is not None:
+            matrices = DomainMatrix._unify_fmt(*matrices, fmt=fmt)
+        return matrices
+
+    def to_Matrix(self):
+        r"""
+        Convert DomainMatrix to Matrix
+
+        Returns
+        =======
+
+        Matrix
+            MutableDenseMatrix for the DomainMatrix
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+
+        >>> A.to_Matrix()
+        Matrix([
+            [1, 2],
+            [3, 4]])
+
+        See Also
+        ========
+
+        from_Matrix
+
+        """
+        from sympy.matrices.dense import MutableDenseMatrix
+
+        # XXX: If the internal representation of RepMatrix changes then this
+        # might need to be changed also.
+        if self.domain in (ZZ, QQ, EXRAW):
+            if self.rep.fmt == "sparse":
+                rep = self.copy()
+            else:
+                rep = self.to_sparse()
+        else:
+            rep = self.convert_to(EXRAW).to_sparse()
+
+        return MutableDenseMatrix._fromrep(rep)
+
+    def to_list(self):
+        """
+        Convert :class:`DomainMatrix` to list of lists.
+
+        See Also
+        ========
+
+        from_list
+        to_list_flat
+        to_flat_nz
+        to_dok
+        """
+        return self.rep.to_list()
+
+    def to_list_flat(self):
+        """
+        Convert :class:`DomainMatrix` to flat list.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> A.to_list_flat()
+        [1, 2, 3, 4]
+
+        See Also
+        ========
+
+        from_list_flat
+        to_list
+        to_flat_nz
+        to_dok
+        """
+        return self.rep.to_list_flat()
+
+    @classmethod
+    def from_list_flat(cls, elements, shape, domain):
+        """
+        Create :class:`DomainMatrix` from flat list.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> element_list = [ZZ(1), ZZ(2), ZZ(3), ZZ(4)]
+        >>> A = DomainMatrix.from_list_flat(element_list, (2, 2), ZZ)
+        >>> A
+        DomainMatrix([[1, 2], [3, 4]], (2, 2), ZZ)
+        >>> A == A.from_list_flat(A.to_list_flat(), A.shape, A.domain)
+        True
+
+        See Also
+        ========
+
+        to_list_flat
+        """
+        ddm = DDM.from_list_flat(elements, shape, domain)
+        return cls.from_rep(ddm.to_dfm_or_ddm())
+
+    def to_flat_nz(self):
+        """
+        Convert :class:`DomainMatrix` to list of nonzero elements and data.
+
+        Explanation
+        ===========
+
+        Returns a tuple ``(elements, data)`` where ``elements`` is a list of
+        elements of the matrix with zeros possibly excluded. The matrix can be
+        reconstructed by passing these to :meth:`from_flat_nz`. The idea is to
+        be able to modify a flat list of the elements and then create a new
+        matrix of the same shape with the modified elements in the same
+        positions.
+
+        The format of ``data`` differs depending on whether the underlying
+        representation is dense or sparse but either way it represents the
+        positions of the elements in the list in a way that
+        :meth:`from_flat_nz` can use to reconstruct the matrix. The
+        :meth:`from_flat_nz` method should be called on the same
+        :class:`DomainMatrix` that was used to call :meth:`to_flat_nz`.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> elements, data = A.to_flat_nz()
+        >>> elements
+        [1, 2, 3, 4]
+        >>> A == A.from_flat_nz(elements, data, A.domain)
+        True
+
+        Create a matrix with the elements doubled:
+
+        >>> elements_doubled = [2*x for x in elements]
+        >>> A2 = A.from_flat_nz(elements_doubled, data, A.domain)
+        >>> A2 == 2*A
+        True
+
+        See Also
+        ========
+
+        from_flat_nz
+        """
+        return self.rep.to_flat_nz()
+
+    def from_flat_nz(self, elements, data, domain):
+        """
+        Reconstruct :class:`DomainMatrix` after calling :meth:`to_flat_nz`.
+
+        See :meth:`to_flat_nz` for explanation.
+
+        See Also
+        ========
+
+        to_flat_nz
+        """
+        rep = self.rep.from_flat_nz(elements, data, domain)
+        return self.from_rep(rep)
+
+    def to_dod(self):
+        """
+        Convert :class:`DomainMatrix` to dictionary of dictionaries (dod) format.
+
+        Explanation
+        ===========
+
+        Returns a dictionary of dictionaries representing the matrix.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DM
+        >>> A = DM([[ZZ(1), ZZ(2), ZZ(0)], [ZZ(3), ZZ(0), ZZ(4)]], ZZ)
+        >>> A.to_dod()
+        {0: {0: 1, 1: 2}, 1: {0: 3, 2: 4}}
+        >>> A.to_sparse() == A.from_dod(A.to_dod(), A.shape, A.domain)
+        True
+        >>> A == A.from_dod_like(A.to_dod())
+        True
+
+        See Also
+        ========
+
+        from_dod
+        from_dod_like
+        to_dok
+        to_list
+        to_list_flat
+        to_flat_nz
+        sympy.matrices.matrixbase.MatrixBase.todod
+        """
+        return self.rep.to_dod()
+
+    @classmethod
+    def from_dod(cls, dod, shape, domain):
+        """
+        Create sparse :class:`DomainMatrix` from dict of dict (dod) format.
+
+        See :meth:`to_dod` for explanation.
+
+        See Also
+        ========
+
+        to_dod
+        from_dod_like
+        """
+        return cls.from_rep(SDM.from_dod(dod, shape, domain))
+
+    def from_dod_like(self, dod, domain=None):
+        """
+        Create :class:`DomainMatrix` like ``self`` from dict of dict (dod) format.
+
+        See :meth:`to_dod` for explanation.
+
+        See Also
+        ========
+
+        to_dod
+        from_dod
+        """
+        if domain is None:
+            domain = self.domain
+        return self.from_rep(self.rep.from_dod(dod, self.shape, domain))
+
+    def to_dok(self):
+        """
+        Convert :class:`DomainMatrix` to dictionary of keys (dok) format.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(0)],
+        ...    [ZZ(0), ZZ(4)]], (2, 2), ZZ)
+        >>> A.to_dok()
+        {(0, 0): 1, (1, 1): 4}
+
+        The matrix can be reconstructed by calling :meth:`from_dok` although
+        the reconstructed matrix will always be in sparse format:
+
+        >>> A.to_sparse() == A.from_dok(A.to_dok(), A.shape, A.domain)
+        True
+
+        See Also
+        ========
+
+        from_dok
+        to_list
+        to_list_flat
+        to_flat_nz
+        """
+        return self.rep.to_dok()
+
+    @classmethod
+    def from_dok(cls, dok, shape, domain):
+        """
+        Create :class:`DomainMatrix` from dictionary of keys (dok) format.
+
+        See :meth:`to_dok` for explanation.
+
+        See Also
+        ========
+
+        to_dok
+        """
+        return cls.from_rep(SDM.from_dok(dok, shape, domain))
+
+    def iter_values(self):
+        """
+        Iterate over nonzero elements of the matrix.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([[ZZ(1), ZZ(0)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> list(A.iter_values())
+        [1, 3, 4]
+
+        See Also
+        ========
+
+        iter_items
+        to_list_flat
+        sympy.matrices.matrixbase.MatrixBase.iter_values
+        """
+        return self.rep.iter_values()
+
+    def iter_items(self):
+        """
+        Iterate over indices and values of nonzero elements of the matrix.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([[ZZ(1), ZZ(0)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> list(A.iter_items())
+        [((0, 0), 1), ((1, 0), 3), ((1, 1), 4)]
+
+        See Also
+        ========
+
+        iter_values
+        to_dok
+        sympy.matrices.matrixbase.MatrixBase.iter_items
+        """
+        return self.rep.iter_items()
+
+    def nnz(self):
+        """
+        Number of nonzero elements in the matrix.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DM
+        >>> A = DM([[1, 0], [0, 4]], ZZ)
+        >>> A.nnz()
+        2
+        """
+        return self.rep.nnz()
+
+    def __repr__(self):
+        return 'DomainMatrix(%s, %r, %r)' % (str(self.rep), self.shape, self.domain)
+
+    def transpose(self):
+        """Matrix transpose of ``self``"""
+        return self.from_rep(self.rep.transpose())
+
+    def flat(self):
+        rows, cols = self.shape
+        return [self[i,j].element for i in range(rows) for j in range(cols)]
+
+    @property
+    def is_zero_matrix(self):
+        return self.rep.is_zero_matrix()
+
+    @property
+    def is_upper(self):
+        """
+        Says whether this matrix is upper-triangular. True can be returned
+        even if the matrix is not square.
+        """
+        return self.rep.is_upper()
+
+    @property
+    def is_lower(self):
+        """
+        Says whether this matrix is lower-triangular. True can be returned
+        even if the matrix is not square.
+        """
+        return self.rep.is_lower()
+
+    @property
+    def is_diagonal(self):
+        """
+        True if the matrix is diagonal.
+
+        Can return true for non-square matrices. A matrix is diagonal if
+        ``M[i,j] == 0`` whenever ``i != j``.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DM
+        >>> M = DM([[ZZ(1), ZZ(0)], [ZZ(0), ZZ(1)]], ZZ)
+        >>> M.is_diagonal
+        True
+
+        See Also
+        ========
+
+        is_upper
+        is_lower
+        is_square
+        diagonal
+        """
+        return self.rep.is_diagonal()
+
+    def diagonal(self):
+        """
+        Get the diagonal entries of the matrix as a list.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DM
+        >>> M = DM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], ZZ)
+        >>> M.diagonal()
+        [1, 4]
+
+        See Also
+        ========
+
+        is_diagonal
+        diag
+        """
+        return self.rep.diagonal()
+
+    @property
+    def is_square(self):
+        """
+        True if the matrix is square.
+        """
+        return self.shape[0] == self.shape[1]
+
+    def rank(self):
+        rref, pivots = self.rref()
+        return len(pivots)
+
+    def hstack(A, *B):
+        r"""Horizontally stack the given matrices.
+
+        Parameters
+        ==========
+
+        B: DomainMatrix
+            Matrices to stack horizontally.
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix by stacking horizontally.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+
+        >>> A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> B = DomainMatrix([[ZZ(5), ZZ(6)], [ZZ(7), ZZ(8)]], (2, 2), ZZ)
+        >>> A.hstack(B)
+        DomainMatrix([[1, 2, 5, 6], [3, 4, 7, 8]], (2, 4), ZZ)
+
+        >>> C = DomainMatrix([[ZZ(9), ZZ(10)], [ZZ(11), ZZ(12)]], (2, 2), ZZ)
+        >>> A.hstack(B, C)
+        DomainMatrix([[1, 2, 5, 6, 9, 10], [3, 4, 7, 8, 11, 12]], (2, 6), ZZ)
+
+        See Also
+        ========
+
+        unify
+        """
+        A, *B = A.unify(*B, fmt=A.rep.fmt)
+        return DomainMatrix.from_rep(A.rep.hstack(*(Bk.rep for Bk in B)))
+
+    def vstack(A, *B):
+        r"""Vertically stack the given matrices.
+
+        Parameters
+        ==========
+
+        B: DomainMatrix
+            Matrices to stack vertically.
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix by stacking vertically.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+
+        >>> A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> B = DomainMatrix([[ZZ(5), ZZ(6)], [ZZ(7), ZZ(8)]], (2, 2), ZZ)
+        >>> A.vstack(B)
+        DomainMatrix([[1, 2], [3, 4], [5, 6], [7, 8]], (4, 2), ZZ)
+
+        >>> C = DomainMatrix([[ZZ(9), ZZ(10)], [ZZ(11), ZZ(12)]], (2, 2), ZZ)
+        >>> A.vstack(B, C)
+        DomainMatrix([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12]], (6, 2), ZZ)
+
+        See Also
+        ========
+
+        unify
+        """
+        A, *B = A.unify(*B, fmt='dense')
+        return DomainMatrix.from_rep(A.rep.vstack(*(Bk.rep for Bk in B)))
+
+    def applyfunc(self, func, domain=None):
+        if domain is None:
+            domain = self.domain
+        return self.from_rep(self.rep.applyfunc(func, domain))
+
+    def __add__(A, B):
+        if not isinstance(B, DomainMatrix):
+            return NotImplemented
+        A, B = A.unify(B, fmt='dense')
+        return A.add(B)
+
+    def __sub__(A, B):
+        if not isinstance(B, DomainMatrix):
+            return NotImplemented
+        A, B = A.unify(B, fmt='dense')
+        return A.sub(B)
+
+    def __neg__(A):
+        return A.neg()
+
+    def __mul__(A, B):
+        """A * B"""
+        if isinstance(B, DomainMatrix):
+            A, B = A.unify(B, fmt='dense')
+            return A.matmul(B)
+        elif B in A.domain:
+            return A.scalarmul(B)
+        elif isinstance(B, DomainScalar):
+            A, B = A.unify(B)
+            return A.scalarmul(B.element)
+        else:
+            return NotImplemented
+
+    def __rmul__(A, B):
+        if B in A.domain:
+            return A.rscalarmul(B)
+        elif isinstance(B, DomainScalar):
+            A, B = A.unify(B)
+            return A.rscalarmul(B.element)
+        else:
+            return NotImplemented
+
+    def __pow__(A, n):
+        """A ** n"""
+        if not isinstance(n, int):
+            return NotImplemented
+        return A.pow(n)
+
+    def _check(a, op, b, ashape, bshape):
+        if a.domain != b.domain:
+            msg = "Domain mismatch: %s %s %s" % (a.domain, op, b.domain)
+            raise DMDomainError(msg)
+        if ashape != bshape:
+            msg = "Shape mismatch: %s %s %s" % (a.shape, op, b.shape)
+            raise DMShapeError(msg)
+        if a.rep.fmt != b.rep.fmt:
+            msg = "Format mismatch: %s %s %s" % (a.rep.fmt, op, b.rep.fmt)
+            raise DMFormatError(msg)
+        if type(a.rep) != type(b.rep):
+            msg = "Type mismatch: %s %s %s" % (type(a.rep), op, type(b.rep))
+            raise DMFormatError(msg)
+
+    def add(A, B):
+        r"""
+        Adds two DomainMatrix matrices of the same Domain
+
+        Parameters
+        ==========
+
+        A, B: DomainMatrix
+            matrices to add
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix after Addition
+
+        Raises
+        ======
+
+        DMShapeError
+            If the dimensions of the two DomainMatrix are not equal
+
+        ValueError
+            If the domain of the two DomainMatrix are not same
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> B = DomainMatrix([
+        ...    [ZZ(4), ZZ(3)],
+        ...    [ZZ(2), ZZ(1)]], (2, 2), ZZ)
+
+        >>> A.add(B)
+        DomainMatrix([[5, 5], [5, 5]], (2, 2), ZZ)
+
+        See Also
+        ========
+
+        sub, matmul
+
+        """
+        A._check('+', B, A.shape, B.shape)
+        return A.from_rep(A.rep.add(B.rep))
+
+
+    def sub(A, B):
+        r"""
+        Subtracts two DomainMatrix matrices of the same Domain
+
+        Parameters
+        ==========
+
+        A, B: DomainMatrix
+            matrices to subtract
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix after Subtraction
+
+        Raises
+        ======
+
+        DMShapeError
+            If the dimensions of the two DomainMatrix are not equal
+
+        ValueError
+            If the domain of the two DomainMatrix are not same
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> B = DomainMatrix([
+        ...    [ZZ(4), ZZ(3)],
+        ...    [ZZ(2), ZZ(1)]], (2, 2), ZZ)
+
+        >>> A.sub(B)
+        DomainMatrix([[-3, -1], [1, 3]], (2, 2), ZZ)
+
+        See Also
+        ========
+
+        add, matmul
+
+        """
+        A._check('-', B, A.shape, B.shape)
+        return A.from_rep(A.rep.sub(B.rep))
+
+    def neg(A):
+        r"""
+        Returns the negative of DomainMatrix
+
+        Parameters
+        ==========
+
+        A : Represents a DomainMatrix
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix after Negation
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+
+        >>> A.neg()
+        DomainMatrix([[-1, -2], [-3, -4]], (2, 2), ZZ)
+
+        """
+        return A.from_rep(A.rep.neg())
+
+    def mul(A, b):
+        r"""
+        Performs term by term multiplication for the second DomainMatrix
+        w.r.t first DomainMatrix. Returns a DomainMatrix whose rows are
+        list of DomainMatrix matrices created after term by term multiplication.
+
+        Parameters
+        ==========
+
+        A, B: DomainMatrix
+            matrices to multiply term-wise
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix after term by term multiplication
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> b = ZZ(2)
+
+        >>> A.mul(b)
+        DomainMatrix([[2, 4], [6, 8]], (2, 2), ZZ)
+
+        See Also
+        ========
+
+        matmul
+
+        """
+        return A.from_rep(A.rep.mul(b))
+
+    def rmul(A, b):
+        return A.from_rep(A.rep.rmul(b))
+
+    def matmul(A, B):
+        r"""
+        Performs matrix multiplication of two DomainMatrix matrices
+
+        Parameters
+        ==========
+
+        A, B: DomainMatrix
+            to multiply
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix after multiplication
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> B = DomainMatrix([
+        ...    [ZZ(1), ZZ(1)],
+        ...    [ZZ(0), ZZ(1)]], (2, 2), ZZ)
+
+        >>> A.matmul(B)
+        DomainMatrix([[1, 3], [3, 7]], (2, 2), ZZ)
+
+        See Also
+        ========
+
+        mul, pow, add, sub
+
+        """
+
+        A._check('*', B, A.shape[1], B.shape[0])
+        return A.from_rep(A.rep.matmul(B.rep))
+
+    def _scalarmul(A, lamda, reverse):
+        if lamda == A.domain.zero:
+            return DomainMatrix.zeros(A.shape, A.domain)
+        elif lamda == A.domain.one:
+            return A.copy()
+        elif reverse:
+            return A.rmul(lamda)
+        else:
+            return A.mul(lamda)
+
+    def scalarmul(A, lamda):
+        return A._scalarmul(lamda, reverse=False)
+
+    def rscalarmul(A, lamda):
+        return A._scalarmul(lamda, reverse=True)
+
+    def mul_elementwise(A, B):
+        assert A.domain == B.domain
+        return A.from_rep(A.rep.mul_elementwise(B.rep))
+
+    def __truediv__(A, lamda):
+        """ Method for Scalar Division"""
+        if isinstance(lamda, int) or ZZ.of_type(lamda):
+            lamda = DomainScalar(ZZ(lamda), ZZ)
+        elif A.domain.is_Field and lamda in A.domain:
+            K = A.domain
+            lamda = DomainScalar(K.convert(lamda), K)
+
+        if not isinstance(lamda, DomainScalar):
+            return NotImplemented
+
+        A, lamda = A.to_field().unify(lamda)
+        if lamda.element == lamda.domain.zero:
+            raise ZeroDivisionError
+        if lamda.element == lamda.domain.one:
+            return A
+
+        return A.mul(1 / lamda.element)
+
+    def pow(A, n):
+        r"""
+        Computes A**n
+
+        Parameters
+        ==========
+
+        A : DomainMatrix
+
+        n : exponent for A
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix on computing A**n
+
+        Raises
+        ======
+
+        NotImplementedError
+            if n is negative.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(1)],
+        ...    [ZZ(0), ZZ(1)]], (2, 2), ZZ)
+
+        >>> A.pow(2)
+        DomainMatrix([[1, 2], [0, 1]], (2, 2), ZZ)
+
+        See Also
+        ========
+
+        matmul
+
+        """
+        nrows, ncols = A.shape
+        if nrows != ncols:
+            raise DMNonSquareMatrixError('Power of a nonsquare matrix')
+        if n < 0:
+            raise NotImplementedError('Negative powers')
+        elif n == 0:
+            return A.eye(nrows, A.domain)
+        elif n == 1:
+            return A
+        elif n % 2 == 1:
+            return A * A**(n - 1)
+        else:
+            sqrtAn = A ** (n // 2)
+            return sqrtAn * sqrtAn
+
+    def scc(self):
+        """Compute the strongly connected components of a DomainMatrix
+
+        Explanation
+        ===========
+
+        A square matrix can be considered as the adjacency matrix for a
+        directed graph where the row and column indices are the vertices. In
+        this graph if there is an edge from vertex ``i`` to vertex ``j`` if
+        ``M[i, j]`` is nonzero. This routine computes the strongly connected
+        components of that graph which are subsets of the rows and columns that
+        are connected by some nonzero element of the matrix. The strongly
+        connected components are useful because many operations such as the
+        determinant can be computed by working with the submatrices
+        corresponding to each component.
+
+        Examples
+        ========
+
+        Find the strongly connected components of a matrix:
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> M = DomainMatrix([[ZZ(1), ZZ(0), ZZ(2)],
+        ...                   [ZZ(0), ZZ(3), ZZ(0)],
+        ...                   [ZZ(4), ZZ(6), ZZ(5)]], (3, 3), ZZ)
+        >>> M.scc()
+        [[1], [0, 2]]
+
+        Compute the determinant from the components:
+
+        >>> MM = M.to_Matrix()
+        >>> MM
+        Matrix([
+        [1, 0, 2],
+        [0, 3, 0],
+        [4, 6, 5]])
+        >>> MM[[1], [1]]
+        Matrix([[3]])
+        >>> MM[[0, 2], [0, 2]]
+        Matrix([
+        [1, 2],
+        [4, 5]])
+        >>> MM.det()
+        -9
+        >>> MM[[1], [1]].det() * MM[[0, 2], [0, 2]].det()
+        -9
+
+        The components are given in reverse topological order and represent a
+        permutation of the rows and columns that will bring the matrix into
+        block lower-triangular form:
+
+        >>> MM[[1, 0, 2], [1, 0, 2]]
+        Matrix([
+        [3, 0, 0],
+        [0, 1, 2],
+        [6, 4, 5]])
+
+        Returns
+        =======
+
+        List of lists of integers
+            Each list represents a strongly connected component.
+
+        See also
+        ========
+
+        sympy.matrices.matrixbase.MatrixBase.strongly_connected_components
+        sympy.utilities.iterables.strongly_connected_components
+
+        """
+        if not self.is_square:
+            raise DMNonSquareMatrixError('Matrix must be square for scc')
+
+        return self.rep.scc()
+
+    def clear_denoms(self, convert=False):
+        """
+        Clear denominators, but keep the domain unchanged.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DM
+        >>> A = DM([[(1,2), (1,3)], [(1,4), (1,5)]], QQ)
+        >>> den, Anum = A.clear_denoms()
+        >>> den.to_sympy()
+        60
+        >>> Anum.to_Matrix()
+        Matrix([
+        [30, 20],
+        [15, 12]])
+        >>> den * A == Anum
+        True
+
+        The numerator matrix will be in the same domain as the original matrix
+        unless ``convert`` is set to ``True``:
+
+        >>> A.clear_denoms()[1].domain
+        QQ
+        >>> A.clear_denoms(convert=True)[1].domain
+        ZZ
+
+        The denominator is always in the associated ring:
+
+        >>> A.clear_denoms()[0].domain
+        ZZ
+        >>> A.domain.get_ring()
+        ZZ
+
+        See Also
+        ========
+
+        sympy.polys.polytools.Poly.clear_denoms
+        clear_denoms_rowwise
+        """
+        elems0, data = self.to_flat_nz()
+
+        K0 = self.domain
+        K1 = K0.get_ring() if K0.has_assoc_Ring else K0
+
+        den, elems1 = dup_clear_denoms(elems0, K0, K1, convert=convert)
+
+        if convert:
+            Kden, Knum = K1, K1
+        else:
+            Kden, Knum = K1, K0
+
+        den = DomainScalar(den, Kden)
+        num = self.from_flat_nz(elems1, data, Knum)
+
+        return den, num
+
+    def clear_denoms_rowwise(self, convert=False):
+        """
+        Clear denominators from each row of the matrix.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DM
+        >>> A = DM([[(1,2), (1,3), (1,4)], [(1,5), (1,6), (1,7)]], QQ)
+        >>> den, Anum = A.clear_denoms_rowwise()
+        >>> den.to_Matrix()
+        Matrix([
+        [12,   0],
+        [ 0, 210]])
+        >>> Anum.to_Matrix()
+        Matrix([
+        [ 6,  4,  3],
+        [42, 35, 30]])
+
+        The denominator matrix is a diagonal matrix with the denominators of
+        each row on the diagonal. The invariants are:
+
+        >>> den * A == Anum
+        True
+        >>> A == den.to_field().inv() * Anum
+        True
+
+        The numerator matrix will be in the same domain as the original matrix
+        unless ``convert`` is set to ``True``:
+
+        >>> A.clear_denoms_rowwise()[1].domain
+        QQ
+        >>> A.clear_denoms_rowwise(convert=True)[1].domain
+        ZZ
+
+        The domain of the denominator matrix is the associated ring:
+
+        >>> A.clear_denoms_rowwise()[0].domain
+        ZZ
+
+        See Also
+        ========
+
+        sympy.polys.polytools.Poly.clear_denoms
+        clear_denoms
+        """
+        dod = self.to_dod()
+
+        K0 = self.domain
+        K1 = K0.get_ring() if K0.has_assoc_Ring else K0
+
+        diagonals = [K0.one] * self.shape[0]
+        dod_num = {}
+        for i, rowi in dod.items():
+            indices, elems = zip(*rowi.items())
+            den, elems_num = dup_clear_denoms(elems, K0, K1, convert=convert)
+            rowi_num = dict(zip(indices, elems_num))
+            diagonals[i] = den
+            dod_num[i] = rowi_num
+
+        if convert:
+            Kden, Knum = K1, K1
+        else:
+            Kden, Knum = K1, K0
+
+        den = self.diag(diagonals, Kden)
+        num = self.from_dod_like(dod_num, Knum)
+
+        return den, num
+
+    def cancel_denom(self, denom):
+        """
+        Cancel factors between a matrix and a denominator.
+
+        Returns a matrix and denominator on lowest terms.
+
+        Requires ``gcd`` in the ground domain.
+
+        Methods like :meth:`solve_den`, :meth:`inv_den` and :meth:`rref_den`
+        return a matrix and denominator but not necessarily on lowest terms.
+        Reduction to lowest terms without fractions can be performed with
+        :meth:`cancel_denom`.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DM
+        >>> from sympy import ZZ
+        >>> M = DM([[2, 2, 0],
+        ...         [0, 2, 2],
+        ...         [0, 0, 2]], ZZ)
+        >>> Minv, den = M.inv_den()
+        >>> Minv.to_Matrix()
+        Matrix([
+        [1, -1,  1],
+        [0,  1, -1],
+        [0,  0,  1]])
+        >>> den
+        2
+        >>> Minv_reduced, den_reduced = Minv.cancel_denom(den)
+        >>> Minv_reduced.to_Matrix()
+        Matrix([
+        [1, -1,  1],
+        [0,  1, -1],
+        [0,  0,  1]])
+        >>> den_reduced
+        2
+        >>> Minv_reduced.to_field() / den_reduced == Minv.to_field() / den
+        True
+
+        The denominator is made canonical with respect to units (e.g. a
+        negative denominator is made positive):
+
+        >>> M = DM([[2, 2, 0]], ZZ)
+        >>> den = ZZ(-4)
+        >>> M.cancel_denom(den)
+        (DomainMatrix([[-1, -1, 0]], (1, 3), ZZ), 2)
+
+        Any factor common to _all_ elements will be cancelled but there can
+        still be factors in common between _some_ elements of the matrix and
+        the denominator. To cancel factors between each element and the
+        denominator, use :meth:`cancel_denom_elementwise` or otherwise convert
+        to a field and use division:
+
+        >>> M = DM([[4, 6]], ZZ)
+        >>> den = ZZ(12)
+        >>> M.cancel_denom(den)
+        (DomainMatrix([[2, 3]], (1, 2), ZZ), 6)
+        >>> numers, denoms = M.cancel_denom_elementwise(den)
+        >>> numers
+        DomainMatrix([[1, 1]], (1, 2), ZZ)
+        >>> denoms
+        DomainMatrix([[3, 2]], (1, 2), ZZ)
+        >>> M.to_field() / den
+        DomainMatrix([[1/3, 1/2]], (1, 2), QQ)
+
+        See Also
+        ========
+
+        solve_den
+        inv_den
+        rref_den
+        cancel_denom_elementwise
+        """
+        M = self
+        K = self.domain
+
+        if K.is_zero(denom):
+            raise ZeroDivisionError('denominator is zero')
+        elif K.is_one(denom):
+            return (M.copy(), denom)
+
+        elements, data = M.to_flat_nz()
+
+        # First canonicalize the denominator (e.g. multiply by -1).
+        if K.is_negative(denom):
+            u = -K.one
+        else:
+            u = K.canonical_unit(denom)
+
+        # Often after e.g. solve_den the denominator will be much more
+        # complicated than the elements of the numerator. Hopefully it will be
+        # quicker to find the gcd of the numerator and if there is no content
+        # then we do not need to look at the denominator at all.
+        content = dup_content(elements, K)
+        common = K.gcd(content, denom)
+
+        if not K.is_one(content):
+
+            common = K.gcd(content, denom)
+
+            if not K.is_one(common):
+                elements = dup_quo_ground(elements, common, K)
+                denom = K.quo(denom, common)
+
+        if not K.is_one(u):
+            elements = dup_mul_ground(elements, u, K)
+            denom = u * denom
+        elif K.is_one(common):
+            return (M.copy(), denom)
+
+        M_cancelled = M.from_flat_nz(elements, data, K)
+
+        return M_cancelled, denom
+
+    def cancel_denom_elementwise(self, denom):
+        """
+        Cancel factors between the elements of a matrix and a denominator.
+
+        Returns a matrix of numerators and matrix of denominators.
+
+        Requires ``gcd`` in the ground domain.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DM
+        >>> from sympy import ZZ
+        >>> M = DM([[2, 3], [4, 12]], ZZ)
+        >>> denom = ZZ(6)
+        >>> numers, denoms = M.cancel_denom_elementwise(denom)
+        >>> numers.to_Matrix()
+        Matrix([
+        [1, 1],
+        [2, 2]])
+        >>> denoms.to_Matrix()
+        Matrix([
+        [3, 2],
+        [3, 1]])
+        >>> M_frac = (M.to_field() / denom).to_Matrix()
+        >>> M_frac
+        Matrix([
+        [1/3, 1/2],
+        [2/3,   2]])
+        >>> denoms_inverted = denoms.to_Matrix().applyfunc(lambda e: 1/e)
+        >>> numers.to_Matrix().multiply_elementwise(denoms_inverted) == M_frac
+        True
+
+        Use :meth:`cancel_denom` to cancel factors between the matrix and the
+        denominator while preserving the form of a matrix with a scalar
+        denominator.
+
+        See Also
+        ========
+
+        cancel_denom
+        """
+        K = self.domain
+        M = self
+
+        if K.is_zero(denom):
+            raise ZeroDivisionError('denominator is zero')
+        elif K.is_one(denom):
+            M_numers = M.copy()
+            M_denoms = M.ones(M.shape, M.domain)
+            return (M_numers, M_denoms)
+
+        elements, data = M.to_flat_nz()
+
+        cofactors = [K.cofactors(numer, denom) for numer in elements]
+        gcds, numers, denoms = zip(*cofactors)
+
+        M_numers = M.from_flat_nz(list(numers), data, K)
+        M_denoms = M.from_flat_nz(list(denoms), data, K)
+
+        return (M_numers, M_denoms)
+
+    def content(self):
+        """
+        Return the gcd of the elements of the matrix.
+
+        Requires ``gcd`` in the ground domain.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DM
+        >>> from sympy import ZZ
+        >>> M = DM([[2, 4], [4, 12]], ZZ)
+        >>> M.content()
+        2
+
+        See Also
+        ========
+
+        primitive
+        cancel_denom
+        """
+        K = self.domain
+        elements, _ = self.to_flat_nz()
+        return dup_content(elements, K)
+
+    def primitive(self):
+        """
+        Factor out gcd of the elements of a matrix.
+
+        Requires ``gcd`` in the ground domain.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DM
+        >>> from sympy import ZZ
+        >>> M = DM([[2, 4], [4, 12]], ZZ)
+        >>> content, M_primitive = M.primitive()
+        >>> content
+        2
+        >>> M_primitive
+        DomainMatrix([[1, 2], [2, 6]], (2, 2), ZZ)
+        >>> content * M_primitive == M
+        True
+        >>> M_primitive.content() == ZZ(1)
+        True
+
+        See Also
+        ========
+
+        content
+        cancel_denom
+        """
+        K = self.domain
+        elements, data = self.to_flat_nz()
+        content, prims = dup_primitive(elements, K)
+        M_primitive = self.from_flat_nz(prims, data, K)
+        return content, M_primitive
+
+    def rref(self, *, method='auto'):
+        r"""
+        Returns reduced-row echelon form (RREF) and list of pivots.
+
+        If the domain is not a field then it will be converted to a field. See
+        :meth:`rref_den` for the fraction-free version of this routine that
+        returns RREF with denominator instead.
+
+        The domain must either be a field or have an associated fraction field
+        (see :meth:`to_field`).
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...     [QQ(2), QQ(-1), QQ(0)],
+        ...     [QQ(-1), QQ(2), QQ(-1)],
+        ...     [QQ(0), QQ(0), QQ(2)]], (3, 3), QQ)
+
+        >>> rref_matrix, rref_pivots = A.rref()
+        >>> rref_matrix
+        DomainMatrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]], (3, 3), QQ)
+        >>> rref_pivots
+        (0, 1, 2)
+
+        Parameters
+        ==========
+
+        method : str, optional (default: 'auto')
+            The method to use to compute the RREF. The default is ``'auto'``,
+            which will attempt to choose the fastest method. The other options
+            are:
+
+            - ``A.rref(method='GJ')`` uses Gauss-Jordan elimination with
+              division. If the domain is not a field then it will be converted
+              to a field with :meth:`to_field` first and RREF will be computed
+              by inverting the pivot elements in each row. This is most
+              efficient for very sparse matrices or for matrices whose elements
+              have complex denominators.
+
+            - ``A.rref(method='FF')`` uses fraction-free Gauss-Jordan
+              elimination. Elimination is performed using exact division
+              (``exquo``) to control the growth of the coefficients. In this
+              case the current domain is always used for elimination but if
+              the domain is not a field then it will be converted to a field
+              at the end and divided by the denominator. This is most efficient
+              for dense matrices or for matrices with simple denominators.
+
+            - ``A.rref(method='CD')`` clears the denominators before using
+              fraction-free Gauss-Jordan elimination in the assoicated ring.
+              This is most efficient for dense matrices with very simple
+              denominators.
+
+            - ``A.rref(method='GJ_dense')``, ``A.rref(method='FF_dense')``, and
+              ``A.rref(method='CD_dense')`` are the same as the above methods
+              except that the dense implementations of the algorithms are used.
+              By default ``A.rref(method='auto')`` will usually choose the
+              sparse implementations for RREF.
+
+            Regardless of which algorithm is used the returned matrix will
+            always have the same format (sparse or dense) as the input and its
+            domain will always be the field of fractions of the input domain.
+
+        Returns
+        =======
+
+        (DomainMatrix, list)
+            reduced-row echelon form and list of pivots for the DomainMatrix
+
+        See Also
+        ========
+
+        rref_den
+            RREF with denominator
+        sympy.polys.matrices.sdm.sdm_irref
+            Sparse implementation of ``method='GJ'``.
+        sympy.polys.matrices.sdm.sdm_rref_den
+            Sparse implementation of ``method='FF'`` and ``method='CD'``.
+        sympy.polys.matrices.dense.ddm_irref
+            Dense implementation of ``method='GJ'``.
+        sympy.polys.matrices.dense.ddm_irref_den
+            Dense implementation of ``method='FF'`` and ``method='CD'``.
+        clear_denoms
+            Clear denominators from a matrix, used by ``method='CD'`` and
+            by ``method='GJ'`` when the original domain is not a field.
+
+        """
+        return _dm_rref(self, method=method)
+
+    def rref_den(self, *, method='auto', keep_domain=True):
+        r"""
+        Returns reduced-row echelon form with denominator and list of pivots.
+
+        Requires exact division in the ground domain (``exquo``).
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ, QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...     [ZZ(2), ZZ(-1), ZZ(0)],
+        ...     [ZZ(-1), ZZ(2), ZZ(-1)],
+        ...     [ZZ(0), ZZ(0), ZZ(2)]], (3, 3), ZZ)
+
+        >>> A_rref, denom, pivots = A.rref_den()
+        >>> A_rref
+        DomainMatrix([[6, 0, 0], [0, 6, 0], [0, 0, 6]], (3, 3), ZZ)
+        >>> denom
+        6
+        >>> pivots
+        (0, 1, 2)
+        >>> A_rref.to_field() / denom
+        DomainMatrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]], (3, 3), QQ)
+        >>> A_rref.to_field() / denom == A.convert_to(QQ).rref()[0]
+        True
+
+        Parameters
+        ==========
+
+        method : str, optional (default: 'auto')
+            The method to use to compute the RREF. The default is ``'auto'``,
+            which will attempt to choose the fastest method. The other options
+            are:
+
+            - ``A.rref(method='FF')`` uses fraction-free Gauss-Jordan
+              elimination. Elimination is performed using exact division
+              (``exquo``) to control the growth of the coefficients. In this
+              case the current domain is always used for elimination and the
+              result is always returned as a matrix over the current domain.
+              This is most efficient for dense matrices or for matrices with
+              simple denominators.
+
+            - ``A.rref(method='CD')`` clears denominators before using
+              fraction-free Gauss-Jordan elimination in the assoicated ring.
+              The result will be converted back to the original domain unless
+              ``keep_domain=False`` is passed in which case the result will be
+              over the ring used for elimination. This is most efficient for
+              dense matrices with very simple denominators.
+
+            - ``A.rref(method='GJ')`` uses Gauss-Jordan elimination with
+              division. If the domain is not a field then it will be converted
+              to a field with :meth:`to_field` first and RREF will be computed
+              by inverting the pivot elements in each row. The result is
+              converted back to the original domain by clearing denominators
+              unless ``keep_domain=False`` is passed in which case the result
+              will be over the field used for elimination. This is most
+              efficient for very sparse matrices or for matrices whose elements
+              have complex denominators.
+
+            - ``A.rref(method='GJ_dense')``, ``A.rref(method='FF_dense')``, and
+              ``A.rref(method='CD_dense')`` are the same as the above methods
+              except that the dense implementations of the algorithms are used.
+              By default ``A.rref(method='auto')`` will usually choose the
+              sparse implementations for RREF.
+
+            Regardless of which algorithm is used the returned matrix will
+            always have the same format (sparse or dense) as the input and if
+            ``keep_domain=True`` its domain will always be the same as the
+            input.
+
+        keep_domain : bool, optional
+            If True (the default), the domain of the returned matrix and
+            denominator are the same as the domain of the input matrix. If
+            False, the domain of the returned matrix might be changed to an
+            associated ring or field if the algorithm used a different domain.
+            This is useful for efficiency if the caller does not need the
+            result to be in the original domain e.g. it avoids clearing
+            denominators in the case of ``A.rref(method='GJ')``.
+
+        Returns
+        =======
+
+        (DomainMatrix, scalar, list)
+            Reduced-row echelon form, denominator and list of pivot indices.
+
+        See Also
+        ========
+
+        rref
+            RREF without denominator for field domains.
+        sympy.polys.matrices.sdm.sdm_irref
+            Sparse implementation of ``method='GJ'``.
+        sympy.polys.matrices.sdm.sdm_rref_den
+            Sparse implementation of ``method='FF'`` and ``method='CD'``.
+        sympy.polys.matrices.dense.ddm_irref
+            Dense implementation of ``method='GJ'``.
+        sympy.polys.matrices.dense.ddm_irref_den
+            Dense implementation of ``method='FF'`` and ``method='CD'``.
+        clear_denoms
+            Clear denominators from a matrix, used by ``method='CD'``.
+
+        """
+        return _dm_rref_den(self, method=method, keep_domain=keep_domain)
+
+    def columnspace(self):
+        r"""
+        Returns the columnspace for the DomainMatrix
+
+        Returns
+        =======
+
+        DomainMatrix
+            The columns of this matrix form a basis for the columnspace.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [QQ(1), QQ(-1)],
+        ...    [QQ(2), QQ(-2)]], (2, 2), QQ)
+        >>> A.columnspace()
+        DomainMatrix([[1], [2]], (2, 1), QQ)
+
+        """
+        if not self.domain.is_Field:
+            raise DMNotAField('Not a field')
+        rref, pivots = self.rref()
+        rows, cols = self.shape
+        return self.extract(range(rows), pivots)
+
+    def rowspace(self):
+        r"""
+        Returns the rowspace for the DomainMatrix
+
+        Returns
+        =======
+
+        DomainMatrix
+            The rows of this matrix form a basis for the rowspace.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [QQ(1), QQ(-1)],
+        ...    [QQ(2), QQ(-2)]], (2, 2), QQ)
+        >>> A.rowspace()
+        DomainMatrix([[1, -1]], (1, 2), QQ)
+
+        """
+        if not self.domain.is_Field:
+            raise DMNotAField('Not a field')
+        rref, pivots = self.rref()
+        rows, cols = self.shape
+        return self.extract(range(len(pivots)), range(cols))
+
+    def nullspace(self, divide_last=False):
+        r"""
+        Returns the nullspace for the DomainMatrix
+
+        Returns
+        =======
+
+        DomainMatrix
+            The rows of this matrix form a basis for the nullspace.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DM
+        >>> A = DM([
+        ...    [QQ(2), QQ(-2)],
+        ...    [QQ(4), QQ(-4)]], QQ)
+        >>> A.nullspace()
+        DomainMatrix([[1, 1]], (1, 2), QQ)
+
+        The returned matrix is a basis for the nullspace:
+
+        >>> A_null = A.nullspace().transpose()
+        >>> A * A_null
+        DomainMatrix([[0], [0]], (2, 1), QQ)
+        >>> rows, cols = A.shape
+        >>> nullity = rows - A.rank()
+        >>> A_null.shape == (cols, nullity)
+        True
+
+        Nullspace can also be computed for non-field rings. If the ring is not
+        a field then division is not used. Setting ``divide_last`` to True will
+        raise an error in this case:
+
+        >>> from sympy import ZZ
+        >>> B = DM([[6, -3],
+        ...         [4, -2]], ZZ)
+        >>> B.nullspace()
+        DomainMatrix([[3, 6]], (1, 2), ZZ)
+        >>> B.nullspace(divide_last=True)
+        Traceback (most recent call last):
+        ...
+        DMNotAField: Cannot normalize vectors over a non-field
+
+        Over a ring with ``gcd`` defined the nullspace can potentially be
+        reduced with :meth:`primitive`:
+
+        >>> B.nullspace().primitive()
+        (3, DomainMatrix([[1, 2]], (1, 2), ZZ))
+
+        A matrix over a ring can often be normalized by converting it to a
+        field but it is often a bad idea to do so:
+
+        >>> from sympy.abc import a, b, c
+        >>> from sympy import Matrix
+        >>> M = Matrix([[        a*b,       b + c,        c],
+        ...             [      a - b,         b*c,     c**2],
+        ...             [a*b + a - b, b*c + b + c, c**2 + c]])
+        >>> M.to_DM().domain
+        ZZ[a,b,c]
+        >>> M.to_DM().nullspace().to_Matrix().transpose()
+        Matrix([
+        [                             c**3],
+        [            -a*b*c**2 + a*c - b*c],
+        [a*b**2*c - a*b - a*c + b**2 + b*c]])
+
+        The unnormalized form here is nicer than the normalized form that
+        spreads a large denominator throughout the matrix:
+
+        >>> M.to_DM().to_field().nullspace(divide_last=True).to_Matrix().transpose()
+        Matrix([
+        [                   c**3/(a*b**2*c - a*b - a*c + b**2 + b*c)],
+        [(-a*b*c**2 + a*c - b*c)/(a*b**2*c - a*b - a*c + b**2 + b*c)],
+        [                                                          1]])
+
+        Parameters
+        ==========
+
+        divide_last : bool, optional
+            If False (the default), the vectors are not normalized and the RREF
+            is computed using :meth:`rref_den` and the denominator is
+            discarded. If True, then each row is divided by its final element;
+            the domain must be a field in this case.
+
+        See Also
+        ========
+
+        nullspace_from_rref
+        rref
+        rref_den
+        rowspace
+        """
+        A = self
+        K = A.domain
+
+        if divide_last and not K.is_Field:
+            raise DMNotAField("Cannot normalize vectors over a non-field")
+
+        if divide_last:
+            A_rref, pivots = A.rref()
+        else:
+            A_rref, den, pivots = A.rref_den()
+
+            # Ensure that the sign is canonical before discarding the
+            # denominator. Then M.nullspace().primitive() is canonical.
+            u = K.canonical_unit(den)
+            if u != K.one:
+                A_rref *= u
+
+        A_null = A_rref.nullspace_from_rref(pivots)
+
+        return A_null
+
+    def nullspace_from_rref(self, pivots=None):
+        """
+        Compute nullspace from rref and pivots.
+
+        The domain of the matrix can be any domain.
+
+        The matrix must be in reduced row echelon form already. Otherwise the
+        result will be incorrect. Use :meth:`rref` or :meth:`rref_den` first
+        to get the reduced row echelon form or use :meth:`nullspace` instead.
+
+        See Also
+        ========
+
+        nullspace
+        rref
+        rref_den
+        sympy.polys.matrices.sdm.SDM.nullspace_from_rref
+        sympy.polys.matrices.ddm.DDM.nullspace_from_rref
+        """
+        null_rep, nonpivots = self.rep.nullspace_from_rref(pivots)
+        return self.from_rep(null_rep)
+
+    def inv(self):
+        r"""
+        Finds the inverse of the DomainMatrix if exists
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix after inverse
+
+        Raises
+        ======
+
+        ValueError
+            If the domain of DomainMatrix not a Field
+
+        DMNonSquareMatrixError
+            If the DomainMatrix is not a not Square DomainMatrix
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...     [QQ(2), QQ(-1), QQ(0)],
+        ...     [QQ(-1), QQ(2), QQ(-1)],
+        ...     [QQ(0), QQ(0), QQ(2)]], (3, 3), QQ)
+        >>> A.inv()
+        DomainMatrix([[2/3, 1/3, 1/6], [1/3, 2/3, 1/3], [0, 0, 1/2]], (3, 3), QQ)
+
+        See Also
+        ========
+
+        neg
+
+        """
+        if not self.domain.is_Field:
+            raise DMNotAField('Not a field')
+        m, n = self.shape
+        if m != n:
+            raise DMNonSquareMatrixError
+        inv = self.rep.inv()
+        return self.from_rep(inv)
+
+    def det(self):
+        r"""
+        Returns the determinant of a square :class:`DomainMatrix`.
+
+        Returns
+        =======
+
+        determinant: DomainElement
+            Determinant of the matrix.
+
+        Raises
+        ======
+
+        ValueError
+            If the domain of DomainMatrix is not a Field
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+
+        >>> A.det()
+        -2
+
+        """
+        m, n = self.shape
+        if m != n:
+            raise DMNonSquareMatrixError
+        return self.rep.det()
+
+    def adj_det(self):
+        """
+        Adjugate and determinant of a square :class:`DomainMatrix`.
+
+        Returns
+        =======
+
+        (adjugate, determinant) : (DomainMatrix, DomainScalar)
+            The adjugate matrix and determinant of this matrix.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DM
+        >>> A = DM([
+        ...     [ZZ(1), ZZ(2)],
+        ...     [ZZ(3), ZZ(4)]], ZZ)
+        >>> adjA, detA = A.adj_det()
+        >>> adjA
+        DomainMatrix([[4, -2], [-3, 1]], (2, 2), ZZ)
+        >>> detA
+        -2
+
+        See Also
+        ========
+
+        adjugate
+            Returns only the adjugate matrix.
+        det
+            Returns only the determinant.
+        inv_den
+            Returns a matrix/denominator pair representing the inverse matrix
+            but perhaps differing from the adjugate and determinant by a common
+            factor.
+        """
+        m, n = self.shape
+        I_m = self.eye((m, m), self.domain)
+        adjA, detA = self.solve_den_charpoly(I_m, check=False)
+        if self.rep.fmt == "dense":
+            adjA = adjA.to_dense()
+        return adjA, detA
+
+    def adjugate(self):
+        """
+        Adjugate of a square :class:`DomainMatrix`.
+
+        The adjugate matrix is the transpose of the cofactor matrix and is
+        related to the inverse by::
+
+            adj(A) = det(A) * A.inv()
+
+        Unlike the inverse matrix the adjugate matrix can be computed and
+        expressed without division or fractions in the ground domain.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DM
+        >>> A = DM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], ZZ)
+        >>> A.adjugate()
+        DomainMatrix([[4, -2], [-3, 1]], (2, 2), ZZ)
+
+        Returns
+        =======
+
+        DomainMatrix
+            The adjugate matrix of this matrix with the same domain.
+
+        See Also
+        ========
+
+        adj_det
+        """
+        adjA, detA = self.adj_det()
+        return adjA
+
+    def inv_den(self, method=None):
+        """
+        Return the inverse as a :class:`DomainMatrix` with denominator.
+
+        Returns
+        =======
+
+        (inv, den) : (:class:`DomainMatrix`, :class:`~.DomainElement`)
+            The inverse matrix and its denominator.
+
+        This is more or less equivalent to :meth:`adj_det` except that ``inv``
+        and ``den`` are not guaranteed to be the adjugate and inverse. The
+        ratio ``inv/den`` is equivalent to ``adj/det`` but some factors
+        might be cancelled between ``inv`` and ``den``. In simple cases this
+        might just be a minus sign so that ``(inv, den) == (-adj, -det)`` but
+        factors more complicated than ``-1`` can also be cancelled.
+        Cancellation is not guaranteed to be complete so ``inv`` and ``den``
+        may not be on lowest terms. The denominator ``den`` will be zero if and
+        only if the determinant is zero.
+
+        If the actual adjugate and determinant are needed, use :meth:`adj_det`
+        instead. If the intention is to compute the inverse matrix or solve a
+        system of equations then :meth:`inv_den` is more efficient.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...     [ZZ(2), ZZ(-1), ZZ(0)],
+        ...     [ZZ(-1), ZZ(2), ZZ(-1)],
+        ...     [ZZ(0), ZZ(0), ZZ(2)]], (3, 3), ZZ)
+        >>> Ainv, den = A.inv_den()
+        >>> den
+        6
+        >>> Ainv
+        DomainMatrix([[4, 2, 1], [2, 4, 2], [0, 0, 3]], (3, 3), ZZ)
+        >>> A * Ainv == den * A.eye(A.shape, A.domain).to_dense()
+        True
+
+        Parameters
+        ==========
+
+        method : str, optional
+            The method to use to compute the inverse. Can be one of ``None``,
+            ``'rref'`` or ``'charpoly'``. If ``None`` then the method is
+            chosen automatically (see :meth:`solve_den` for details).
+
+        See Also
+        ========
+
+        inv
+        det
+        adj_det
+        solve_den
+        """
+        I = self.eye(self.shape, self.domain)
+        return self.solve_den(I, method=method)
+
+    def solve_den(self, b, method=None):
+        """
+        Solve matrix equation $Ax = b$ without fractions in the ground domain.
+
+        Examples
+        ========
+
+        Solve a matrix equation over the integers:
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DM
+        >>> A = DM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], ZZ)
+        >>> b = DM([[ZZ(5)], [ZZ(6)]], ZZ)
+        >>> xnum, xden = A.solve_den(b)
+        >>> xden
+        -2
+        >>> xnum
+        DomainMatrix([[8], [-9]], (2, 1), ZZ)
+        >>> A * xnum == xden * b
+        True
+
+        Solve a matrix equation over a polynomial ring:
+
+        >>> from sympy import ZZ
+        >>> from sympy.abc import x, y, z, a, b
+        >>> R = ZZ[x, y, z, a, b]
+        >>> M = DM([[x*y, x*z], [y*z, x*z]], R)
+        >>> b = DM([[a], [b]], R)
+        >>> M.to_Matrix()
+        Matrix([
+        [x*y, x*z],
+        [y*z, x*z]])
+        >>> b.to_Matrix()
+        Matrix([
+        [a],
+        [b]])
+        >>> xnum, xden = M.solve_den(b)
+        >>> xden
+        x**2*y*z - x*y*z**2
+        >>> xnum.to_Matrix()
+        Matrix([
+        [ a*x*z - b*x*z],
+        [-a*y*z + b*x*y]])
+        >>> M * xnum == xden * b
+        True
+
+        The solution can be expressed over a fraction field which will cancel
+        gcds between the denominator and the elements of the numerator:
+
+        >>> xsol = xnum.to_field() / xden
+        >>> xsol.to_Matrix()
+        Matrix([
+        [           (a - b)/(x*y - y*z)],
+        [(-a*z + b*x)/(x**2*z - x*z**2)]])
+        >>> (M * xsol).to_Matrix() == b.to_Matrix()
+        True
+
+        When solving a large system of equations this cancellation step might
+        be a lot slower than :func:`solve_den` itself. The solution can also be
+        expressed as a ``Matrix`` without attempting any polynomial
+        cancellation between the numerator and denominator giving a less
+        simplified result more quickly:
+
+        >>> xsol_uncancelled = xnum.to_Matrix() / xnum.domain.to_sympy(xden)
+        >>> xsol_uncancelled
+        Matrix([
+        [ (a*x*z - b*x*z)/(x**2*y*z - x*y*z**2)],
+        [(-a*y*z + b*x*y)/(x**2*y*z - x*y*z**2)]])
+        >>> from sympy import cancel
+        >>> cancel(xsol_uncancelled) == xsol.to_Matrix()
+        True
+
+        Parameters
+        ==========
+
+        self : :class:`DomainMatrix`
+            The ``m x n`` matrix $A$ in the equation $Ax = b$. Underdetermined
+            systems are not supported so ``m >= n``: $A$ should be square or
+            have more rows than columns.
+        b : :class:`DomainMatrix`
+            The ``n x m`` matrix $b$ for the rhs.
+        cp : list of :class:`~.DomainElement`, optional
+            The characteristic polynomial of the matrix $A$. If not given, it
+            will be computed using :meth:`charpoly`.
+        method: str, optional
+            The method to use for solving the system. Can be one of ``None``,
+            ``'charpoly'`` or ``'rref'``. If ``None`` (the default) then the
+            method will be chosen automatically.
+
+            The ``charpoly`` method uses :meth:`solve_den_charpoly` and can
+            only be used if the matrix is square. This method is division free
+            and can be used with any domain.
+
+            The ``rref`` method is fraction free but requires exact division
+            in the ground domain (``exquo``). This is also suitable for most
+            domains. This method can be used with overdetermined systems (more
+            equations than unknowns) but not underdetermined systems as a
+            unique solution is sought.
+
+        Returns
+        =======
+
+        (xnum, xden) : (DomainMatrix, DomainElement)
+            The solution of the equation $Ax = b$ as a pair consisting of an
+            ``n x m`` matrix numerator ``xnum`` and a scalar denominator
+            ``xden``.
+
+        The solution $x$ is given by ``x = xnum / xden``. The division free
+        invariant is ``A * xnum == xden * b``. If $A$ is square then the
+        denominator ``xden`` will be a divisor of the determinant $det(A)$.
+
+        Raises
+        ======
+
+        DMNonInvertibleMatrixError
+            If the system $Ax = b$ does not have a unique solution.
+
+        See Also
+        ========
+
+        solve_den_charpoly
+        solve_den_rref
+        inv_den
+        """
+        m, n = self.shape
+        bm, bn = b.shape
+
+        if m != bm:
+            raise DMShapeError("Matrix equation shape mismatch.")
+
+        if method is None:
+            method = 'rref'
+        elif method == 'charpoly' and m != n:
+            raise DMNonSquareMatrixError("method='charpoly' requires a square matrix.")
+
+        if method == 'charpoly':
+            xnum, xden = self.solve_den_charpoly(b)
+        elif method == 'rref':
+            xnum, xden = self.solve_den_rref(b)
+        else:
+            raise DMBadInputError("method should be 'rref' or 'charpoly'")
+
+        return xnum, xden
+
+    def solve_den_rref(self, b):
+        """
+        Solve matrix equation $Ax = b$ using fraction-free RREF
+
+        Solves the matrix equation $Ax = b$ for $x$ and returns the solution
+        as a numerator/denominator pair.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DM
+        >>> A = DM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], ZZ)
+        >>> b = DM([[ZZ(5)], [ZZ(6)]], ZZ)
+        >>> xnum, xden = A.solve_den_rref(b)
+        >>> xden
+        -2
+        >>> xnum
+        DomainMatrix([[8], [-9]], (2, 1), ZZ)
+        >>> A * xnum == xden * b
+        True
+
+        See Also
+        ========
+
+        solve_den
+        solve_den_charpoly
+        """
+        A = self
+        m, n = A.shape
+        bm, bn = b.shape
+
+        if m != bm:
+            raise DMShapeError("Matrix equation shape mismatch.")
+
+        if m < n:
+            raise DMShapeError("Underdetermined matrix equation.")
+
+        Aaug = A.hstack(b)
+        Aaug_rref, denom, pivots = Aaug.rref_den()
+
+        # XXX: We check here if there are pivots after the last column. If
+        # there were than it possibly means that rref_den performed some
+        # unnecessary elimination. It would be better if rref methods had a
+        # parameter indicating how many columns should be used for elimination.
+        if len(pivots) != n or pivots and pivots[-1] >= n:
+            raise DMNonInvertibleMatrixError("Non-unique solution.")
+
+        xnum = Aaug_rref[:n, n:]
+        xden = denom
+
+        return xnum, xden
+
+    def solve_den_charpoly(self, b, cp=None, check=True):
+        """
+        Solve matrix equation $Ax = b$ using the characteristic polynomial.
+
+        This method solves the square matrix equation $Ax = b$ for $x$ using
+        the characteristic polynomial without any division or fractions in the
+        ground domain.
+
+        Examples
+        ========
+
+        Solve a matrix equation over the integers:
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DM
+        >>> A = DM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], ZZ)
+        >>> b = DM([[ZZ(5)], [ZZ(6)]], ZZ)
+        >>> xnum, detA = A.solve_den_charpoly(b)
+        >>> detA
+        -2
+        >>> xnum
+        DomainMatrix([[8], [-9]], (2, 1), ZZ)
+        >>> A * xnum == detA * b
+        True
+
+        Parameters
+        ==========
+
+        self : DomainMatrix
+            The ``n x n`` matrix `A` in the equation `Ax = b`. Must be square
+            and invertible.
+        b : DomainMatrix
+            The ``n x m`` matrix `b` for the rhs.
+        cp : list, optional
+            The characteristic polynomial of the matrix `A` if known. If not
+            given, it will be computed using :meth:`charpoly`.
+        check : bool, optional
+            If ``True`` (the default) check that the determinant is not zero
+            and raise an error if it is. If ``False`` then if the determinant
+            is zero the return value will be equal to ``(A.adjugate()*b, 0)``.
+
+        Returns
+        =======
+
+        (xnum, detA) : (DomainMatrix, DomainElement)
+            The solution of the equation `Ax = b` as a matrix numerator and
+            scalar denominator pair. The denominator is equal to the
+            determinant of `A` and the numerator is ``adj(A)*b``.
+
+        The solution $x$ is given by ``x = xnum / detA``. The division free
+        invariant is ``A * xnum == detA * b``.
+
+        If ``b`` is the identity matrix, then ``xnum`` is the adjugate matrix
+        and we have ``A * adj(A) == detA * I``.
+
+        See Also
+        ========
+
+        solve_den
+            Main frontend for solving matrix equations with denominator.
+        solve_den_rref
+            Solve matrix equations using fraction-free RREF.
+        inv_den
+            Invert a matrix using the characteristic polynomial.
+        """
+        A, b = self.unify(b)
+        m, n = self.shape
+        mb, nb = b.shape
+
+        if m != n:
+            raise DMNonSquareMatrixError("Matrix must be square")
+
+        if mb != m:
+            raise DMShapeError("Matrix and vector must have the same number of rows")
+
+        f, detA = self.adj_poly_det(cp=cp)
+
+        if check and not detA:
+            raise DMNonInvertibleMatrixError("Matrix is not invertible")
+
+        # Compute adj(A)*b = det(A)*inv(A)*b using Horner's method without
+        # constructing inv(A) explicitly.
+        adjA_b = self.eval_poly_mul(f, b)
+
+        return (adjA_b, detA)
+
+    def adj_poly_det(self, cp=None):
+        """
+        Return the polynomial $p$ such that $p(A) = adj(A)$ and also the
+        determinant of $A$.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DM
+        >>> A = DM([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], QQ)
+        >>> p, detA = A.adj_poly_det()
+        >>> p
+        [-1, 5]
+        >>> p_A = A.eval_poly(p)
+        >>> p_A
+        DomainMatrix([[4, -2], [-3, 1]], (2, 2), QQ)
+        >>> p[0]*A**1 + p[1]*A**0 == p_A
+        True
+        >>> p_A == A.adjugate()
+        True
+        >>> A * A.adjugate() == detA * A.eye(A.shape, A.domain).to_dense()
+        True
+
+        See Also
+        ========
+
+        adjugate
+        eval_poly
+        adj_det
+        """
+
+        # Cayley-Hamilton says that a matrix satisfies its own minimal
+        # polynomial
+        #
+        #   p[0]*A^n + p[1]*A^(n-1) + ... + p[n]*I = 0
+        #
+        # with p[0]=1 and p[n]=(-1)^n*det(A) or
+        #
+        #   det(A)*I = -(-1)^n*(p[0]*A^(n-1) + p[1]*A^(n-2) + ... + p[n-1]*A).
+        #
+        # Define a new polynomial f with f[i] = -(-1)^n*p[i] for i=0..n-1. Then
+        #
+        #   det(A)*I = f[0]*A^n + f[1]*A^(n-1) + ... + f[n-1]*A.
+        #
+        # Multiplying on the right by inv(A) gives
+        #
+        #   det(A)*inv(A) = f[0]*A^(n-1) + f[1]*A^(n-2) + ... + f[n-1].
+        #
+        # So adj(A) = det(A)*inv(A) = f(A)
+
+        A = self
+        m, n = self.shape
+
+        if m != n:
+            raise DMNonSquareMatrixError("Matrix must be square")
+
+        if cp is None:
+            cp = A.charpoly()
+
+        if len(cp) % 2:
+            # n is even
+            detA = cp[-1]
+            f = [-cpi for cpi in cp[:-1]]
+        else:
+            # n is odd
+            detA = -cp[-1]
+            f = cp[:-1]
+
+        return f, detA
+
+    def eval_poly(self, p):
+        """
+        Evaluate polynomial function of a matrix $p(A)$.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DM
+        >>> A = DM([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], QQ)
+        >>> p = [QQ(1), QQ(2), QQ(3)]
+        >>> p_A = A.eval_poly(p)
+        >>> p_A
+        DomainMatrix([[12, 14], [21, 33]], (2, 2), QQ)
+        >>> p_A == p[0]*A**2 + p[1]*A + p[2]*A**0
+        True
+
+        See Also
+        ========
+
+        eval_poly_mul
+        """
+        A = self
+        m, n = A.shape
+
+        if m != n:
+            raise DMNonSquareMatrixError("Matrix must be square")
+
+        if not p:
+            return self.zeros(self.shape, self.domain)
+        elif len(p) == 1:
+            return p[0] * self.eye(self.shape, self.domain)
+
+        # Evaluate p(A) using Horner's method:
+        # XXX: Use Paterson-Stockmeyer method?
+        I = A.eye(A.shape, A.domain)
+        p_A = p[0] * I
+        for pi in p[1:]:
+            p_A = A*p_A + pi*I
+
+        return p_A
+
+    def eval_poly_mul(self, p, B):
+        r"""
+        Evaluate polynomial matrix product $p(A) \times B$.
+
+        Evaluate the polynomial matrix product $p(A) \times B$ using Horner's
+        method without creating the matrix $p(A)$ explicitly. If $B$ is a
+        column matrix then this method will only use matrix-vector multiplies
+        and no matrix-matrix multiplies are needed.
+
+        If $B$ is square or wide or if $A$ can be represented in a simpler
+        domain than $B$ then it might be faster to evaluate $p(A)$ explicitly
+        (see :func:`eval_poly`) and then multiply with $B$.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DM
+        >>> A = DM([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], QQ)
+        >>> b = DM([[QQ(5)], [QQ(6)]], QQ)
+        >>> p = [QQ(1), QQ(2), QQ(3)]
+        >>> p_A_b = A.eval_poly_mul(p, b)
+        >>> p_A_b
+        DomainMatrix([[144], [303]], (2, 1), QQ)
+        >>> p_A_b == p[0]*A**2*b + p[1]*A*b + p[2]*b
+        True
+        >>> A.eval_poly_mul(p, b) == A.eval_poly(p)*b
+        True
+
+        See Also
+        ========
+
+        eval_poly
+        solve_den_charpoly
+        """
+        A = self
+        m, n = A.shape
+        mb, nb = B.shape
+
+        if m != n:
+            raise DMNonSquareMatrixError("Matrix must be square")
+
+        if mb != n:
+            raise DMShapeError("Matrices are not aligned")
+
+        if A.domain != B.domain:
+            raise DMDomainError("Matrices must have the same domain")
+
+        # Given a polynomial p(x) = p[0]*x^n + p[1]*x^(n-1) + ... + p[n-1]
+        # and matrices A and B we want to find
+        #
+        #   p(A)*B = p[0]*A^n*B + p[1]*A^(n-1)*B + ... + p[n-1]*B
+        #
+        # Factoring out A term by term we get
+        #
+        #   p(A)*B = A*(...A*(A*(A*(p[0]*B) + p[1]*B) + p[2]*B) + ...) + p[n-1]*B
+        #
+        # where each pair of brackets represents one iteration of the loop
+        # below starting from the innermost p[0]*B. If B is a column matrix
+        # then products like A*(...) are matrix-vector multiplies and products
+        # like p[i]*B are scalar-vector multiplies so there are no
+        # matrix-matrix multiplies.
+
+        if not p:
+            return B.zeros(B.shape, B.domain, fmt=B.rep.fmt)
+
+        p_A_B = p[0]*B
+
+        for p_i in p[1:]:
+            p_A_B = A*p_A_B + p_i*B
+
+        return p_A_B
+
+    def lu(self):
+        r"""
+        Returns Lower and Upper decomposition of the DomainMatrix
+
+        Returns
+        =======
+
+        (L, U, exchange)
+            L, U are Lower and Upper decomposition of the DomainMatrix,
+            exchange is the list of indices of rows exchanged in the
+            decomposition.
+
+        Raises
+        ======
+
+        ValueError
+            If the domain of DomainMatrix not a Field
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [QQ(1), QQ(-1)],
+        ...    [QQ(2), QQ(-2)]], (2, 2), QQ)
+        >>> L, U, exchange = A.lu()
+        >>> L
+        DomainMatrix([[1, 0], [2, 1]], (2, 2), QQ)
+        >>> U
+        DomainMatrix([[1, -1], [0, 0]], (2, 2), QQ)
+        >>> exchange
+        []
+
+        See Also
+        ========
+
+        lu_solve
+
+        """
+        if not self.domain.is_Field:
+            raise DMNotAField('Not a field')
+        L, U, swaps = self.rep.lu()
+        return self.from_rep(L), self.from_rep(U), swaps
+
+    def lu_solve(self, rhs):
+        r"""
+        Solver for DomainMatrix x in the A*x = B
+
+        Parameters
+        ==========
+
+        rhs : DomainMatrix B
+
+        Returns
+        =======
+
+        DomainMatrix
+            x in A*x = B
+
+        Raises
+        ======
+
+        DMShapeError
+            If the DomainMatrix A and rhs have different number of rows
+
+        ValueError
+            If the domain of DomainMatrix A not a Field
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [QQ(1), QQ(2)],
+        ...    [QQ(3), QQ(4)]], (2, 2), QQ)
+        >>> B = DomainMatrix([
+        ...    [QQ(1), QQ(1)],
+        ...    [QQ(0), QQ(1)]], (2, 2), QQ)
+
+        >>> A.lu_solve(B)
+        DomainMatrix([[-2, -1], [3/2, 1]], (2, 2), QQ)
+
+        See Also
+        ========
+
+        lu
+
+        """
+        if self.shape[0] != rhs.shape[0]:
+            raise DMShapeError("Shape")
+        if not self.domain.is_Field:
+            raise DMNotAField('Not a field')
+        sol = self.rep.lu_solve(rhs.rep)
+        return self.from_rep(sol)
+
+    def _solve(A, b):
+        # XXX: Not sure about this method or its signature. It is just created
+        # because it is needed by the holonomic module.
+        if A.shape[0] != b.shape[0]:
+            raise DMShapeError("Shape")
+        if A.domain != b.domain or not A.domain.is_Field:
+            raise DMNotAField('Not a field')
+        Aaug = A.hstack(b)
+        Arref, pivots = Aaug.rref()
+        particular = Arref.from_rep(Arref.rep.particular())
+        nullspace_rep, nonpivots = Arref[:,:-1].rep.nullspace()
+        nullspace = Arref.from_rep(nullspace_rep)
+        return particular, nullspace
+
+    def charpoly(self):
+        r"""
+        Characteristic polynomial of a square matrix.
+
+        Computes the characteristic polynomial in a fully expanded form using
+        division free arithmetic. If a factorization of the characteristic
+        polynomial is needed then it is more efficient to call
+        :meth:`charpoly_factor_list` than calling :meth:`charpoly` and then
+        factorizing the result.
+
+        Returns
+        =======
+
+        list: list of DomainElement
+            coefficients of the characteristic polynomial
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+
+        >>> A.charpoly()
+        [1, -5, -2]
+
+        See Also
+        ========
+
+        charpoly_factor_list
+            Compute the factorisation of the characteristic polynomial.
+        charpoly_factor_blocks
+            A partial factorisation of the characteristic polynomial that can
+            be computed more efficiently than either the full factorisation or
+            the fully expanded polynomial.
+        """
+        M = self
+        K = M.domain
+
+        factors = M.charpoly_factor_blocks()
+
+        cp = [K.one]
+
+        for f, mult in factors:
+            for _ in range(mult):
+                cp = dup_mul(cp, f, K)
+
+        return cp
+
+    def charpoly_factor_list(self):
+        """
+        Full factorization of the characteristic polynomial.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DM
+        >>> from sympy import ZZ
+        >>> M = DM([[6, -1, 0, 0],
+        ...         [9, 12, 0, 0],
+        ...         [0,  0, 1, 2],
+        ...         [0,  0, 5, 6]], ZZ)
+
+        Compute the factorization of the characteristic polynomial:
+
+        >>> M.charpoly_factor_list()
+        [([1, -9], 2), ([1, -7, -4], 1)]
+
+        Use :meth:`charpoly` to get the unfactorized characteristic polynomial:
+
+        >>> M.charpoly()
+        [1, -25, 203, -495, -324]
+
+        The same calculations with ``Matrix``:
+
+        >>> M.to_Matrix().charpoly().as_expr()
+        lambda**4 - 25*lambda**3 + 203*lambda**2 - 495*lambda - 324
+        >>> M.to_Matrix().charpoly().as_expr().factor()
+        (lambda - 9)**2*(lambda**2 - 7*lambda - 4)
+
+        Returns
+        =======
+
+        list: list of pairs (factor, multiplicity)
+            A full factorization of the characteristic polynomial.
+
+        See Also
+        ========
+
+        charpoly
+            Expanded form of the characteristic polynomial.
+        charpoly_factor_blocks
+            A partial factorisation of the characteristic polynomial that can
+            be computed more efficiently.
+        """
+        M = self
+        K = M.domain
+
+        # It is more efficient to start from the partial factorization provided
+        # for free by M.charpoly_factor_blocks than the expanded M.charpoly.
+        factors = M.charpoly_factor_blocks()
+
+        factors_irreducible = []
+
+        for factor_i, mult_i in factors:
+
+            _, factors_list = dup_factor_list(factor_i, K)
+
+            for factor_j, mult_j in factors_list:
+                factors_irreducible.append((factor_j, mult_i * mult_j))
+
+        return _collect_factors(factors_irreducible)
+
+    def charpoly_factor_blocks(self):
+        """
+        Partial factorisation of the characteristic polynomial.
+
+        This factorisation arises from a block structure of the matrix (if any)
+        and so the factors are not guaranteed to be irreducible. The
+        :meth:`charpoly_factor_blocks` method is the most efficient way to get
+        a representation of the characteristic polynomial but the result is
+        neither fully expanded nor fully factored.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DM
+        >>> from sympy import ZZ
+        >>> M = DM([[6, -1, 0, 0],
+        ...         [9, 12, 0, 0],
+        ...         [0,  0, 1, 2],
+        ...         [0,  0, 5, 6]], ZZ)
+
+        This computes a partial factorization using only the block structure of
+        the matrix to reveal factors:
+
+        >>> M.charpoly_factor_blocks()
+        [([1, -18, 81], 1), ([1, -7, -4], 1)]
+
+        These factors correspond to the two diagonal blocks in the matrix:
+
+        >>> DM([[6, -1], [9, 12]], ZZ).charpoly()
+        [1, -18, 81]
+        >>> DM([[1, 2], [5, 6]], ZZ).charpoly()
+        [1, -7, -4]
+
+        Use :meth:`charpoly_factor_list` to get a complete factorization into
+        irreducibles:
+
+        >>> M.charpoly_factor_list()
+        [([1, -9], 2), ([1, -7, -4], 1)]
+
+        Use :meth:`charpoly` to get the expanded characteristic polynomial:
+
+        >>> M.charpoly()
+        [1, -25, 203, -495, -324]
+
+        Returns
+        =======
+
+        list: list of pairs (factor, multiplicity)
+            A partial factorization of the characteristic polynomial.
+
+        See Also
+        ========
+
+        charpoly
+            Compute the fully expanded characteristic polynomial.
+        charpoly_factor_list
+            Compute a full factorization of the characteristic polynomial.
+        """
+        M = self
+
+        if not M.is_square:
+            raise DMNonSquareMatrixError("not square")
+
+        # scc returns indices that permute the matrix into block triangular
+        # form and can extract the diagonal blocks. M.charpoly() is equal to
+        # the product of the diagonal block charpolys.
+        components = M.scc()
+
+        block_factors = []
+
+        for indices in components:
+            block = M.extract(indices, indices)
+            block_factors.append((block.charpoly_base(), 1))
+
+        return _collect_factors(block_factors)
+
+    def charpoly_base(self):
+        """
+        Base case for :meth:`charpoly_factor_blocks` after block decomposition.
+
+        This method is used internally by :meth:`charpoly_factor_blocks` as the
+        base case for computing the characteristic polynomial of a block. It is
+        more efficient to call :meth:`charpoly_factor_blocks`, :meth:`charpoly`
+        or :meth:`charpoly_factor_list` rather than call this method directly.
+
+        This will use either the dense or the sparse implementation depending
+        on the sparsity of the matrix and will clear denominators if possible
+        before calling :meth:`charpoly_berk` to compute the characteristic
+        polynomial using the Berkowitz algorithm.
+
+        See Also
+        ========
+
+        charpoly
+        charpoly_factor_list
+        charpoly_factor_blocks
+        charpoly_berk
+        """
+        M = self
+        K = M.domain
+
+        # It seems that the sparse implementation is always faster for random
+        # matrices with fewer than 50% non-zero entries. This does not seem to
+        # depend on domain, size, bit count etc.
+        density = self.nnz() / self.shape[0]**2
+        if density < 0.5:
+            M = M.to_sparse()
+        else:
+            M = M.to_dense()
+
+        # Clearing denominators is always more efficient if it can be done.
+        # Doing it here after block decomposition is good because each block
+        # might have a smaller denominator. However it might be better for
+        # charpoly and charpoly_factor_list to restore the denominators only at
+        # the very end so that they can call e.g. dup_factor_list before
+        # restoring the denominators. The methods would need to be changed to
+        # return (poly, denom) pairs to make that work though.
+        clear_denoms = K.is_Field and K.has_assoc_Ring
+
+        if clear_denoms:
+            clear_denoms = True
+            d, M = M.clear_denoms(convert=True)
+            d = d.element
+            K_f = K
+            K_r = M.domain
+
+        # Berkowitz algorithm over K_r.
+        cp = M.charpoly_berk()
+
+        if clear_denoms:
+            # Restore the denominator in the charpoly over K_f.
+            #
+            # If M = N/d then p_M(x) = p_N(x*d)/d^n.
+            cp = dup_convert(cp, K_r, K_f)
+            p = [K_f.one, K_f.zero]
+            q = [K_f.one/d]
+            cp = dup_transform(cp, p, q, K_f)
+
+        return cp
+
+    def charpoly_berk(self):
+        """Compute the characteristic polynomial using the Berkowitz algorithm.
+
+        This method directly calls the underlying implementation of the
+        Berkowitz algorithm (:meth:`sympy.polys.matrices.dense.ddm_berk` or
+        :meth:`sympy.polys.matrices.sdm.sdm_berk`).
+
+        This is used by :meth:`charpoly` and other methods as the base case for
+        for computing the characteristic polynomial. However those methods will
+        apply other optimizations such as block decomposition, clearing
+        denominators and converting between dense and sparse representations
+        before calling this method. It is more efficient to call those methods
+        instead of this one but this method is provided for direct access to
+        the Berkowitz algorithm.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DM
+        >>> from sympy import QQ
+        >>> M = DM([[6, -1, 0, 0],
+        ...         [9, 12, 0, 0],
+        ...         [0,  0, 1, 2],
+        ...         [0,  0, 5, 6]], QQ)
+        >>> M.charpoly_berk()
+        [1, -25, 203, -495, -324]
+
+        See Also
+        ========
+
+        charpoly
+        charpoly_base
+        charpoly_factor_list
+        charpoly_factor_blocks
+        sympy.polys.matrices.dense.ddm_berk
+        sympy.polys.matrices.sdm.sdm_berk
+        """
+        return self.rep.charpoly()
+
+    @classmethod
+    def eye(cls, shape, domain):
+        r"""
+        Return identity matrix of size n or shape (m, n).
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import QQ
+        >>> DomainMatrix.eye(3, QQ)
+        DomainMatrix({0: {0: 1}, 1: {1: 1}, 2: {2: 1}}, (3, 3), QQ)
+
+        """
+        if isinstance(shape, int):
+            shape = (shape, shape)
+        return cls.from_rep(SDM.eye(shape, domain))
+
+    @classmethod
+    def diag(cls, diagonal, domain, shape=None):
+        r"""
+        Return diagonal matrix with entries from ``diagonal``.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import ZZ
+        >>> DomainMatrix.diag([ZZ(5), ZZ(6)], ZZ)
+        DomainMatrix({0: {0: 5}, 1: {1: 6}}, (2, 2), ZZ)
+
+        """
+        if shape is None:
+            N = len(diagonal)
+            shape = (N, N)
+        return cls.from_rep(SDM.diag(diagonal, domain, shape))
+
+    @classmethod
+    def zeros(cls, shape, domain, *, fmt='sparse'):
+        """Returns a zero DomainMatrix of size shape, belonging to the specified domain
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import QQ
+        >>> DomainMatrix.zeros((2, 3), QQ)
+        DomainMatrix({}, (2, 3), QQ)
+
+        """
+        return cls.from_rep(SDM.zeros(shape, domain))
+
+    @classmethod
+    def ones(cls, shape, domain):
+        """Returns a DomainMatrix of 1s, of size shape, belonging to the specified domain
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import QQ
+        >>> DomainMatrix.ones((2,3), QQ)
+        DomainMatrix([[1, 1, 1], [1, 1, 1]], (2, 3), QQ)
+
+        """
+        return cls.from_rep(DDM.ones(shape, domain).to_dfm_or_ddm())
+
+    def __eq__(A, B):
+        r"""
+        Checks for two DomainMatrix matrices to be equal or not
+
+        Parameters
+        ==========
+
+        A, B: DomainMatrix
+            to check equality
+
+        Returns
+        =======
+
+        Boolean
+            True for equal, else False
+
+        Raises
+        ======
+
+        NotImplementedError
+            If B is not a DomainMatrix
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> B = DomainMatrix([
+        ...    [ZZ(1), ZZ(1)],
+        ...    [ZZ(0), ZZ(1)]], (2, 2), ZZ)
+        >>> A.__eq__(A)
+        True
+        >>> A.__eq__(B)
+        False
+
+        """
+        if not isinstance(A, type(B)):
+            return NotImplemented
+        return A.domain == B.domain and A.rep == B.rep
+
+    def unify_eq(A, B):
+        if A.shape != B.shape:
+            return False
+        if A.domain != B.domain:
+            A, B = A.unify(B)
+        return A == B
+
+    def lll(A, delta=QQ(3, 4)):
+        """
+        Performs the Lenstra–Lenstra–Lovász (LLL) basis reduction algorithm.
+        See [1]_ and [2]_.
+
+        Parameters
+        ==========
+
+        delta : QQ, optional
+            The Lovász parameter. Must be in the interval (0.25, 1), with larger
+            values producing a more reduced basis. The default is 0.75 for
+            historical reasons.
+
+        Returns
+        =======
+
+        The reduced basis as a DomainMatrix over ZZ.
+
+        Throws
+        ======
+
+        DMValueError: if delta is not in the range (0.25, 1)
+        DMShapeError: if the matrix is not of shape (m, n) with m <= n
+        DMDomainError: if the matrix domain is not ZZ
+        DMRankError: if the matrix contains linearly dependent rows
+
+        Examples
+        ========
+
+        >>> from sympy.polys.domains import ZZ, QQ
+        >>> from sympy.polys.matrices import DM
+        >>> x = DM([[1, 0, 0, 0, -20160],
+        ...         [0, 1, 0, 0, 33768],
+        ...         [0, 0, 1, 0, 39578],
+        ...         [0, 0, 0, 1, 47757]], ZZ)
+        >>> y = DM([[10, -3, -2, 8, -4],
+        ...         [3, -9, 8, 1, -11],
+        ...         [-3, 13, -9, -3, -9],
+        ...         [-12, -7, -11, 9, -1]], ZZ)
+        >>> assert x.lll(delta=QQ(5, 6)) == y
+
+        Notes
+        =====
+
+        The implementation is derived from the Maple code given in Figures 4.3
+        and 4.4 of [3]_ (pp.68-69). It uses the efficient method of only calculating
+        state updates as they are required.
+
+        See also
+        ========
+
+        lll_transform
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Lenstra%E2%80%93Lenstra%E2%80%93Lov%C3%A1sz_lattice_basis_reduction_algorithm
+        .. [2] https://web.archive.org/web/20221029115428/https://web.cs.elte.hu/~lovasz/scans/lll.pdf
+        .. [3] Murray R. Bremner, "Lattice Basis Reduction: An Introduction to the LLL Algorithm and Its Applications"
+
+        """
+        return DomainMatrix.from_rep(A.rep.lll(delta=delta))
+
+    def lll_transform(A, delta=QQ(3, 4)):
+        """
+        Performs the Lenstra–Lenstra–Lovász (LLL) basis reduction algorithm
+        and returns the reduced basis and transformation matrix.
+
+        Explanation
+        ===========
+
+        Parameters, algorithm and basis are the same as for :meth:`lll` except that
+        the return value is a tuple `(B, T)` with `B` the reduced basis and
+        `T` a transformation matrix. The original basis `A` is transformed to
+        `B` with `T*A == B`. If only `B` is needed then :meth:`lll` should be
+        used as it is a little faster.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.domains import ZZ, QQ
+        >>> from sympy.polys.matrices import DM
+        >>> X = DM([[1, 0, 0, 0, -20160],
+        ...         [0, 1, 0, 0, 33768],
+        ...         [0, 0, 1, 0, 39578],
+        ...         [0, 0, 0, 1, 47757]], ZZ)
+        >>> B, T = X.lll_transform(delta=QQ(5, 6))
+        >>> T * X == B
+        True
+
+        See also
+        ========
+
+        lll
+
+        """
+        reduced, transform = A.rep.lll_transform(delta=delta)
+        return DomainMatrix.from_rep(reduced), DomainMatrix.from_rep(transform)
+
+
+def _collect_factors(factors_list):
+    """
+    Collect repeating factors and sort.
+
+    >>> from sympy.polys.matrices.domainmatrix import _collect_factors
+    >>> _collect_factors([([1, 2], 2), ([1, 4], 3), ([1, 2], 5)])
+    [([1, 4], 3), ([1, 2], 7)]
+    """
+    factors = Counter()
+    for factor, exponent in factors_list:
+        factors[tuple(factor)] += exponent
+
+    factors_list = [(list(f), e) for f, e in factors.items()]
+
+    return _sort_factors(factors_list)
diff --git a/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/domainscalar.py b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/domainscalar.py
new file mode 100644
index 0000000000000000000000000000000000000000..df439a60a0ea0df5f6fac988c06da2a06a4fbac2
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/domainscalar.py
@@ -0,0 +1,122 @@
+"""
+
+Module for the DomainScalar class.
+
+A DomainScalar represents an element which is in a particular
+Domain. The idea is that the DomainScalar class provides the
+convenience routines for unifying elements with different domains.
+
+It assists in Scalar Multiplication and getitem for DomainMatrix.
+
+"""
+from ..constructor import construct_domain
+
+from sympy.polys.domains import Domain, ZZ
+
+
+class DomainScalar:
+    r"""
+    docstring
+    """
+
+    def __new__(cls, element, domain):
+        if not isinstance(domain, Domain):
+            raise TypeError("domain should be of type Domain")
+        if not domain.of_type(element):
+            raise TypeError("element %s should be in domain %s" % (element, domain))
+        return cls.new(element, domain)
+
+    @classmethod
+    def new(cls, element, domain):
+        obj = super().__new__(cls)
+        obj.element = element
+        obj.domain = domain
+        return obj
+
+    def __repr__(self):
+        return repr(self.element)
+
+    @classmethod
+    def from_sympy(cls, expr):
+        [domain, [element]] = construct_domain([expr])
+        return cls.new(element, domain)
+
+    def to_sympy(self):
+        return self.domain.to_sympy(self.element)
+
+    def to_domain(self, domain):
+        element = domain.convert_from(self.element, self.domain)
+        return self.new(element, domain)
+
+    def convert_to(self, domain):
+        return self.to_domain(domain)
+
+    def unify(self, other):
+        domain = self.domain.unify(other.domain)
+        return self.to_domain(domain), other.to_domain(domain)
+
+    def __bool__(self):
+        return bool(self.element)
+
+    def __add__(self, other):
+        if not isinstance(other, DomainScalar):
+            return NotImplemented
+        self, other = self.unify(other)
+        return self.new(self.element + other.element, self.domain)
+
+    def __sub__(self, other):
+        if not isinstance(other, DomainScalar):
+            return NotImplemented
+        self, other = self.unify(other)
+        return self.new(self.element - other.element, self.domain)
+
+    def __mul__(self, other):
+        if not isinstance(other, DomainScalar):
+            if isinstance(other, int):
+                other = DomainScalar(ZZ(other), ZZ)
+            else:
+                return NotImplemented
+
+        self, other = self.unify(other)
+        return self.new(self.element * other.element, self.domain)
+
+    def __floordiv__(self, other):
+        if not isinstance(other, DomainScalar):
+            return NotImplemented
+        self, other = self.unify(other)
+        return self.new(self.domain.quo(self.element, other.element), self.domain)
+
+    def __mod__(self, other):
+        if not isinstance(other, DomainScalar):
+            return NotImplemented
+        self, other = self.unify(other)
+        return self.new(self.domain.rem(self.element, other.element), self.domain)
+
+    def __divmod__(self, other):
+        if not isinstance(other, DomainScalar):
+            return NotImplemented
+        self, other = self.unify(other)
+        q, r = self.domain.div(self.element, other.element)
+        return (self.new(q, self.domain), self.new(r, self.domain))
+
+    def __pow__(self, n):
+        if not isinstance(n, int):
+            return NotImplemented
+        return self.new(self.element**n, self.domain)
+
+    def __pos__(self):
+        return self.new(+self.element, self.domain)
+
+    def __neg__(self):
+        return self.new(-self.element, self.domain)
+
+    def __eq__(self, other):
+        if not isinstance(other, DomainScalar):
+            return NotImplemented
+        return self.element == other.element and self.domain == other.domain
+
+    def is_zero(self):
+        return self.element == self.domain.zero
+
+    def is_one(self):
+        return self.element == self.domain.one
diff --git a/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/linsolve.py b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/linsolve.py
new file mode 100644
index 0000000000000000000000000000000000000000..af74058d859b744cf8fe1059ddb7c775fece79c7
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/linsolve.py
@@ -0,0 +1,230 @@
+#
+# sympy.polys.matrices.linsolve module
+#
+# This module defines the _linsolve function which is the internal workhorse
+# used by linsolve. This computes the solution of a system of linear equations
+# using the SDM sparse matrix implementation in sympy.polys.matrices.sdm. This
+# is a replacement for solve_lin_sys in sympy.polys.solvers which is
+# inefficient for large sparse systems due to the use of a PolyRing with many
+# generators:
+#
+#     https://github.com/sympy/sympy/issues/20857
+#
+# The implementation of _linsolve here handles:
+#
+# - Extracting the coefficients from the Expr/Eq input equations.
+# - Constructing a domain and converting the coefficients to
+#   that domain.
+# - Using the SDM.rref, SDM.nullspace etc methods to generate the full
+#   solution working with arithmetic only in the domain of the coefficients.
+#
+# The routines here are particularly designed to be efficient for large sparse
+# systems of linear equations although as well as dense systems. It is
+# possible that for some small dense systems solve_lin_sys which uses the
+# dense matrix implementation DDM will be more efficient. With smaller systems
+# though the bulk of the time is spent just preprocessing the inputs and the
+# relative time spent in rref is too small to be noticeable.
+#
+
+from collections import defaultdict
+
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.singleton import S
+
+from sympy.polys.constructor import construct_domain
+from sympy.polys.solvers import PolyNonlinearError
+
+from .sdm import (
+    SDM,
+    sdm_irref,
+    sdm_particular_from_rref,
+    sdm_nullspace_from_rref
+)
+
+from sympy.utilities.misc import filldedent
+
+
+def _linsolve(eqs, syms):
+
+    """Solve a linear system of equations.
+
+    Examples
+    ========
+
+    Solve a linear system with a unique solution:
+
+    >>> from sympy import symbols, Eq
+    >>> from sympy.polys.matrices.linsolve import _linsolve
+    >>> x, y = symbols('x, y')
+    >>> eqs = [Eq(x + y, 1), Eq(x - y, 2)]
+    >>> _linsolve(eqs, [x, y])
+    {x: 3/2, y: -1/2}
+
+    In the case of underdetermined systems the solution will be expressed in
+    terms of the unknown symbols that are unconstrained:
+
+    >>> _linsolve([Eq(x + y, 0)], [x, y])
+    {x: -y, y: y}
+
+    """
+    # Number of unknowns (columns in the non-augmented matrix)
+    nsyms = len(syms)
+
+    # Convert to sparse augmented matrix (len(eqs) x (nsyms+1))
+    eqsdict, const = _linear_eq_to_dict(eqs, syms)
+    Aaug = sympy_dict_to_dm(eqsdict, const, syms)
+    K = Aaug.domain
+
+    # sdm_irref has issues with float matrices. This uses the ddm_rref()
+    # function. When sdm_rref() can handle float matrices reasonably this
+    # should be removed...
+    if K.is_RealField or K.is_ComplexField:
+        Aaug = Aaug.to_ddm().rref()[0].to_sdm()
+
+    # Compute reduced-row echelon form (RREF)
+    Arref, pivots, nzcols = sdm_irref(Aaug)
+
+    # No solution:
+    if pivots and pivots[-1] == nsyms:
+        return None
+
+    # Particular solution for non-homogeneous system:
+    P = sdm_particular_from_rref(Arref, nsyms+1, pivots)
+
+    # Nullspace - general solution to homogeneous system
+    # Note: using nsyms not nsyms+1 to ignore last column
+    V, nonpivots = sdm_nullspace_from_rref(Arref, K.one, nsyms, pivots, nzcols)
+
+    # Collect together terms from particular and nullspace:
+    sol = defaultdict(list)
+    for i, v in P.items():
+        sol[syms[i]].append(K.to_sympy(v))
+    for npi, Vi in zip(nonpivots, V):
+        sym = syms[npi]
+        for i, v in Vi.items():
+            sol[syms[i]].append(sym * K.to_sympy(v))
+
+    # Use a single call to Add for each term:
+    sol = {s: Add(*terms) for s, terms in sol.items()}
+
+    # Fill in the zeros:
+    zero = S.Zero
+    for s in set(syms) - set(sol):
+        sol[s] = zero
+
+    # All done!
+    return sol
+
+
+def sympy_dict_to_dm(eqs_coeffs, eqs_rhs, syms):
+    """Convert a system of dict equations to a sparse augmented matrix"""
+    elems = set(eqs_rhs).union(*(e.values() for e in eqs_coeffs))
+    K, elems_K = construct_domain(elems, field=True, extension=True)
+    elem_map = dict(zip(elems, elems_K))
+    neqs = len(eqs_coeffs)
+    nsyms = len(syms)
+    sym2index = dict(zip(syms, range(nsyms)))
+    eqsdict = []
+    for eq, rhs in zip(eqs_coeffs, eqs_rhs):
+        eqdict = {sym2index[s]: elem_map[c] for s, c in eq.items()}
+        if rhs:
+            eqdict[nsyms] = -elem_map[rhs]
+        if eqdict:
+            eqsdict.append(eqdict)
+    sdm_aug = SDM(enumerate(eqsdict), (neqs, nsyms + 1), K)
+    return sdm_aug
+
+
+def _linear_eq_to_dict(eqs, syms):
+    """Convert a system Expr/Eq equations into dict form, returning
+    the coefficient dictionaries and a list of syms-independent terms
+    from each expression in ``eqs```.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.matrices.linsolve import _linear_eq_to_dict
+    >>> from sympy.abc import x
+    >>> _linear_eq_to_dict([2*x + 3], {x})
+    ([{x: 2}], [3])
+    """
+    coeffs = []
+    ind = []
+    symset = set(syms)
+    for e in eqs:
+        if e.is_Equality:
+            coeff, terms = _lin_eq2dict(e.lhs, symset)
+            cR, tR = _lin_eq2dict(e.rhs, symset)
+            # there were no nonlinear errors so now
+            # cancellation is allowed
+            coeff -= cR
+            for k, v in tR.items():
+                if k in terms:
+                    terms[k] -= v
+                else:
+                    terms[k] = -v
+            # don't store coefficients of 0, however
+            terms = {k: v for k, v in terms.items() if v}
+            c, d = coeff, terms
+        else:
+            c, d = _lin_eq2dict(e, symset)
+        coeffs.append(d)
+        ind.append(c)
+    return coeffs, ind
+
+
+def _lin_eq2dict(a, symset):
+    """return (c, d) where c is the sym-independent part of ``a`` and
+    ``d`` is an efficiently calculated dictionary mapping symbols to
+    their coefficients. A PolyNonlinearError is raised if non-linearity
+    is detected.
+
+    The values in the dictionary will be non-zero.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.matrices.linsolve import _lin_eq2dict
+    >>> from sympy.abc import x, y
+    >>> _lin_eq2dict(x + 2*y + 3, {x, y})
+    (3, {x: 1, y: 2})
+    """
+    if a in symset:
+        return S.Zero, {a: S.One}
+    elif a.is_Add:
+        terms_list = defaultdict(list)
+        coeff_list = []
+        for ai in a.args:
+            ci, ti = _lin_eq2dict(ai, symset)
+            coeff_list.append(ci)
+            for mij, cij in ti.items():
+                terms_list[mij].append(cij)
+        coeff = Add(*coeff_list)
+        terms = {sym: Add(*coeffs) for sym, coeffs in terms_list.items()}
+        return coeff, terms
+    elif a.is_Mul:
+        terms = terms_coeff = None
+        coeff_list = []
+        for ai in a.args:
+            ci, ti = _lin_eq2dict(ai, symset)
+            if not ti:
+                coeff_list.append(ci)
+            elif terms is None:
+                terms = ti
+                terms_coeff = ci
+            else:
+                # since ti is not null and we already have
+                # a term, this is a cross term
+                raise PolyNonlinearError(filldedent('''
+                    nonlinear cross-term: %s''' % a))
+        coeff = Mul._from_args(coeff_list)
+        if terms is None:
+            return coeff, {}
+        else:
+            terms = {sym: coeff * c for sym, c in terms.items()}
+            return  coeff * terms_coeff, terms
+    elif not a.has_xfree(symset):
+        return a, {}
+    else:
+        raise PolyNonlinearError('nonlinear term: %s' % a)
diff --git a/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/lll.py b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/lll.py
new file mode 100644
index 0000000000000000000000000000000000000000..f33f91d92c5e20f89f302991e494a6a5b9fa4b2e
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/lll.py
@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from math import floor as mfloor
+
+from sympy.polys.domains import ZZ, QQ
+from sympy.polys.matrices.exceptions import DMRankError, DMShapeError, DMValueError, DMDomainError
+
+
+def _ddm_lll(x, delta=QQ(3, 4), return_transform=False):
+    if QQ(1, 4) >= delta or delta >= QQ(1, 1):
+        raise DMValueError("delta must lie in range (0.25, 1)")
+    if x.shape[0] > x.shape[1]:
+        raise DMShapeError("input matrix must have shape (m, n) with m <= n")
+    if x.domain != ZZ:
+        raise DMDomainError("input matrix domain must be ZZ")
+    m = x.shape[0]
+    n = x.shape[1]
+    k = 1
+    y = x.copy()
+    y_star = x.zeros((m, n), QQ)
+    mu = x.zeros((m, m), QQ)
+    g_star = [QQ(0, 1) for _ in range(m)]
+    half = QQ(1, 2)
+    T = x.eye(m, ZZ) if return_transform else None
+    linear_dependent_error = "input matrix contains linearly dependent rows"
+
+    def closest_integer(x):
+        return ZZ(mfloor(x + half))
+
+    def lovasz_condition(k: int) -> bool:
+        return g_star[k] >= ((delta - mu[k][k - 1] ** 2) * g_star[k - 1])
+
+    def mu_small(k: int, j: int) -> bool:
+        return abs(mu[k][j]) <= half
+
+    def dot_rows(x, y, rows: tuple[int, int]):
+        return sum(x[rows[0]][z] * y[rows[1]][z] for z in range(x.shape[1]))
+
+    def reduce_row(T, mu, y, rows: tuple[int, int]):
+        r = closest_integer(mu[rows[0]][rows[1]])
+        y[rows[0]] = [y[rows[0]][z] - r * y[rows[1]][z] for z in range(n)]
+        mu[rows[0]][:rows[1]] = [mu[rows[0]][z] - r * mu[rows[1]][z] for z in range(rows[1])]
+        mu[rows[0]][rows[1]] -= r
+        if return_transform:
+            T[rows[0]] = [T[rows[0]][z] - r * T[rows[1]][z] for z in range(m)]
+
+    for i in range(m):
+        y_star[i] = [QQ.convert_from(z, ZZ) for z in y[i]]
+        for j in range(i):
+            row_dot = dot_rows(y, y_star, (i, j))
+            try:
+                mu[i][j] = row_dot / g_star[j]
+            except ZeroDivisionError:
+                raise DMRankError(linear_dependent_error)
+            y_star[i] = [y_star[i][z] - mu[i][j] * y_star[j][z] for z in range(n)]
+        g_star[i] = dot_rows(y_star, y_star, (i, i))
+    while k < m:
+        if not mu_small(k, k - 1):
+            reduce_row(T, mu, y, (k, k - 1))
+        if lovasz_condition(k):
+            for l in range(k - 2, -1, -1):
+                if not mu_small(k, l):
+                    reduce_row(T, mu, y, (k, l))
+            k += 1
+        else:
+            nu = mu[k][k - 1]
+            alpha = g_star[k] + nu ** 2 * g_star[k - 1]
+            try:
+                beta = g_star[k - 1] / alpha
+            except ZeroDivisionError:
+                raise DMRankError(linear_dependent_error)
+            mu[k][k - 1] = nu * beta
+            g_star[k] = g_star[k] * beta
+            g_star[k - 1] = alpha
+            y[k], y[k - 1] = y[k - 1], y[k]
+            mu[k][:k - 1], mu[k - 1][:k - 1] = mu[k - 1][:k - 1], mu[k][:k - 1]
+            for i in range(k + 1, m):
+                xi = mu[i][k]
+                mu[i][k] = mu[i][k - 1] - nu * xi
+                mu[i][k - 1] = mu[k][k - 1] * mu[i][k] + xi
+            if return_transform:
+                T[k], T[k - 1] = T[k - 1], T[k]
+            k = max(k - 1, 1)
+    assert all(lovasz_condition(i) for i in range(1, m))
+    assert all(mu_small(i, j) for i in range(m) for j in range(i))
+    return y, T
+
+
+def ddm_lll(x, delta=QQ(3, 4)):
+    return _ddm_lll(x, delta=delta, return_transform=False)[0]
+
+
+def ddm_lll_transform(x, delta=QQ(3, 4)):
+    return _ddm_lll(x, delta=delta, return_transform=True)
diff --git a/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/normalforms.py b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/normalforms.py
new file mode 100644
index 0000000000000000000000000000000000000000..507d9bf53163d56217a9b290bc42510445c20888
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/normalforms.py
@@ -0,0 +1,406 @@
+'''Functions returning normal forms of matrices'''
+
+from collections import defaultdict
+
+from .domainmatrix import DomainMatrix
+from .exceptions import DMDomainError, DMShapeError
+from sympy.ntheory.modular import symmetric_residue
+from sympy.polys.domains import QQ, ZZ
+
+
+# TODO (future work):
+#  There are faster algorithms for Smith and Hermite normal forms, which
+#  we should implement. See e.g. the Kannan-Bachem algorithm:
+#  <https://www.researchgate.net/publication/220617516_Polynomial_Algorithms_for_Computing_the_Smith_and_Hermite_Normal_Forms_of_an_Integer_Matrix>
+
+
+def smith_normal_form(m):
+    '''
+    Return the Smith Normal Form of a matrix `m` over the ring `domain`.
+    This will only work if the ring is a principal ideal domain.
+
+    Examples
+    ========
+
+    >>> from sympy import ZZ
+    >>> from sympy.polys.matrices import DomainMatrix
+    >>> from sympy.polys.matrices.normalforms import smith_normal_form
+    >>> m = DomainMatrix([[ZZ(12), ZZ(6), ZZ(4)],
+    ...                   [ZZ(3), ZZ(9), ZZ(6)],
+    ...                   [ZZ(2), ZZ(16), ZZ(14)]], (3, 3), ZZ)
+    >>> print(smith_normal_form(m).to_Matrix())
+    Matrix([[1, 0, 0], [0, 10, 0], [0, 0, -30]])
+
+    '''
+    invs = invariant_factors(m)
+    smf = DomainMatrix.diag(invs, m.domain, m.shape)
+    return smf
+
+
+def add_columns(m, i, j, a, b, c, d):
+    # replace m[:, i] by a*m[:, i] + b*m[:, j]
+    # and m[:, j] by c*m[:, i] + d*m[:, j]
+    for k in range(len(m)):
+        e = m[k][i]
+        m[k][i] = a*e + b*m[k][j]
+        m[k][j] = c*e + d*m[k][j]
+
+
+def invariant_factors(m):
+    '''
+    Return the tuple of abelian invariants for a matrix `m`
+    (as in the Smith-Normal form)
+
+    References
+    ==========
+
+    [1] https://en.wikipedia.org/wiki/Smith_normal_form#Algorithm
+    [2] https://web.archive.org/web/20200331143852/https://sierra.nmsu.edu/morandi/notes/SmithNormalForm.pdf
+
+    '''
+    domain = m.domain
+    if not domain.is_PID:
+        msg = "The matrix entries must be over a principal ideal domain"
+        raise ValueError(msg)
+
+    if 0 in m.shape:
+        return ()
+
+    rows, cols = shape = m.shape
+    m = list(m.to_dense().rep.to_ddm())
+
+    def add_rows(m, i, j, a, b, c, d):
+        # replace m[i, :] by a*m[i, :] + b*m[j, :]
+        # and m[j, :] by c*m[i, :] + d*m[j, :]
+        for k in range(cols):
+            e = m[i][k]
+            m[i][k] = a*e + b*m[j][k]
+            m[j][k] = c*e + d*m[j][k]
+
+    def clear_column(m):
+        # make m[1:, 0] zero by row and column operations
+        if m[0][0] == 0:
+            return m  # pragma: nocover
+        pivot = m[0][0]
+        for j in range(1, rows):
+            if m[j][0] == 0:
+                continue
+            d, r = domain.div(m[j][0], pivot)
+            if r == 0:
+                add_rows(m, 0, j, 1, 0, -d, 1)
+            else:
+                a, b, g = domain.gcdex(pivot, m[j][0])
+                d_0 = domain.div(m[j][0], g)[0]
+                d_j = domain.div(pivot, g)[0]
+                add_rows(m, 0, j, a, b, d_0, -d_j)
+                pivot = g
+        return m
+
+    def clear_row(m):
+        # make m[0, 1:] zero by row and column operations
+        if m[0][0] == 0:
+            return m  # pragma: nocover
+        pivot = m[0][0]
+        for j in range(1, cols):
+            if m[0][j] == 0:
+                continue
+            d, r = domain.div(m[0][j], pivot)
+            if r == 0:
+                add_columns(m, 0, j, 1, 0, -d, 1)
+            else:
+                a, b, g = domain.gcdex(pivot, m[0][j])
+                d_0 = domain.div(m[0][j], g)[0]
+                d_j = domain.div(pivot, g)[0]
+                add_columns(m, 0, j, a, b, d_0, -d_j)
+                pivot = g
+        return m
+
+    # permute the rows and columns until m[0,0] is non-zero if possible
+    ind = [i for i in range(rows) if m[i][0] != 0]
+    if ind and ind[0] != 0:
+        m[0], m[ind[0]] = m[ind[0]], m[0]
+    else:
+        ind = [j for j in range(cols) if m[0][j] != 0]
+        if ind and ind[0] != 0:
+            for row in m:
+                row[0], row[ind[0]] = row[ind[0]], row[0]
+
+    # make the first row and column except m[0,0] zero
+    while (any(m[0][i] != 0 for i in range(1,cols)) or
+           any(m[i][0] != 0 for i in range(1,rows))):
+        m = clear_column(m)
+        m = clear_row(m)
+
+    if 1 in shape:
+        invs = ()
+    else:
+        lower_right = DomainMatrix([r[1:] for r in m[1:]], (rows-1, cols-1), domain)
+        invs = invariant_factors(lower_right)
+
+    if m[0][0]:
+        result = [m[0][0]]
+        result.extend(invs)
+        # in case m[0] doesn't divide the invariants of the rest of the matrix
+        for i in range(len(result)-1):
+            if result[i] and domain.div(result[i+1], result[i])[1] != 0:
+                g = domain.gcd(result[i+1], result[i])
+                result[i+1] = domain.div(result[i], g)[0]*result[i+1]
+                result[i] = g
+            else:
+                break
+    else:
+        result = invs + (m[0][0],)
+    return tuple(result)
+
+
+def _gcdex(a, b):
+    r"""
+    This supports the functions that compute Hermite Normal Form.
+
+    Explanation
+    ===========
+
+    Let x, y be the coefficients returned by the extended Euclidean
+    Algorithm, so that x*a + y*b = g. In the algorithms for computing HNF,
+    it is critical that x, y not only satisfy the condition of being small
+    in magnitude -- namely that |x| <= |b|/g, |y| <- |a|/g -- but also that
+    y == 0 when a | b.
+
+    """
+    x, y, g = ZZ.gcdex(a, b)
+    if a != 0 and b % a == 0:
+        y = 0
+        x = -1 if a < 0 else 1
+    return x, y, g
+
+
+def _hermite_normal_form(A):
+    r"""
+    Compute the Hermite Normal Form of DomainMatrix *A* over :ref:`ZZ`.
+
+    Parameters
+    ==========
+
+    A : :py:class:`~.DomainMatrix` over domain :ref:`ZZ`.
+
+    Returns
+    =======
+
+    :py:class:`~.DomainMatrix`
+        The HNF of matrix *A*.
+
+    Raises
+    ======
+
+    DMDomainError
+        If the domain of the matrix is not :ref:`ZZ`.
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
+       (See Algorithm 2.4.5.)
+
+    """
+    if not A.domain.is_ZZ:
+        raise DMDomainError('Matrix must be over domain ZZ.')
+    # We work one row at a time, starting from the bottom row, and working our
+    # way up.
+    m, n = A.shape
+    A = A.to_dense().rep.to_ddm().copy()
+    # Our goal is to put pivot entries in the rightmost columns.
+    # Invariant: Before processing each row, k should be the index of the
+    # leftmost column in which we have so far put a pivot.
+    k = n
+    for i in range(m - 1, -1, -1):
+        if k == 0:
+            # This case can arise when n < m and we've already found n pivots.
+            # We don't need to consider any more rows, because this is already
+            # the maximum possible number of pivots.
+            break
+        k -= 1
+        # k now points to the column in which we want to put a pivot.
+        # We want zeros in all entries to the left of the pivot column.
+        for j in range(k - 1, -1, -1):
+            if A[i][j] != 0:
+                # Replace cols j, k by lin combs of these cols such that, in row i,
+                # col j has 0, while col k has the gcd of their row i entries. Note
+                # that this ensures a nonzero entry in col k.
+                u, v, d = _gcdex(A[i][k], A[i][j])
+                r, s = A[i][k] // d, A[i][j] // d
+                add_columns(A, k, j, u, v, -s, r)
+        b = A[i][k]
+        # Do not want the pivot entry to be negative.
+        if b < 0:
+            add_columns(A, k, k, -1, 0, -1, 0)
+            b = -b
+        # The pivot entry will be 0 iff the row was 0 from the pivot col all the
+        # way to the left. In this case, we are still working on the same pivot
+        # col for the next row. Therefore:
+        if b == 0:
+            k += 1
+        # If the pivot entry is nonzero, then we want to reduce all entries to its
+        # right in the sense of the division algorithm, i.e. make them all remainders
+        # w.r.t. the pivot as divisor.
+        else:
+            for j in range(k + 1, n):
+                q = A[i][j] // b
+                add_columns(A, j, k, 1, -q, 0, 1)
+    # Finally, the HNF consists of those columns of A in which we succeeded in making
+    # a nonzero pivot.
+    return DomainMatrix.from_rep(A.to_dfm_or_ddm())[:, k:]
+
+
+def _hermite_normal_form_modulo_D(A, D):
+    r"""
+    Perform the mod *D* Hermite Normal Form reduction algorithm on
+    :py:class:`~.DomainMatrix` *A*.
+
+    Explanation
+    ===========
+
+    If *A* is an $m \times n$ matrix of rank $m$, having Hermite Normal Form
+    $W$, and if *D* is any positive integer known in advance to be a multiple
+    of $\det(W)$, then the HNF of *A* can be computed by an algorithm that
+    works mod *D* in order to prevent coefficient explosion.
+
+    Parameters
+    ==========
+
+    A : :py:class:`~.DomainMatrix` over :ref:`ZZ`
+        $m \times n$ matrix, having rank $m$.
+    D : :ref:`ZZ`
+        Positive integer, known to be a multiple of the determinant of the
+        HNF of *A*.
+
+    Returns
+    =======
+
+    :py:class:`~.DomainMatrix`
+        The HNF of matrix *A*.
+
+    Raises
+    ======
+
+    DMDomainError
+        If the domain of the matrix is not :ref:`ZZ`, or
+        if *D* is given but is not in :ref:`ZZ`.
+
+    DMShapeError
+        If the matrix has more rows than columns.
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
+       (See Algorithm 2.4.8.)
+
+    """
+    if not A.domain.is_ZZ:
+        raise DMDomainError('Matrix must be over domain ZZ.')
+    if not ZZ.of_type(D) or D < 1:
+        raise DMDomainError('Modulus D must be positive element of domain ZZ.')
+
+    def add_columns_mod_R(m, R, i, j, a, b, c, d):
+        # replace m[:, i] by (a*m[:, i] + b*m[:, j]) % R
+        # and m[:, j] by (c*m[:, i] + d*m[:, j]) % R
+        for k in range(len(m)):
+            e = m[k][i]
+            m[k][i] = symmetric_residue((a * e + b * m[k][j]) % R, R)
+            m[k][j] = symmetric_residue((c * e + d * m[k][j]) % R, R)
+
+    W = defaultdict(dict)
+
+    m, n = A.shape
+    if n < m:
+        raise DMShapeError('Matrix must have at least as many columns as rows.')
+    A = A.to_dense().rep.to_ddm().copy()
+    k = n
+    R = D
+    for i in range(m - 1, -1, -1):
+        k -= 1
+        for j in range(k - 1, -1, -1):
+            if A[i][j] != 0:
+                u, v, d = _gcdex(A[i][k], A[i][j])
+                r, s = A[i][k] // d, A[i][j] // d
+                add_columns_mod_R(A, R, k, j, u, v, -s, r)
+        b = A[i][k]
+        if b == 0:
+            A[i][k] = b = R
+        u, v, d = _gcdex(b, R)
+        for ii in range(m):
+            W[ii][i] = u*A[ii][k] % R
+        if W[i][i] == 0:
+            W[i][i] = R
+        for j in range(i + 1, m):
+            q = W[i][j] // W[i][i]
+            add_columns(W, j, i, 1, -q, 0, 1)
+        R //= d
+    return DomainMatrix(W, (m, m), ZZ).to_dense()
+
+
+def hermite_normal_form(A, *, D=None, check_rank=False):
+    r"""
+    Compute the Hermite Normal Form of :py:class:`~.DomainMatrix` *A* over
+    :ref:`ZZ`.
+
+    Examples
+    ========
+
+    >>> from sympy import ZZ
+    >>> from sympy.polys.matrices import DomainMatrix
+    >>> from sympy.polys.matrices.normalforms import hermite_normal_form
+    >>> m = DomainMatrix([[ZZ(12), ZZ(6), ZZ(4)],
+    ...                   [ZZ(3), ZZ(9), ZZ(6)],
+    ...                   [ZZ(2), ZZ(16), ZZ(14)]], (3, 3), ZZ)
+    >>> print(hermite_normal_form(m).to_Matrix())
+    Matrix([[10, 0, 2], [0, 15, 3], [0, 0, 2]])
+
+    Parameters
+    ==========
+
+    A : $m \times n$ ``DomainMatrix`` over :ref:`ZZ`.
+
+    D : :ref:`ZZ`, optional
+        Let $W$ be the HNF of *A*. If known in advance, a positive integer *D*
+        being any multiple of $\det(W)$ may be provided. In this case, if *A*
+        also has rank $m$, then we may use an alternative algorithm that works
+        mod *D* in order to prevent coefficient explosion.
+
+    check_rank : boolean, optional (default=False)
+        The basic assumption is that, if you pass a value for *D*, then
+        you already believe that *A* has rank $m$, so we do not waste time
+        checking it for you. If you do want this to be checked (and the
+        ordinary, non-modulo *D* algorithm to be used if the check fails), then
+        set *check_rank* to ``True``.
+
+    Returns
+    =======
+
+    :py:class:`~.DomainMatrix`
+        The HNF of matrix *A*.
+
+    Raises
+    ======
+
+    DMDomainError
+        If the domain of the matrix is not :ref:`ZZ`, or
+        if *D* is given but is not in :ref:`ZZ`.
+
+    DMShapeError
+        If the mod *D* algorithm is used but the matrix has more rows than
+        columns.
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
+       (See Algorithms 2.4.5 and 2.4.8.)
+
+    """
+    if not A.domain.is_ZZ:
+        raise DMDomainError('Matrix must be over domain ZZ.')
+    if D is not None and (not check_rank or A.convert_to(QQ).rank() == A.shape[0]):
+        return _hermite_normal_form_modulo_D(A, D)
+    else:
+        return _hermite_normal_form(A)
diff --git a/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/rref.py b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/rref.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5a71b04971e8dc8ecac5cc2691f98ba68e35d45
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/rref.py
@@ -0,0 +1,422 @@
+# Algorithms for computing the reduced row echelon form of a matrix.
+#
+# We need to choose carefully which algorithms to use depending on the domain,
+# shape, and sparsity of the matrix as well as things like the bit count in the
+# case of ZZ or QQ. This is important because the algorithms have different
+# performance characteristics in the extremes of dense vs sparse.
+#
+# In all cases we use the sparse implementations but we need to choose between
+# Gauss-Jordan elimination with division and fraction-free Gauss-Jordan
+# elimination. For very sparse matrices over ZZ with low bit counts it is
+# asymptotically faster to use Gauss-Jordan elimination with division. For
+# dense matrices with high bit counts it is asymptotically faster to use
+# fraction-free Gauss-Jordan.
+#
+# The most important thing is to get the extreme cases right because it can
+# make a big difference. In between the extremes though we have to make a
+# choice and here we use empirically determined thresholds based on timings
+# with random sparse matrices.
+#
+# In the case of QQ we have to consider the denominators as well. If the
+# denominators are small then it is faster to clear them and use fraction-free
+# Gauss-Jordan over ZZ. If the denominators are large then it is faster to use
+# Gauss-Jordan elimination with division over QQ.
+#
+# Timings for the various algorithms can be found at
+#
+#   https://github.com/sympy/sympy/issues/25410
+#   https://github.com/sympy/sympy/pull/25443
+
+from sympy.polys.domains import ZZ
+
+from sympy.polys.matrices.sdm import SDM, sdm_irref, sdm_rref_den
+from sympy.polys.matrices.ddm import DDM
+from sympy.polys.matrices.dense import ddm_irref, ddm_irref_den
+
+
+def _dm_rref(M, *, method='auto'):
+    """
+    Compute the reduced row echelon form of a ``DomainMatrix``.
+
+    This function is the implementation of :meth:`DomainMatrix.rref`.
+
+    Chooses the best algorithm depending on the domain, shape, and sparsity of
+    the matrix as well as things like the bit count in the case of :ref:`ZZ` or
+    :ref:`QQ`. The result is returned over the field associated with the domain
+    of the Matrix.
+
+    See Also
+    ========
+
+    sympy.polys.matrices.domainmatrix.DomainMatrix.rref
+        The ``DomainMatrix`` method that calls this function.
+    sympy.polys.matrices.rref._dm_rref_den
+        Alternative function for computing RREF with denominator.
+    """
+    method, use_fmt = _dm_rref_choose_method(M, method, denominator=False)
+
+    M, old_fmt = _dm_to_fmt(M, use_fmt)
+
+    if method == 'GJ':
+        # Use Gauss-Jordan with division over the associated field.
+        Mf = _to_field(M)
+        M_rref, pivots = _dm_rref_GJ(Mf)
+
+    elif method == 'FF':
+        # Use fraction-free GJ over the current domain.
+        M_rref_f, den, pivots = _dm_rref_den_FF(M)
+        M_rref = _to_field(M_rref_f) / den
+
+    elif method == 'CD':
+        # Clear denominators and use fraction-free GJ in the associated ring.
+        _, Mr = M.clear_denoms_rowwise(convert=True)
+        M_rref_f, den, pivots = _dm_rref_den_FF(Mr)
+        M_rref = _to_field(M_rref_f) / den
+
+    else:
+        raise ValueError(f"Unknown method for rref: {method}")
+
+    M_rref, _ = _dm_to_fmt(M_rref, old_fmt)
+
+    # Invariants:
+    #   - M_rref is in the same format (sparse or dense) as the input matrix.
+    #   - M_rref is in the associated field domain and any denominator was
+    #     divided in (so is implicitly 1 now).
+
+    return M_rref, pivots
+
+
+def _dm_rref_den(M, *, keep_domain=True, method='auto'):
+    """
+    Compute the reduced row echelon form of a ``DomainMatrix`` with denominator.
+
+    This function is the implementation of :meth:`DomainMatrix.rref_den`.
+
+    Chooses the best algorithm depending on the domain, shape, and sparsity of
+    the matrix as well as things like the bit count in the case of :ref:`ZZ` or
+    :ref:`QQ`. The result is returned over the same domain as the input matrix
+    unless ``keep_domain=False`` in which case the result might be over an
+    associated ring or field domain.
+
+    See Also
+    ========
+
+    sympy.polys.matrices.domainmatrix.DomainMatrix.rref_den
+        The ``DomainMatrix`` method that calls this function.
+    sympy.polys.matrices.rref._dm_rref
+        Alternative function for computing RREF without denominator.
+    """
+    method, use_fmt = _dm_rref_choose_method(M, method, denominator=True)
+
+    M, old_fmt = _dm_to_fmt(M, use_fmt)
+
+    if method == 'FF':
+        # Use fraction-free GJ over the current domain.
+        M_rref, den, pivots = _dm_rref_den_FF(M)
+
+    elif method == 'GJ':
+        # Use Gauss-Jordan with division over the associated field.
+        M_rref_f, pivots = _dm_rref_GJ(_to_field(M))
+
+        # Convert back to the ring?
+        if keep_domain and M_rref_f.domain != M.domain:
+            _, M_rref = M_rref_f.clear_denoms(convert=True)
+
+            if pivots:
+                den = M_rref[0, pivots[0]].element
+            else:
+                den = M_rref.domain.one
+        else:
+            # Possibly an associated field
+            M_rref = M_rref_f
+            den = M_rref.domain.one
+
+    elif method == 'CD':
+        # Clear denominators and use fraction-free GJ in the associated ring.
+        _, Mr = M.clear_denoms_rowwise(convert=True)
+
+        M_rref_r, den, pivots = _dm_rref_den_FF(Mr)
+
+        if keep_domain and M_rref_r.domain != M.domain:
+            # Convert back to the field
+            M_rref = _to_field(M_rref_r) / den
+            den = M.domain.one
+        else:
+            # Possibly an associated ring
+            M_rref = M_rref_r
+
+            if pivots:
+                den = M_rref[0, pivots[0]].element
+            else:
+                den = M_rref.domain.one
+    else:
+        raise ValueError(f"Unknown method for rref: {method}")
+
+    M_rref, _ = _dm_to_fmt(M_rref, old_fmt)
+
+    # Invariants:
+    #   - M_rref is in the same format (sparse or dense) as the input matrix.
+    #   - If keep_domain=True then M_rref and den are in the same domain as the
+    #     input matrix
+    #   - If keep_domain=False then M_rref might be in an associated ring or
+    #     field domain but den is always in the same domain as M_rref.
+
+    return M_rref, den, pivots
+
+
+def _dm_to_fmt(M, fmt):
+    """Convert a matrix to the given format and return the old format."""
+    old_fmt = M.rep.fmt
+    if old_fmt == fmt:
+        pass
+    elif fmt == 'dense':
+        M = M.to_dense()
+    elif fmt == 'sparse':
+        M = M.to_sparse()
+    else:
+        raise ValueError(f'Unknown format: {fmt}') # pragma: no cover
+    return M, old_fmt
+
+
+# These are the four basic implementations that we want to choose between:
+
+
+def _dm_rref_GJ(M):
+    """Compute RREF using Gauss-Jordan elimination with division."""
+    if M.rep.fmt == 'sparse':
+        return _dm_rref_GJ_sparse(M)
+    else:
+        return _dm_rref_GJ_dense(M)
+
+
+def _dm_rref_den_FF(M):
+    """Compute RREF using fraction-free Gauss-Jordan elimination."""
+    if M.rep.fmt == 'sparse':
+        return _dm_rref_den_FF_sparse(M)
+    else:
+        return _dm_rref_den_FF_dense(M)
+
+
+def _dm_rref_GJ_sparse(M):
+    """Compute RREF using sparse Gauss-Jordan elimination with division."""
+    M_rref_d, pivots, _ = sdm_irref(M.rep)
+    M_rref_sdm = SDM(M_rref_d, M.shape, M.domain)
+    pivots = tuple(pivots)
+    return M.from_rep(M_rref_sdm), pivots
+
+
+def _dm_rref_GJ_dense(M):
+    """Compute RREF using dense Gauss-Jordan elimination with division."""
+    partial_pivot = M.domain.is_RR or M.domain.is_CC
+    ddm = M.rep.to_ddm().copy()
+    pivots = ddm_irref(ddm, _partial_pivot=partial_pivot)
+    M_rref_ddm = DDM(ddm, M.shape, M.domain)
+    pivots = tuple(pivots)
+    return M.from_rep(M_rref_ddm.to_dfm_or_ddm()), pivots
+
+
+def _dm_rref_den_FF_sparse(M):
+    """Compute RREF using sparse fraction-free Gauss-Jordan elimination."""
+    M_rref_d, den, pivots = sdm_rref_den(M.rep, M.domain)
+    M_rref_sdm = SDM(M_rref_d, M.shape, M.domain)
+    pivots = tuple(pivots)
+    return M.from_rep(M_rref_sdm), den, pivots
+
+
+def _dm_rref_den_FF_dense(M):
+    """Compute RREF using sparse fraction-free Gauss-Jordan elimination."""
+    ddm = M.rep.to_ddm().copy()
+    den, pivots = ddm_irref_den(ddm, M.domain)
+    M_rref_ddm = DDM(ddm, M.shape, M.domain)
+    pivots = tuple(pivots)
+    return M.from_rep(M_rref_ddm.to_dfm_or_ddm()), den, pivots
+
+
+def _dm_rref_choose_method(M, method, *, denominator=False):
+    """Choose the fastest method for computing RREF for M."""
+
+    if method != 'auto':
+        if method.endswith('_dense'):
+            method = method[:-len('_dense')]
+            use_fmt = 'dense'
+        else:
+            use_fmt = 'sparse'
+
+    else:
+        # The sparse implementations are always faster
+        use_fmt = 'sparse'
+
+        K = M.domain
+
+        if K.is_ZZ:
+            method = _dm_rref_choose_method_ZZ(M, denominator=denominator)
+        elif K.is_QQ:
+            method = _dm_rref_choose_method_QQ(M, denominator=denominator)
+        elif K.is_RR or K.is_CC:
+            # TODO: Add partial pivot support to the sparse implementations.
+            method = 'GJ'
+            use_fmt = 'dense'
+        elif K.is_EX and M.rep.fmt == 'dense' and not denominator:
+            # Do not switch to the sparse implementation for EX because the
+            # domain does not have proper canonicalization and the sparse
+            # implementation gives equivalent but non-identical results over EX
+            # from performing arithmetic in a different order. Specifically
+            # test_issue_23718 ends up getting a more complicated expression
+            # when using the sparse implementation. Probably the best fix for
+            # this is something else but for now we stick with the dense
+            # implementation for EX if the matrix is already dense.
+            method = 'GJ'
+            use_fmt = 'dense'
+        else:
+            # This is definitely suboptimal. More work is needed to determine
+            # the best method for computing RREF over different domains.
+            if denominator:
+                method = 'FF'
+            else:
+                method = 'GJ'
+
+    return method, use_fmt
+
+
+def _dm_rref_choose_method_QQ(M, *, denominator=False):
+    """Choose the fastest method for computing RREF over QQ."""
+    # The same sorts of considerations apply here as in the case of ZZ. Here
+    # though a new more significant consideration is what sort of denominators
+    # we have and what to do with them so we focus on that.
+
+    # First compute the density. This is the average number of non-zero entries
+    # per row but only counting rows that have at least one non-zero entry
+    # since RREF can ignore fully zero rows.
+    density, _, ncols = _dm_row_density(M)
+
+    # For sparse matrices use Gauss-Jordan elimination over QQ regardless.
+    if density < min(5, ncols/2):
+        return 'GJ'
+
+    # Compare the bit-length of the lcm of the denominators to the bit length
+    # of the numerators.
+    #
+    # The threshold here is empirical: we prefer rref over QQ if clearing
+    # denominators would result in a numerator matrix having 5x the bit size of
+    # the current numerators.
+    numers, denoms = _dm_QQ_numers_denoms(M)
+    numer_bits = max([n.bit_length() for n in numers], default=1)
+
+    denom_lcm = ZZ.one
+    for d in denoms:
+        denom_lcm = ZZ.lcm(denom_lcm, d)
+        if denom_lcm.bit_length() > 5*numer_bits:
+            return 'GJ'
+
+    # If we get here then the matrix is dense and the lcm of the denominators
+    # is not too large compared to the numerators. For particularly small
+    # denominators it is fastest just to clear them and use fraction-free
+    # Gauss-Jordan over ZZ. With very small denominators this is a little
+    # faster than using rref_den over QQ but there is an intermediate regime
+    # where rref_den over QQ is significantly faster. The small denominator
+    # case is probably very common because small fractions like 1/2 or 1/3 are
+    # often seen in user inputs.
+
+    if denom_lcm.bit_length() < 50:
+        return 'CD'
+    else:
+        return 'FF'
+
+
+def _dm_rref_choose_method_ZZ(M, *, denominator=False):
+    """Choose the fastest method for computing RREF over ZZ."""
+    # In the extreme of very sparse matrices and low bit counts it is faster to
+    # use Gauss-Jordan elimination over QQ rather than fraction-free
+    # Gauss-Jordan over ZZ. In the opposite extreme of dense matrices and high
+    # bit counts it is faster to use fraction-free Gauss-Jordan over ZZ. These
+    # two extreme cases need to be handled differently because they lead to
+    # different asymptotic complexities. In between these two extremes we need
+    # a threshold for deciding which method to use. This threshold is
+    # determined empirically by timing the two methods with random matrices.
+
+    # The disadvantage of using empirical timings is that future optimisations
+    # might change the relative speeds so this can easily become out of date.
+    # The main thing is to get the asymptotic complexity right for the extreme
+    # cases though so the precise value of the threshold is hopefully not too
+    # important.
+
+    # Empirically determined parameter.
+    PARAM = 10000
+
+    # First compute the density. This is the average number of non-zero entries
+    # per row but only counting rows that have at least one non-zero entry
+    # since RREF can ignore fully zero rows.
+    density, nrows_nz, ncols = _dm_row_density(M)
+
+    # For small matrices use QQ if more than half the entries are zero.
+    if nrows_nz < 10:
+        if density < ncols/2:
+            return 'GJ'
+        else:
+            return 'FF'
+
+    # These are just shortcuts for the formula below.
+    if density < 5:
+        return 'GJ'
+    elif density > 5 + PARAM/nrows_nz:
+        return 'FF'  # pragma: no cover
+
+    # Maximum bitsize of any entry.
+    elements = _dm_elements(M)
+    bits = max([e.bit_length() for e in elements], default=1)
+
+    # Wideness parameter. This is 1 for square or tall matrices but >1 for wide
+    # matrices.
+    wideness = max(1, 2/3*ncols/nrows_nz)
+
+    max_density = (5 + PARAM/(nrows_nz*bits**2)) * wideness
+
+    if density < max_density:
+        return 'GJ'
+    else:
+        return 'FF'
+
+
+def _dm_row_density(M):
+    """Density measure for sparse matrices.
+
+    Defines the "density", ``d`` as the average number of non-zero entries per
+    row except ignoring rows that are fully zero. RREF can ignore fully zero
+    rows so they are excluded. By definition ``d >= 1`` except that we define
+    ``d = 0`` for the zero matrix.
+
+    Returns ``(density, nrows_nz, ncols)`` where ``nrows_nz`` counts the number
+    of nonzero rows and ``ncols`` is the number of columns.
+    """
+    # Uses the SDM dict-of-dicts representation.
+    ncols = M.shape[1]
+    rows_nz = M.rep.to_sdm().values()
+    if not rows_nz:
+        return 0, 0, ncols
+    else:
+        nrows_nz = len(rows_nz)
+        density = sum(map(len, rows_nz)) / nrows_nz
+        return density, nrows_nz, ncols
+
+
+def _dm_elements(M):
+    """Return nonzero elements of a DomainMatrix."""
+    elements, _ = M.to_flat_nz()
+    return elements
+
+
+def _dm_QQ_numers_denoms(Mq):
+    """Returns the numerators and denominators of a DomainMatrix over QQ."""
+    elements = _dm_elements(Mq)
+    numers = [e.numerator for e in elements]
+    denoms = [e.denominator for e in elements]
+    return numers, denoms
+
+
+def _to_field(M):
+    """Convert a DomainMatrix to a field if possible."""
+    K = M.domain
+    if K.has_assoc_Field:
+        return M.to_field()
+    else:
+        return M
diff --git a/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/sdm.py b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/sdm.py
new file mode 100644
index 0000000000000000000000000000000000000000..5afe39adfad5b28dad209742d34af9bf9cac6991
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/matrices/sdm.py
@@ -0,0 +1,2164 @@
+"""
+
+Module for the SDM class.
+
+"""
+
+from operator import add, neg, pos, sub, mul
+from collections import defaultdict
+
+from sympy.external.gmpy import GROUND_TYPES
+from sympy.utilities.decorator import doctest_depends_on
+from sympy.utilities.iterables import _strongly_connected_components
+
+from .exceptions import DMBadInputError, DMDomainError, DMShapeError
+
+from sympy.polys.domains import QQ
+
+from .ddm import DDM
+
+
+if GROUND_TYPES != 'flint':
+    __doctest_skip__ = ['SDM.to_dfm', 'SDM.to_dfm_or_ddm']
+
+
+class SDM(dict):
+    r"""Sparse matrix based on polys domain elements
+
+    This is a dict subclass and is a wrapper for a dict of dicts that supports
+    basic matrix arithmetic +, -, *, **.
+
+
+    In order to create a new :py:class:`~.SDM`, a dict
+    of dicts mapping non-zero elements to their
+    corresponding row and column in the matrix is needed.
+
+    We also need to specify the shape and :py:class:`~.Domain`
+    of our :py:class:`~.SDM` object.
+
+    We declare a 2x2 :py:class:`~.SDM` matrix belonging
+    to QQ domain as shown below.
+    The 2x2 Matrix in the example is
+
+    .. math::
+           A = \left[\begin{array}{ccc}
+                0 & \frac{1}{2} \\
+                0 & 0 \end{array} \right]
+
+
+    >>> from sympy.polys.matrices.sdm import SDM
+    >>> from sympy import QQ
+    >>> elemsdict = {0:{1:QQ(1, 2)}}
+    >>> A = SDM(elemsdict, (2, 2), QQ)
+    >>> A
+    {0: {1: 1/2}}
+
+    We can manipulate :py:class:`~.SDM` the same way
+    as a Matrix class
+
+    >>> from sympy import ZZ
+    >>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
+    >>> B  = SDM({0:{0: ZZ(3)}, 1:{1:ZZ(4)}}, (2, 2), ZZ)
+    >>> A + B
+    {0: {0: 3, 1: 2}, 1: {0: 1, 1: 4}}
+
+    Multiplication
+
+    >>> A*B
+    {0: {1: 8}, 1: {0: 3}}
+    >>> A*ZZ(2)
+    {0: {1: 4}, 1: {0: 2}}
+
+    """
+
+    fmt = 'sparse'
+    is_DFM = False
+    is_DDM = False
+
+    def __init__(self, elemsdict, shape, domain):
+        super().__init__(elemsdict)
+        self.shape = self.rows, self.cols = m, n = shape
+        self.domain = domain
+
+        if not all(0 <= r < m for r in self):
+            raise DMBadInputError("Row out of range")
+        if not all(0 <= c < n for row in self.values() for c in row):
+            raise DMBadInputError("Column out of range")
+
+    def getitem(self, i, j):
+        try:
+            return self[i][j]
+        except KeyError:
+            m, n = self.shape
+            if -m <= i < m and -n <= j < n:
+                try:
+                    return self[i % m][j % n]
+                except KeyError:
+                    return self.domain.zero
+            else:
+                raise IndexError("index out of range")
+
+    def setitem(self, i, j, value):
+        m, n = self.shape
+        if not (-m <= i < m and -n <= j < n):
+            raise IndexError("index out of range")
+        i, j = i % m, j % n
+        if value:
+            try:
+                self[i][j] = value
+            except KeyError:
+                self[i] = {j: value}
+        else:
+            rowi = self.get(i, None)
+            if rowi is not None:
+                try:
+                    del rowi[j]
+                except KeyError:
+                    pass
+                else:
+                    if not rowi:
+                        del self[i]
+
+    def extract_slice(self, slice1, slice2):
+        m, n = self.shape
+        ri = range(m)[slice1]
+        ci = range(n)[slice2]
+
+        sdm = {}
+        for i, row in self.items():
+            if i in ri:
+                row = {ci.index(j): e for j, e in row.items() if j in ci}
+                if row:
+                    sdm[ri.index(i)] = row
+
+        return self.new(sdm, (len(ri), len(ci)), self.domain)
+
+    def extract(self, rows, cols):
+        if not (self and rows and cols):
+            return self.zeros((len(rows), len(cols)), self.domain)
+
+        m, n = self.shape
+        if not (-m <= min(rows) <= max(rows) < m):
+            raise IndexError('Row index out of range')
+        if not (-n <= min(cols) <= max(cols) < n):
+            raise IndexError('Column index out of range')
+
+        # rows and cols can contain duplicates e.g. M[[1, 2, 2], [0, 1]]
+        # Build a map from row/col in self to list of rows/cols in output
+        rowmap = defaultdict(list)
+        colmap = defaultdict(list)
+        for i2, i1 in enumerate(rows):
+            rowmap[i1 % m].append(i2)
+        for j2, j1 in enumerate(cols):
+            colmap[j1 % n].append(j2)
+
+        # Used to efficiently skip zero rows/cols
+        rowset = set(rowmap)
+        colset = set(colmap)
+
+        sdm1 = self
+        sdm2 = {}
+        for i1 in rowset & sdm1.keys():
+            row1 = sdm1[i1]
+            row2 = {}
+            for j1 in colset & row1.keys():
+                row1_j1 = row1[j1]
+                for j2 in colmap[j1]:
+                    row2[j2] = row1_j1
+            if row2:
+                for i2 in rowmap[i1]:
+                    sdm2[i2] = row2.copy()
+
+        return self.new(sdm2, (len(rows), len(cols)), self.domain)
+
+    def __str__(self):
+        rowsstr = []
+        for i, row in self.items():
+            elemsstr = ', '.join('%s: %s' % (j, elem) for j, elem in row.items())
+            rowsstr.append('%s: {%s}' % (i, elemsstr))
+        return '{%s}' % ', '.join(rowsstr)
+
+    def __repr__(self):
+        cls = type(self).__name__
+        rows = dict.__repr__(self)
+        return '%s(%s, %s, %s)' % (cls, rows, self.shape, self.domain)
+
+    @classmethod
+    def new(cls, sdm, shape, domain):
+        """
+
+        Parameters
+        ==========
+
+        sdm: A dict of dicts for non-zero elements in SDM
+        shape: tuple representing dimension of SDM
+        domain: Represents :py:class:`~.Domain` of SDM
+
+        Returns
+        =======
+
+        An :py:class:`~.SDM` object
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> elemsdict = {0:{1: QQ(2)}}
+        >>> A = SDM.new(elemsdict, (2, 2), QQ)
+        >>> A
+        {0: {1: 2}}
+
+        """
+        return cls(sdm, shape, domain)
+
+    def copy(A):
+        """
+        Returns the copy of a :py:class:`~.SDM` object
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> elemsdict = {0:{1:QQ(2)}, 1:{}}
+        >>> A = SDM(elemsdict, (2, 2), QQ)
+        >>> B = A.copy()
+        >>> B
+        {0: {1: 2}, 1: {}}
+
+        """
+        Ac = {i: Ai.copy() for i, Ai in A.items()}
+        return A.new(Ac, A.shape, A.domain)
+
+    @classmethod
+    def from_list(cls, ddm, shape, domain):
+        """
+        Create :py:class:`~.SDM` object from a list of lists.
+
+        Parameters
+        ==========
+
+        ddm:
+            list of lists containing domain elements
+        shape:
+            Dimensions of :py:class:`~.SDM` matrix
+        domain:
+            Represents :py:class:`~.Domain` of :py:class:`~.SDM` object
+
+        Returns
+        =======
+
+        :py:class:`~.SDM` containing elements of ddm
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> ddm = [[QQ(1, 2), QQ(0)], [QQ(0), QQ(3, 4)]]
+        >>> A = SDM.from_list(ddm, (2, 2), QQ)
+        >>> A
+        {0: {0: 1/2}, 1: {1: 3/4}}
+
+        See Also
+        ========
+
+        to_list
+        from_list_flat
+        from_dok
+        from_ddm
+        """
+
+        m, n = shape
+        if not (len(ddm) == m and all(len(row) == n for row in ddm)):
+            raise DMBadInputError("Inconsistent row-list/shape")
+        getrow = lambda i: {j:ddm[i][j] for j in range(n) if ddm[i][j]}
+        irows = ((i, getrow(i)) for i in range(m))
+        sdm = {i: row for i, row in irows if row}
+        return cls(sdm, shape, domain)
+
+    @classmethod
+    def from_ddm(cls, ddm):
+        """
+        Create :py:class:`~.SDM` from a :py:class:`~.DDM`.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.ddm import DDM
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> ddm = DDM( [[QQ(1, 2), 0], [0, QQ(3, 4)]], (2, 2), QQ)
+        >>> A = SDM.from_ddm(ddm)
+        >>> A
+        {0: {0: 1/2}, 1: {1: 3/4}}
+        >>> SDM.from_ddm(ddm).to_ddm() == ddm
+        True
+
+        See Also
+        ========
+
+        to_ddm
+        from_list
+        from_list_flat
+        from_dok
+        """
+        return cls.from_list(ddm, ddm.shape, ddm.domain)
+
+    def to_list(M):
+        """
+        Convert a :py:class:`~.SDM` object to a list of lists.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> elemsdict = {0:{1:QQ(2)}, 1:{}}
+        >>> A = SDM(elemsdict, (2, 2), QQ)
+        >>> A.to_list()
+        [[0, 2], [0, 0]]
+
+
+        """
+        m, n = M.shape
+        zero = M.domain.zero
+        ddm = [[zero] * n for _ in range(m)]
+        for i, row in M.items():
+            for j, e in row.items():
+                ddm[i][j] = e
+        return ddm
+
+    def to_list_flat(M):
+        """
+        Convert :py:class:`~.SDM` to a flat list.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> A = SDM({0:{1:QQ(2)}, 1:{0: QQ(3)}}, (2, 2), QQ)
+        >>> A.to_list_flat()
+        [0, 2, 3, 0]
+        >>> A == A.from_list_flat(A.to_list_flat(), A.shape, A.domain)
+        True
+
+        See Also
+        ========
+
+        from_list_flat
+        to_list
+        to_dok
+        to_ddm
+        """
+        m, n = M.shape
+        zero = M.domain.zero
+        flat = [zero] * (m * n)
+        for i, row in M.items():
+            for j, e in row.items():
+                flat[i*n + j] = e
+        return flat
+
+    @classmethod
+    def from_list_flat(cls, elements, shape, domain):
+        """
+        Create :py:class:`~.SDM` from a flat list of elements.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> A = SDM.from_list_flat([QQ(0), QQ(2), QQ(0), QQ(0)], (2, 2), QQ)
+        >>> A
+        {0: {1: 2}}
+        >>> A == A.from_list_flat(A.to_list_flat(), A.shape, A.domain)
+        True
+
+        See Also
+        ========
+
+        to_list_flat
+        from_list
+        from_dok
+        from_ddm
+        """
+        m, n = shape
+        if len(elements) != m * n:
+            raise DMBadInputError("Inconsistent flat-list shape")
+        sdm = defaultdict(dict)
+        for inj, element in enumerate(elements):
+            if element:
+                i, j = divmod(inj, n)
+                sdm[i][j] = element
+        return cls(sdm, shape, domain)
+
+    def to_flat_nz(M):
+        """
+        Convert :class:`SDM` to a flat list of nonzero elements and data.
+
+        Explanation
+        ===========
+
+        This is used to operate on a list of the elements of a matrix and then
+        reconstruct a modified matrix with elements in the same positions using
+        :meth:`from_flat_nz`. Zero elements are omitted from the list.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> A = SDM({0:{1:QQ(2)}, 1:{0: QQ(3)}}, (2, 2), QQ)
+        >>> elements, data = A.to_flat_nz()
+        >>> elements
+        [2, 3]
+        >>> A == A.from_flat_nz(elements, data, A.domain)
+        True
+
+        See Also
+        ========
+
+        from_flat_nz
+        to_list_flat
+        sympy.polys.matrices.ddm.DDM.to_flat_nz
+        sympy.polys.matrices.domainmatrix.DomainMatrix.to_flat_nz
+        """
+        dok = M.to_dok()
+        indices = tuple(dok)
+        elements = list(dok.values())
+        data = (indices, M.shape)
+        return elements, data
+
+    @classmethod
+    def from_flat_nz(cls, elements, data, domain):
+        """
+        Reconstruct a :class:`~.SDM` after calling :meth:`to_flat_nz`.
+
+        See :meth:`to_flat_nz` for explanation.
+
+        See Also
+        ========
+
+        to_flat_nz
+        from_list_flat
+        sympy.polys.matrices.ddm.DDM.from_flat_nz
+        sympy.polys.matrices.domainmatrix.DomainMatrix.from_flat_nz
+        """
+        indices, shape = data
+        dok = dict(zip(indices, elements))
+        return cls.from_dok(dok, shape, domain)
+
+    def to_dod(M):
+        """
+        Convert to dictionary of dictionaries (dod) format.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> A = SDM({0: {1: QQ(2)}, 1: {0: QQ(3)}}, (2, 2), QQ)
+        >>> A.to_dod()
+        {0: {1: 2}, 1: {0: 3}}
+
+        See Also
+        ========
+
+        from_dod
+        sympy.polys.matrices.domainmatrix.DomainMatrix.to_dod
+        """
+        return {i: row.copy() for i, row in M.items()}
+
+    @classmethod
+    def from_dod(cls, dod, shape, domain):
+        """
+        Create :py:class:`~.SDM` from dictionary of dictionaries (dod) format.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> dod = {0: {1: QQ(2)}, 1: {0: QQ(3)}}
+        >>> A = SDM.from_dod(dod, (2, 2), QQ)
+        >>> A
+        {0: {1: 2}, 1: {0: 3}}
+        >>> A == SDM.from_dod(A.to_dod(), A.shape, A.domain)
+        True
+
+        See Also
+        ========
+
+        to_dod
+        sympy.polys.matrices.domainmatrix.DomainMatrix.to_dod
+        """
+        sdm = defaultdict(dict)
+        for i, row in dod.items():
+            for j, e in row.items():
+                if e:
+                    sdm[i][j] = e
+        return cls(sdm, shape, domain)
+
+    def to_dok(M):
+        """
+        Convert to dictionary of keys (dok) format.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> A = SDM({0: {1: QQ(2)}, 1: {0: QQ(3)}}, (2, 2), QQ)
+        >>> A.to_dok()
+        {(0, 1): 2, (1, 0): 3}
+
+        See Also
+        ========
+
+        from_dok
+        to_list
+        to_list_flat
+        to_ddm
+        """
+        return {(i, j): e for i, row in M.items() for j, e in row.items()}
+
+    @classmethod
+    def from_dok(cls, dok, shape, domain):
+        """
+        Create :py:class:`~.SDM` from dictionary of keys (dok) format.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> dok = {(0, 1): QQ(2), (1, 0): QQ(3)}
+        >>> A = SDM.from_dok(dok, (2, 2), QQ)
+        >>> A
+        {0: {1: 2}, 1: {0: 3}}
+        >>> A == SDM.from_dok(A.to_dok(), A.shape, A.domain)
+        True
+
+        See Also
+        ========
+
+        to_dok
+        from_list
+        from_list_flat
+        from_ddm
+        """
+        sdm = defaultdict(dict)
+        for (i, j), e in dok.items():
+            if e:
+                sdm[i][j] = e
+        return cls(sdm, shape, domain)
+
+    def iter_values(M):
+        """
+        Iterate over the nonzero values of a :py:class:`~.SDM` matrix.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> A = SDM({0: {1: QQ(2)}, 1: {0: QQ(3)}}, (2, 2), QQ)
+        >>> list(A.iter_values())
+        [2, 3]
+
+        """
+        for row in M.values():
+            yield from row.values()
+
+    def iter_items(M):
+        """
+        Iterate over indices and values of the nonzero elements.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> A = SDM({0: {1: QQ(2)}, 1: {0: QQ(3)}}, (2, 2), QQ)
+        >>> list(A.iter_items())
+        [((0, 1), 2), ((1, 0), 3)]
+
+        See Also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.iter_items
+        """
+        for i, row in M.items():
+            for j, e in row.items():
+                yield (i, j), e
+
+    def to_ddm(M):
+        """
+        Convert a :py:class:`~.SDM` object to a :py:class:`~.DDM` object
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> A = SDM({0:{1:QQ(2)}, 1:{}}, (2, 2), QQ)
+        >>> A.to_ddm()
+        [[0, 2], [0, 0]]
+
+        """
+        return DDM(M.to_list(), M.shape, M.domain)
+
+    def to_sdm(M):
+        """
+        Convert to :py:class:`~.SDM` format (returns self).
+        """
+        return M
+
+    @doctest_depends_on(ground_types=['flint'])
+    def to_dfm(M):
+        """
+        Convert a :py:class:`~.SDM` object to a :py:class:`~.DFM` object
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> A = SDM({0:{1:QQ(2)}, 1:{}}, (2, 2), QQ)
+        >>> A.to_dfm()
+        [[0, 2], [0, 0]]
+
+        See Also
+        ========
+
+        to_ddm
+        to_dfm_or_ddm
+        sympy.polys.matrices.domainmatrix.DomainMatrix.to_dfm
+        """
+        return M.to_ddm().to_dfm()
+
+    @doctest_depends_on(ground_types=['flint'])
+    def to_dfm_or_ddm(M):
+        """
+        Convert to :py:class:`~.DFM` if possible, else :py:class:`~.DDM`.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> A = SDM({0:{1:QQ(2)}, 1:{}}, (2, 2), QQ)
+        >>> A.to_dfm_or_ddm()
+        [[0, 2], [0, 0]]
+        >>> type(A.to_dfm_or_ddm())  # depends on the ground types
+        <class 'sympy.polys.matrices._dfm.DFM'>
+
+        See Also
+        ========
+
+        to_ddm
+        to_dfm
+        sympy.polys.matrices.domainmatrix.DomainMatrix.to_dfm_or_ddm
+        """
+        return M.to_ddm().to_dfm_or_ddm()
+
+    @classmethod
+    def zeros(cls, shape, domain):
+        r"""
+
+        Returns a :py:class:`~.SDM` of size shape,
+        belonging to the specified domain
+
+        In the example below we declare a matrix A where,
+
+        .. math::
+            A := \left[\begin{array}{ccc}
+            0 & 0 & 0 \\
+            0 & 0 & 0 \end{array} \right]
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> A = SDM.zeros((2, 3), QQ)
+        >>> A
+        {}
+
+        """
+        return cls({}, shape, domain)
+
+    @classmethod
+    def ones(cls, shape, domain):
+        one = domain.one
+        m, n = shape
+        row = dict(zip(range(n), [one]*n))
+        sdm = {i: row.copy() for i in range(m)}
+        return cls(sdm, shape, domain)
+
+    @classmethod
+    def eye(cls, shape, domain):
+        """
+
+        Returns a identity :py:class:`~.SDM` matrix of dimensions
+        size x size, belonging to the specified domain
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> I = SDM.eye((2, 2), QQ)
+        >>> I
+        {0: {0: 1}, 1: {1: 1}}
+
+        """
+        if isinstance(shape, int):
+            rows, cols = shape, shape
+        else:
+            rows, cols = shape
+        one = domain.one
+        sdm = {i: {i: one} for i in range(min(rows, cols))}
+        return cls(sdm, (rows, cols), domain)
+
+    @classmethod
+    def diag(cls, diagonal, domain, shape=None):
+        if shape is None:
+            shape = (len(diagonal), len(diagonal))
+        sdm = {i: {i: v} for i, v in enumerate(diagonal) if v}
+        return cls(sdm, shape, domain)
+
+    def transpose(M):
+        """
+
+        Returns the transpose of a :py:class:`~.SDM` matrix
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> A = SDM({0:{1:QQ(2)}, 1:{}}, (2, 2), QQ)
+        >>> A.transpose()
+        {1: {0: 2}}
+
+        """
+        MT = sdm_transpose(M)
+        return M.new(MT, M.shape[::-1], M.domain)
+
+    def __add__(A, B):
+        if not isinstance(B, SDM):
+            return NotImplemented
+        elif A.shape != B.shape:
+            raise DMShapeError("Matrix size mismatch: %s + %s" % (A.shape, B.shape))
+        return A.add(B)
+
+    def __sub__(A, B):
+        if not isinstance(B, SDM):
+            return NotImplemented
+        elif A.shape != B.shape:
+            raise DMShapeError("Matrix size mismatch: %s - %s" % (A.shape, B.shape))
+        return A.sub(B)
+
+    def __neg__(A):
+        return A.neg()
+
+    def __mul__(A, B):
+        """A * B"""
+        if isinstance(B, SDM):
+            return A.matmul(B)
+        elif B in A.domain:
+            return A.mul(B)
+        else:
+            return NotImplemented
+
+    def __rmul__(a, b):
+        if b in a.domain:
+            return a.rmul(b)
+        else:
+            return NotImplemented
+
+    def matmul(A, B):
+        """
+        Performs matrix multiplication of two SDM matrices
+
+        Parameters
+        ==========
+
+        A, B: SDM to multiply
+
+        Returns
+        =======
+
+        SDM
+            SDM after multiplication
+
+        Raises
+        ======
+
+        DomainError
+            If domain of A does not match
+            with that of B
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
+        >>> B = SDM({0:{0:ZZ(2), 1:ZZ(3)}, 1:{0:ZZ(4)}}, (2, 2), ZZ)
+        >>> A.matmul(B)
+        {0: {0: 8}, 1: {0: 2, 1: 3}}
+
+        """
+        if A.domain != B.domain:
+            raise DMDomainError
+        m, n = A.shape
+        n2, o = B.shape
+        if n != n2:
+            raise DMShapeError
+        C = sdm_matmul(A, B, A.domain, m, o)
+        return A.new(C, (m, o), A.domain)
+
+    def mul(A, b):
+        """
+        Multiplies each element of A with a scalar b
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
+        >>> A.mul(ZZ(3))
+        {0: {1: 6}, 1: {0: 3}}
+
+        """
+        Csdm = unop_dict(A, lambda aij: aij*b)
+        return A.new(Csdm, A.shape, A.domain)
+
+    def rmul(A, b):
+        Csdm = unop_dict(A, lambda aij: b*aij)
+        return A.new(Csdm, A.shape, A.domain)
+
+    def mul_elementwise(A, B):
+        if A.domain != B.domain:
+            raise DMDomainError
+        if A.shape != B.shape:
+            raise DMShapeError
+        zero = A.domain.zero
+        fzero = lambda e: zero
+        Csdm = binop_dict(A, B, mul, fzero, fzero)
+        return A.new(Csdm, A.shape, A.domain)
+
+    def add(A, B):
+        """
+
+        Adds two :py:class:`~.SDM` matrices
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
+        >>> B = SDM({0:{0: ZZ(3)}, 1:{1:ZZ(4)}}, (2, 2), ZZ)
+        >>> A.add(B)
+        {0: {0: 3, 1: 2}, 1: {0: 1, 1: 4}}
+
+        """
+        Csdm = binop_dict(A, B, add, pos, pos)
+        return A.new(Csdm, A.shape, A.domain)
+
+    def sub(A, B):
+        """
+
+        Subtracts two :py:class:`~.SDM` matrices
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
+        >>> B  = SDM({0:{0: ZZ(3)}, 1:{1:ZZ(4)}}, (2, 2), ZZ)
+        >>> A.sub(B)
+        {0: {0: -3, 1: 2}, 1: {0: 1, 1: -4}}
+
+        """
+        Csdm = binop_dict(A, B, sub, pos, neg)
+        return A.new(Csdm, A.shape, A.domain)
+
+    def neg(A):
+        """
+
+        Returns the negative of a :py:class:`~.SDM` matrix
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
+        >>> A.neg()
+        {0: {1: -2}, 1: {0: -1}}
+
+        """
+        Csdm = unop_dict(A, neg)
+        return A.new(Csdm, A.shape, A.domain)
+
+    def convert_to(A, K):
+        """
+        Converts the :py:class:`~.Domain` of a :py:class:`~.SDM` matrix to K
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ, QQ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
+        >>> A.convert_to(QQ)
+        {0: {1: 2}, 1: {0: 1}}
+
+        """
+        Kold = A.domain
+        if K == Kold:
+            return A.copy()
+        Ak = unop_dict(A, lambda e: K.convert_from(e, Kold))
+        return A.new(Ak, A.shape, K)
+
+    def nnz(A):
+        """Number of non-zero elements in the :py:class:`~.SDM` matrix.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
+        >>> A.nnz()
+        2
+
+        See Also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.nnz
+        """
+        return sum(map(len, A.values()))
+
+    def scc(A):
+        """Strongly connected components of a square matrix *A*.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{0: ZZ(2)}, 1:{1:ZZ(1)}}, (2, 2), ZZ)
+        >>> A.scc()
+        [[0], [1]]
+
+        See also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.scc
+        """
+        rows, cols = A.shape
+        assert rows == cols
+        V = range(rows)
+        Emap = {v: list(A.get(v, [])) for v in V}
+        return _strongly_connected_components(V, Emap)
+
+    def rref(A):
+        """
+
+        Returns reduced-row echelon form and list of pivots for the :py:class:`~.SDM`
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(2), 1:QQ(4)}}, (2, 2), QQ)
+        >>> A.rref()
+        ({0: {0: 1, 1: 2}}, [0])
+
+        """
+        B, pivots, _ = sdm_irref(A)
+        return A.new(B, A.shape, A.domain), pivots
+
+    def rref_den(A):
+        """
+
+        Returns reduced-row echelon form (RREF) with denominator and pivots.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(2), 1:QQ(4)}}, (2, 2), QQ)
+        >>> A.rref_den()
+        ({0: {0: 1, 1: 2}}, 1, [0])
+
+        """
+        K = A.domain
+        A_rref_sdm, denom, pivots = sdm_rref_den(A, K)
+        A_rref = A.new(A_rref_sdm, A.shape, A.domain)
+        return A_rref, denom, pivots
+
+    def inv(A):
+        """
+
+        Returns inverse of a matrix A
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+        >>> A.inv()
+        {0: {0: -2, 1: 1}, 1: {0: 3/2, 1: -1/2}}
+
+        """
+        return A.to_dfm_or_ddm().inv().to_sdm()
+
+    def det(A):
+        """
+        Returns determinant of A
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+        >>> A.det()
+        -2
+
+        """
+        # It would be better to have a sparse implementation of det for use
+        # with very sparse matrices. Extremely sparse matrices probably just
+        # have determinant zero and we could probably detect that very quickly.
+        # In the meantime, we convert to a dense matrix and use ddm_idet.
+        #
+        # If GROUND_TYPES=flint though then we will use Flint's implementation
+        # if possible (dfm).
+        return A.to_dfm_or_ddm().det()
+
+    def lu(A):
+        """
+
+        Returns LU decomposition for a matrix A
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+        >>> A.lu()
+        ({0: {0: 1}, 1: {0: 3, 1: 1}}, {0: {0: 1, 1: 2}, 1: {1: -2}}, [])
+
+        """
+        L, U, swaps = A.to_ddm().lu()
+        return A.from_ddm(L), A.from_ddm(U), swaps
+
+    def lu_solve(A, b):
+        """
+
+        Uses LU decomposition to solve Ax = b,
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+        >>> b = SDM({0:{0:QQ(1)}, 1:{0:QQ(2)}}, (2, 1), QQ)
+        >>> A.lu_solve(b)
+        {1: {0: 1/2}}
+
+        """
+        return A.from_ddm(A.to_ddm().lu_solve(b.to_ddm()))
+
+    def nullspace(A):
+        """
+        Nullspace of a :py:class:`~.SDM` matrix A.
+
+        The domain of the matrix must be a field.
+
+        It is better to use the :meth:`~.DomainMatrix.nullspace` method rather
+        than this method which is otherwise no longer used.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0: QQ(2), 1: QQ(4)}}, (2, 2), QQ)
+        >>> A.nullspace()
+        ({0: {0: -2, 1: 1}}, [1])
+
+
+        See Also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.nullspace
+            The preferred way to get the nullspace of a matrix.
+
+        """
+        ncols = A.shape[1]
+        one = A.domain.one
+        B, pivots, nzcols = sdm_irref(A)
+        K, nonpivots = sdm_nullspace_from_rref(B, one, ncols, pivots, nzcols)
+        K = dict(enumerate(K))
+        shape = (len(K), ncols)
+        return A.new(K, shape, A.domain), nonpivots
+
+    def nullspace_from_rref(A, pivots=None):
+        """
+        Returns nullspace for a :py:class:`~.SDM` matrix ``A`` in RREF.
+
+        The domain of the matrix can be any domain.
+
+        The matrix must already be in reduced row echelon form (RREF).
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0: QQ(2), 1: QQ(4)}}, (2, 2), QQ)
+        >>> A_rref, pivots = A.rref()
+        >>> A_null, nonpivots = A_rref.nullspace_from_rref(pivots)
+        >>> A_null
+        {0: {0: -2, 1: 1}}
+        >>> pivots
+        [0]
+        >>> nonpivots
+        [1]
+
+        See Also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.nullspace
+            The higher-level function that would usually be called instead of
+            calling this one directly.
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.nullspace_from_rref
+            The higher-level direct equivalent of this function.
+
+        sympy.polys.matrices.ddm.DDM.nullspace_from_rref
+            The equivalent function for dense :py:class:`~.DDM` matrices.
+
+        """
+        m, n = A.shape
+        K = A.domain
+
+        if pivots is None:
+            pivots = sorted(map(min, A.values()))
+
+        if not pivots:
+            return A.eye((n, n), K), list(range(n))
+        elif len(pivots) == n:
+            return A.zeros((0, n), K), []
+
+        # In fraction-free RREF the nonzero entry inserted for the pivots is
+        # not necessarily 1.
+        pivot_val = A[0][pivots[0]]
+        assert not K.is_zero(pivot_val)
+
+        pivots_set = set(pivots)
+
+        # Loop once over all nonzero entries making a map from column indices
+        # to the nonzero entries in that column along with the row index of the
+        # nonzero entry. This is basically the transpose of the matrix.
+        nonzero_cols = defaultdict(list)
+        for i, Ai in A.items():
+            for j, Aij in Ai.items():
+                nonzero_cols[j].append((i, Aij))
+
+        # Usually in SDM we want to avoid looping over the dimensions of the
+        # matrix because it is optimised to support extremely sparse matrices.
+        # Here in nullspace though every zero column becomes a nonzero column
+        # so we need to loop once over the columns at least (range(n)) rather
+        # than just the nonzero entries of the matrix. We can still avoid
+        # an inner loop over the rows though by using the nonzero_cols map.
+        basis = []
+        nonpivots = []
+        for j in range(n):
+            if j in pivots_set:
+                continue
+            nonpivots.append(j)
+
+            vec = {j: pivot_val}
+            for ip, Aij in nonzero_cols[j]:
+                vec[pivots[ip]] = -Aij
+
+            basis.append(vec)
+
+        sdm = dict(enumerate(basis))
+        A_null = A.new(sdm, (len(basis), n), K)
+
+        return (A_null, nonpivots)
+
+    def particular(A):
+        ncols = A.shape[1]
+        B, pivots, nzcols = sdm_irref(A)
+        P = sdm_particular_from_rref(B, ncols, pivots)
+        rep = {0:P} if P else {}
+        return A.new(rep, (1, ncols-1), A.domain)
+
+    def hstack(A, *B):
+        """Horizontally stacks :py:class:`~.SDM` matrices.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices.sdm import SDM
+
+        >>> A = SDM({0: {0: ZZ(1), 1: ZZ(2)}, 1: {0: ZZ(3), 1: ZZ(4)}}, (2, 2), ZZ)
+        >>> B = SDM({0: {0: ZZ(5), 1: ZZ(6)}, 1: {0: ZZ(7), 1: ZZ(8)}}, (2, 2), ZZ)
+        >>> A.hstack(B)
+        {0: {0: 1, 1: 2, 2: 5, 3: 6}, 1: {0: 3, 1: 4, 2: 7, 3: 8}}
+
+        >>> C = SDM({0: {0: ZZ(9), 1: ZZ(10)}, 1: {0: ZZ(11), 1: ZZ(12)}}, (2, 2), ZZ)
+        >>> A.hstack(B, C)
+        {0: {0: 1, 1: 2, 2: 5, 3: 6, 4: 9, 5: 10}, 1: {0: 3, 1: 4, 2: 7, 3: 8, 4: 11, 5: 12}}
+        """
+        Anew = dict(A.copy())
+        rows, cols = A.shape
+        domain = A.domain
+
+        for Bk in B:
+            Bkrows, Bkcols = Bk.shape
+            assert Bkrows == rows
+            assert Bk.domain == domain
+
+            for i, Bki in Bk.items():
+                Ai = Anew.get(i, None)
+                if Ai is None:
+                    Anew[i] = Ai = {}
+                for j, Bkij in Bki.items():
+                    Ai[j + cols] = Bkij
+            cols += Bkcols
+
+        return A.new(Anew, (rows, cols), A.domain)
+
+    def vstack(A, *B):
+        """Vertically stacks :py:class:`~.SDM` matrices.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices.sdm import SDM
+
+        >>> A = SDM({0: {0: ZZ(1), 1: ZZ(2)}, 1: {0: ZZ(3), 1: ZZ(4)}}, (2, 2), ZZ)
+        >>> B = SDM({0: {0: ZZ(5), 1: ZZ(6)}, 1: {0: ZZ(7), 1: ZZ(8)}}, (2, 2), ZZ)
+        >>> A.vstack(B)
+        {0: {0: 1, 1: 2}, 1: {0: 3, 1: 4}, 2: {0: 5, 1: 6}, 3: {0: 7, 1: 8}}
+
+        >>> C = SDM({0: {0: ZZ(9), 1: ZZ(10)}, 1: {0: ZZ(11), 1: ZZ(12)}}, (2, 2), ZZ)
+        >>> A.vstack(B, C)
+        {0: {0: 1, 1: 2}, 1: {0: 3, 1: 4}, 2: {0: 5, 1: 6}, 3: {0: 7, 1: 8}, 4: {0: 9, 1: 10}, 5: {0: 11, 1: 12}}
+        """
+        Anew = dict(A.copy())
+        rows, cols = A.shape
+        domain = A.domain
+
+        for Bk in B:
+            Bkrows, Bkcols = Bk.shape
+            assert Bkcols == cols
+            assert Bk.domain == domain
+
+            for i, Bki in Bk.items():
+                Anew[i + rows] = Bki
+            rows += Bkrows
+
+        return A.new(Anew, (rows, cols), A.domain)
+
+    def applyfunc(self, func, domain):
+        sdm = {i: {j: func(e) for j, e in row.items()} for i, row in self.items()}
+        return self.new(sdm, self.shape, domain)
+
+    def charpoly(A):
+        """
+        Returns the coefficients of the characteristic polynomial
+        of the :py:class:`~.SDM` matrix. These elements will be domain elements.
+        The domain of the elements will be same as domain of the :py:class:`~.SDM`.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ, Symbol
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy.polys import Poly
+        >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+        >>> A.charpoly()
+        [1, -5, -2]
+
+        We can create a polynomial using the
+        coefficients using :py:class:`~.Poly`
+
+        >>> x = Symbol('x')
+        >>> p = Poly(A.charpoly(), x, domain=A.domain)
+        >>> p
+        Poly(x**2 - 5*x - 2, x, domain='QQ')
+
+        """
+        K = A.domain
+        n, _ = A.shape
+        pdict = sdm_berk(A, n, K)
+        plist = [K.zero] * (n + 1)
+        for i, pi in pdict.items():
+            plist[i] = pi
+        return plist
+
+    def is_zero_matrix(self):
+        """
+        Says whether this matrix has all zero entries.
+        """
+        return not self
+
+    def is_upper(self):
+        """
+        Says whether this matrix is upper-triangular. True can be returned
+        even if the matrix is not square.
+        """
+        return all(i <= j for i, row in self.items() for j in row)
+
+    def is_lower(self):
+        """
+        Says whether this matrix is lower-triangular. True can be returned
+        even if the matrix is not square.
+        """
+        return all(i >= j for i, row in self.items() for j in row)
+
+    def is_diagonal(self):
+        """
+        Says whether this matrix is diagonal. True can be returned
+        even if the matrix is not square.
+        """
+        return all(i == j for i, row in self.items() for j in row)
+
+    def diagonal(self):
+        """
+        Returns the diagonal of the matrix as a list.
+        """
+        m, n = self.shape
+        zero = self.domain.zero
+        return [row.get(i, zero) for i, row in self.items() if i < n]
+
+    def lll(A, delta=QQ(3, 4)):
+        """
+        Returns the LLL-reduced basis for the :py:class:`~.SDM` matrix.
+        """
+        return A.to_dfm_or_ddm().lll(delta=delta).to_sdm()
+
+    def lll_transform(A, delta=QQ(3, 4)):
+        """
+        Returns the LLL-reduced basis and transformation matrix.
+        """
+        reduced, transform = A.to_dfm_or_ddm().lll_transform(delta=delta)
+        return reduced.to_sdm(), transform.to_sdm()
+
+
+def binop_dict(A, B, fab, fa, fb):
+    Anz, Bnz = set(A), set(B)
+    C = {}
+
+    for i in Anz & Bnz:
+        Ai, Bi = A[i], B[i]
+        Ci = {}
+        Anzi, Bnzi = set(Ai), set(Bi)
+        for j in Anzi & Bnzi:
+            Cij = fab(Ai[j], Bi[j])
+            if Cij:
+                Ci[j] = Cij
+        for j in Anzi - Bnzi:
+            Cij = fa(Ai[j])
+            if Cij:
+                Ci[j] = Cij
+        for j in Bnzi - Anzi:
+            Cij = fb(Bi[j])
+            if Cij:
+                Ci[j] = Cij
+        if Ci:
+            C[i] = Ci
+
+    for i in Anz - Bnz:
+        Ai = A[i]
+        Ci = {}
+        for j, Aij in Ai.items():
+            Cij = fa(Aij)
+            if Cij:
+                Ci[j] = Cij
+        if Ci:
+            C[i] = Ci
+
+    for i in Bnz - Anz:
+        Bi = B[i]
+        Ci = {}
+        for j, Bij in Bi.items():
+            Cij = fb(Bij)
+            if Cij:
+                Ci[j] = Cij
+        if Ci:
+            C[i] = Ci
+
+    return C
+
+
+def unop_dict(A, f):
+    B = {}
+    for i, Ai in A.items():
+        Bi = {}
+        for j, Aij in Ai.items():
+            Bij = f(Aij)
+            if Bij:
+                Bi[j] = Bij
+        if Bi:
+            B[i] = Bi
+    return B
+
+
+def sdm_transpose(M):
+    MT = {}
+    for i, Mi in M.items():
+        for j, Mij in Mi.items():
+            try:
+                MT[j][i] = Mij
+            except KeyError:
+                MT[j] = {i: Mij}
+    return MT
+
+
+def sdm_dotvec(A, B, K):
+    return K.sum(A[j] * B[j] for j in A.keys() & B.keys())
+
+
+def sdm_matvecmul(A, B, K):
+    C = {}
+    for i, Ai in A.items():
+        Ci = sdm_dotvec(Ai, B, K)
+        if Ci:
+            C[i] = Ci
+    return C
+
+
+def sdm_matmul(A, B, K, m, o):
+    #
+    # Should be fast if A and B are very sparse.
+    # Consider e.g. A = B = eye(1000).
+    #
+    # The idea here is that we compute C = A*B in terms of the rows of C and
+    # B since the dict of dicts representation naturally stores the matrix as
+    # rows. The ith row of C (Ci) is equal to the sum of Aik * Bk where Bk is
+    # the kth row of B. The algorithm below loops over each nonzero element
+    # Aik of A and if the corresponding row Bj is nonzero then we do
+    #    Ci += Aik * Bk.
+    # To make this more efficient we don't need to loop over all elements Aik.
+    # Instead for each row Ai we compute the intersection of the nonzero
+    # columns in Ai with the nonzero rows in B. That gives the k such that
+    # Aik and Bk are both nonzero. In Python the intersection of two sets
+    # of int can be computed very efficiently.
+    #
+    if K.is_EXRAW:
+        return sdm_matmul_exraw(A, B, K, m, o)
+
+    C = {}
+    B_knz = set(B)
+    for i, Ai in A.items():
+        Ci = {}
+        Ai_knz = set(Ai)
+        for k in Ai_knz & B_knz:
+            Aik = Ai[k]
+            for j, Bkj in B[k].items():
+                Cij = Ci.get(j, None)
+                if Cij is not None:
+                    Cij = Cij + Aik * Bkj
+                    if Cij:
+                        Ci[j] = Cij
+                    else:
+                        Ci.pop(j)
+                else:
+                    Cij = Aik * Bkj
+                    if Cij:
+                        Ci[j] = Cij
+        if Ci:
+            C[i] = Ci
+    return C
+
+
+def sdm_matmul_exraw(A, B, K, m, o):
+    #
+    # Like sdm_matmul above except that:
+    #
+    # - Handles cases like 0*oo -> nan (sdm_matmul skips multipication by zero)
+    # - Uses K.sum (Add(*items)) for efficient addition of Expr
+    #
+    zero = K.zero
+    C = {}
+    B_knz = set(B)
+    for i, Ai in A.items():
+        Ci_list = defaultdict(list)
+        Ai_knz = set(Ai)
+
+        # Nonzero row/column pair
+        for k in Ai_knz & B_knz:
+            Aik = Ai[k]
+            if zero * Aik == zero:
+                # This is the main inner loop:
+                for j, Bkj in B[k].items():
+                    Ci_list[j].append(Aik * Bkj)
+            else:
+                for j in range(o):
+                    Ci_list[j].append(Aik * B[k].get(j, zero))
+
+        # Zero row in B, check for infinities in A
+        for k in Ai_knz - B_knz:
+            zAik = zero * Ai[k]
+            if zAik != zero:
+                for j in range(o):
+                    Ci_list[j].append(zAik)
+
+        # Add terms using K.sum (Add(*terms)) for efficiency
+        Ci = {}
+        for j, Cij_list in Ci_list.items():
+            Cij = K.sum(Cij_list)
+            if Cij:
+                Ci[j] = Cij
+        if Ci:
+            C[i] = Ci
+
+    # Find all infinities in B
+    for k, Bk in B.items():
+        for j, Bkj in Bk.items():
+            if zero * Bkj != zero:
+                for i in range(m):
+                    Aik = A.get(i, {}).get(k, zero)
+                    # If Aik is not zero then this was handled above
+                    if Aik == zero:
+                        Ci = C.get(i, {})
+                        Cij = Ci.get(j, zero) + Aik * Bkj
+                        if Cij != zero:
+                            Ci[j] = Cij
+                        else:  # pragma: no cover
+                            # Not sure how we could get here but let's raise an
+                            # exception just in case.
+                            raise RuntimeError
+                        C[i] = Ci
+
+    return C
+
+
+def sdm_irref(A):
+    """RREF and pivots of a sparse matrix *A*.
+
+    Compute the reduced row echelon form (RREF) of the matrix *A* and return a
+    list of the pivot columns. This routine does not work in place and leaves
+    the original matrix *A* unmodified.
+
+    The domain of the matrix must be a field.
+
+    Examples
+    ========
+
+    This routine works with a dict of dicts sparse representation of a matrix:
+
+    >>> from sympy import QQ
+    >>> from sympy.polys.matrices.sdm import sdm_irref
+    >>> A = {0: {0: QQ(1), 1: QQ(2)}, 1: {0: QQ(3), 1: QQ(4)}}
+    >>> Arref, pivots, _ = sdm_irref(A)
+    >>> Arref
+    {0: {0: 1}, 1: {1: 1}}
+    >>> pivots
+    [0, 1]
+
+    The analogous calculation with :py:class:`~.MutableDenseMatrix` would be
+
+    >>> from sympy import Matrix
+    >>> M = Matrix([[1, 2], [3, 4]])
+    >>> Mrref, pivots = M.rref()
+    >>> Mrref
+    Matrix([
+    [1, 0],
+    [0, 1]])
+    >>> pivots
+    (0, 1)
+
+    Notes
+    =====
+
+    The cost of this algorithm is determined purely by the nonzero elements of
+    the matrix. No part of the cost of any step in this algorithm depends on
+    the number of rows or columns in the matrix. No step depends even on the
+    number of nonzero rows apart from the primary loop over those rows. The
+    implementation is much faster than ddm_rref for sparse matrices. In fact
+    at the time of writing it is also (slightly) faster than the dense
+    implementation even if the input is a fully dense matrix so it seems to be
+    faster in all cases.
+
+    The elements of the matrix should support exact division with ``/``. For
+    example elements of any domain that is a field (e.g. ``QQ``) should be
+    fine. No attempt is made to handle inexact arithmetic.
+
+    See Also
+    ========
+
+    sympy.polys.matrices.domainmatrix.DomainMatrix.rref
+        The higher-level function that would normally be used to call this
+        routine.
+    sympy.polys.matrices.dense.ddm_irref
+        The dense equivalent of this routine.
+    sdm_rref_den
+        Fraction-free version of this routine.
+    """
+    #
+    # Any zeros in the matrix are not stored at all so an element is zero if
+    # its row dict has no index at that key. A row is entirely zero if its
+    # row index is not in the outer dict. Since rref reorders the rows and
+    # removes zero rows we can completely discard the row indices. The first
+    # step then copies the row dicts into a list sorted by the index of the
+    # first nonzero column in each row.
+    #
+    # The algorithm then processes each row Ai one at a time. Previously seen
+    # rows are used to cancel their pivot columns from Ai. Then a pivot from
+    # Ai is chosen and is cancelled from all previously seen rows. At this
+    # point Ai joins the previously seen rows. Once all rows are seen all
+    # elimination has occurred and the rows are sorted by pivot column index.
+    #
+    # The previously seen rows are stored in two separate groups. The reduced
+    # group consists of all rows that have been reduced to a single nonzero
+    # element (the pivot). There is no need to attempt any further reduction
+    # with these. Rows that still have other nonzeros need to be considered
+    # when Ai is cancelled from the previously seen rows.
+    #
+    # A dict nonzerocolumns is used to map from a column index to a set of
+    # previously seen rows that still have a nonzero element in that column.
+    # This means that we can cancel the pivot from Ai into the previously seen
+    # rows without needing to loop over each row that might have a zero in
+    # that column.
+    #
+
+    # Row dicts sorted by index of first nonzero column
+    # (Maybe sorting is not needed/useful.)
+    Arows = sorted((Ai.copy() for Ai in A.values()), key=min)
+
+    # Each processed row has an associated pivot column.
+    # pivot_row_map maps from the pivot column index to the row dict.
+    # This means that we can represent a set of rows purely as a set of their
+    # pivot indices.
+    pivot_row_map = {}
+
+    # Set of pivot indices for rows that are fully reduced to a single nonzero.
+    reduced_pivots = set()
+
+    # Set of pivot indices for rows not fully reduced
+    nonreduced_pivots = set()
+
+    # Map from column index to a set of pivot indices representing the rows
+    # that have a nonzero at that column.
+    nonzero_columns = defaultdict(set)
+
+    while Arows:
+        # Select pivot element and row
+        Ai = Arows.pop()
+
+        # Nonzero columns from fully reduced pivot rows can be removed
+        Ai = {j: Aij for j, Aij in Ai.items() if j not in reduced_pivots}
+
+        # Others require full row cancellation
+        for j in nonreduced_pivots & set(Ai):
+            Aj = pivot_row_map[j]
+            Aij = Ai[j]
+            Ainz = set(Ai)
+            Ajnz = set(Aj)
+            for k in Ajnz - Ainz:
+                Ai[k] = - Aij * Aj[k]
+            Ai.pop(j)
+            Ainz.remove(j)
+            for k in Ajnz & Ainz:
+                Aik = Ai[k] - Aij * Aj[k]
+                if Aik:
+                    Ai[k] = Aik
+                else:
+                    Ai.pop(k)
+
+        # We have now cancelled previously seen pivots from Ai.
+        # If it is zero then discard it.
+        if not Ai:
+            continue
+
+        # Choose a pivot from Ai:
+        j = min(Ai)
+        Aij = Ai[j]
+        pivot_row_map[j] = Ai
+        Ainz = set(Ai)
+
+        # Normalise the pivot row to make the pivot 1.
+        #
+        # This approach is slow for some domains. Cross cancellation might be
+        # better for e.g. QQ(x) with division delayed to the final steps.
+        Aijinv = Aij**-1
+        for l in Ai:
+            Ai[l] *= Aijinv
+
+        # Use Aij to cancel column j from all previously seen rows
+        for k in nonzero_columns.pop(j, ()):
+            Ak = pivot_row_map[k]
+            Akj = Ak[j]
+            Aknz = set(Ak)
+            for l in Ainz - Aknz:
+                Ak[l] = - Akj * Ai[l]
+                nonzero_columns[l].add(k)
+            Ak.pop(j)
+            Aknz.remove(j)
+            for l in Ainz & Aknz:
+                Akl = Ak[l] - Akj * Ai[l]
+                if Akl:
+                    Ak[l] = Akl
+                else:
+                    # Drop nonzero elements
+                    Ak.pop(l)
+                    if l != j:
+                        nonzero_columns[l].remove(k)
+            if len(Ak) == 1:
+                reduced_pivots.add(k)
+                nonreduced_pivots.remove(k)
+
+        if len(Ai) == 1:
+            reduced_pivots.add(j)
+        else:
+            nonreduced_pivots.add(j)
+            for l in Ai:
+                if l != j:
+                    nonzero_columns[l].add(j)
+
+    # All done!
+    pivots = sorted(reduced_pivots | nonreduced_pivots)
+    pivot2row = {p: n for n, p in enumerate(pivots)}
+    nonzero_columns = {c: {pivot2row[p] for p in s} for c, s in nonzero_columns.items()}
+    rows = [pivot_row_map[i] for i in pivots]
+    rref = dict(enumerate(rows))
+    return rref, pivots, nonzero_columns
+
+
+def sdm_rref_den(A, K):
+    """
+    Return the reduced row echelon form (RREF) of A with denominator.
+
+    The RREF is computed using fraction-free Gauss-Jordan elimination.
+
+    Explanation
+    ===========
+
+    The algorithm used is the fraction-free version of Gauss-Jordan elimination
+    described as FFGJ in [1]_. Here it is modified to handle zero or missing
+    pivots and to avoid redundant arithmetic. This implementation is also
+    optimized for sparse matrices.
+
+    The domain $K$ must support exact division (``K.exquo``) but does not need
+    to be a field. This method is suitable for most exact rings and fields like
+    :ref:`ZZ`, :ref:`QQ` and :ref:`QQ(a)`. In the case of :ref:`QQ` or
+    :ref:`K(x)` it might be more efficient to clear denominators and use
+    :ref:`ZZ` or :ref:`K[x]` instead.
+
+    For inexact domains like :ref:`RR` and :ref:`CC` use ``ddm_irref`` instead.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.matrices.sdm import sdm_rref_den
+    >>> from sympy.polys.domains import ZZ
+    >>> A = {0: {0: ZZ(1), 1: ZZ(2)}, 1: {0: ZZ(3), 1: ZZ(4)}}
+    >>> A_rref, den, pivots = sdm_rref_den(A, ZZ)
+    >>> A_rref
+    {0: {0: -2}, 1: {1: -2}}
+    >>> den
+    -2
+    >>> pivots
+    [0, 1]
+
+    See Also
+    ========
+
+    sympy.polys.matrices.domainmatrix.DomainMatrix.rref_den
+        Higher-level interface to ``sdm_rref_den`` that would usually be used
+        instead of calling this function directly.
+    sympy.polys.matrices.sdm.sdm_rref_den
+        The ``SDM`` method that uses this function.
+    sdm_irref
+        Computes RREF using field division.
+    ddm_irref_den
+        The dense version of this algorithm.
+
+    References
+    ==========
+
+    .. [1] Fraction-free algorithms for linear and polynomial equations.
+        George C. Nakos , Peter R. Turner , Robert M. Williams.
+        https://dl.acm.org/doi/10.1145/271130.271133
+    """
+    #
+    # We represent each row of the matrix as a dict mapping column indices to
+    # nonzero elements. We will build the RREF matrix starting from an empty
+    # matrix and appending one row at a time. At each step we will have the
+    # RREF of the rows we have processed so far.
+    #
+    # Our representation of the RREF divides it into three parts:
+    #
+    # 1. Fully reduced rows having only a single nonzero element (the pivot).
+    # 2. Partially reduced rows having nonzeros after the pivot.
+    # 3. The current denominator and divisor.
+    #
+    # For example if the incremental RREF might be:
+    #
+    #   [2, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+    #   [0, 0, 2, 0, 0, 0, 7, 0, 0, 0]
+    #   [0, 0, 0, 0, 0, 2, 0, 0, 0, 0]
+    #   [0, 0, 0, 0, 0, 0, 0, 2, 0, 0]
+    #   [0, 0, 0, 0, 0, 0, 0, 0, 2, 0]
+    #
+    # Here the second row is partially reduced and the other rows are fully
+    # reduced. The denominator would be 2 in this case. We distinguish the
+    # fully reduced rows because we can handle them more efficiently when
+    # adding a new row.
+    #
+    # When adding a new row we need to multiply it by the current denominator.
+    # Then we reduce the new row by cross cancellation with the previous rows.
+    # Then if it is not reduced to zero we take its leading entry as the new
+    # pivot, cross cancel the new row from the previous rows and update the
+    # denominator. In the fraction-free version this last step requires
+    # multiplying and dividing the whole matrix by the new pivot and the
+    # current divisor. The advantage of building the RREF one row at a time is
+    # that in the sparse case we only need to work with the relatively sparse
+    # upper rows of the matrix. The simple version of FFGJ in [1] would
+    # multiply and divide all the dense lower rows at each step.
+
+    # Handle the trivial cases.
+    if not A:
+        return ({}, K.one, [])
+    elif len(A) == 1:
+        Ai, = A.values()
+        j = min(Ai)
+        Aij = Ai[j]
+        return ({0: Ai.copy()}, Aij, [j])
+
+    # For inexact domains like RR[x] we use quo and discard the remainder.
+    # Maybe it would be better for K.exquo to do this automatically.
+    if K.is_Exact:
+        exquo = K.exquo
+    else:
+        exquo = K.quo
+
+    # Make sure we have the rows in order to make this deterministic from the
+    # outset.
+    _, rows_in_order = zip(*sorted(A.items()))
+
+    col_to_row_reduced = {}
+    col_to_row_unreduced = {}
+    reduced = col_to_row_reduced.keys()
+    unreduced = col_to_row_unreduced.keys()
+
+    # Our representation of the RREF so far.
+    A_rref_rows = []
+    denom = None
+    divisor = None
+
+    # The rows that remain to be added to the RREF. These are sorted by the
+    # column index of their leading entry. Note that sorted() is stable so the
+    # previous sort by unique row index is still needed to make this
+    # deterministic (there may be multiple rows with the same leading column).
+    A_rows = sorted(rows_in_order, key=min)
+
+    for Ai in A_rows:
+
+        # All fully reduced columns can be immediately discarded.
+        Ai = {j: Aij for j, Aij in Ai.items() if j not in reduced}
+
+        # We need to multiply the new row by the current denominator to bring
+        # it into the same scale as the previous rows and then cross-cancel to
+        # reduce it wrt the previous unreduced rows. All pivots in the previous
+        # rows are equal to denom so the coefficients we need to make a linear
+        # combination of the previous rows to cancel into the new row are just
+        # the ones that are already in the new row *before* we multiply by
+        # denom. We compute that linear combination first and then multiply the
+        # new row by denom before subtraction.
+        Ai_cancel = {}
+
+        for j in unreduced & Ai.keys():
+            # Remove the pivot column from the new row since it would become
+            # zero anyway.
+            Aij = Ai.pop(j)
+
+            Aj = A_rref_rows[col_to_row_unreduced[j]]
+
+            for k, Ajk in Aj.items():
+                Aik_cancel = Ai_cancel.get(k)
+                if Aik_cancel is None:
+                    Ai_cancel[k] = Aij * Ajk
+                else:
+                    Aik_cancel = Aik_cancel + Aij * Ajk
+                    if Aik_cancel:
+                        Ai_cancel[k] = Aik_cancel
+                    else:
+                        Ai_cancel.pop(k)
+
+        # Multiply the new row by the current denominator and subtract.
+        Ai_nz = set(Ai)
+        Ai_cancel_nz = set(Ai_cancel)
+
+        d = denom or K.one
+
+        for k in Ai_cancel_nz - Ai_nz:
+            Ai[k] = -Ai_cancel[k]
+
+        for k in Ai_nz - Ai_cancel_nz:
+            Ai[k] = Ai[k] * d
+
+        for k in Ai_cancel_nz & Ai_nz:
+            Aik = Ai[k] * d - Ai_cancel[k]
+            if Aik:
+                Ai[k] = Aik
+            else:
+                Ai.pop(k)
+
+        # Now Ai has the same scale as the other rows and is reduced wrt the
+        # unreduced rows.
+
+        # If the row is reduced to zero then discard it.
+        if not Ai:
+            continue
+
+        # Choose a pivot for this row.
+        j = min(Ai)
+        Aij = Ai.pop(j)
+
+        # Cross cancel the unreduced rows by the new row.
+        #     a[k][l] = (a[i][j]*a[k][l] - a[k][j]*a[i][l]) / divisor
+        for pk, k in list(col_to_row_unreduced.items()):
+
+            Ak = A_rref_rows[k]
+
+            if j not in Ak:
+                # This row is already reduced wrt the new row but we need to
+                # bring it to the same scale as the new denominator. This step
+                # is not needed in sdm_irref.
+                for l, Akl in Ak.items():
+                    Akl = Akl * Aij
+                    if divisor is not None:
+                        Akl = exquo(Akl, divisor)
+                    Ak[l] = Akl
+                continue
+
+            Akj = Ak.pop(j)
+            Ai_nz = set(Ai)
+            Ak_nz = set(Ak)
+
+            for l in Ai_nz - Ak_nz:
+                Ak[l] = - Akj * Ai[l]
+                if divisor is not None:
+                    Ak[l] = exquo(Ak[l], divisor)
+
+            # This loop also not needed in sdm_irref.
+            for l in Ak_nz - Ai_nz:
+                Ak[l] = Aij * Ak[l]
+                if divisor is not None:
+                    Ak[l] = exquo(Ak[l], divisor)
+
+            for l in Ai_nz & Ak_nz:
+                Akl = Aij * Ak[l] - Akj * Ai[l]
+                if Akl:
+                    if divisor is not None:
+                        Akl = exquo(Akl, divisor)
+                    Ak[l] = Akl
+                else:
+                    Ak.pop(l)
+
+            if not Ak:
+                col_to_row_unreduced.pop(pk)
+                col_to_row_reduced[pk] = k
+
+        i = len(A_rref_rows)
+        A_rref_rows.append(Ai)
+        if Ai:
+            col_to_row_unreduced[j] = i
+        else:
+            col_to_row_reduced[j] = i
+
+        # Update the denominator.
+        if not K.is_one(Aij):
+            if denom is None:
+                denom = Aij
+            else:
+                denom *= Aij
+
+        if divisor is not None:
+            denom = exquo(denom, divisor)
+
+        # Update the divisor.
+        divisor = denom
+
+    if denom is None:
+        denom = K.one
+
+    # Sort the rows by their leading column index.
+    col_to_row = {**col_to_row_reduced, **col_to_row_unreduced}
+    row_to_col = {i: j for j, i in col_to_row.items()}
+    A_rref_rows_col = [(row_to_col[i], Ai) for i, Ai in enumerate(A_rref_rows)]
+    pivots, A_rref = zip(*sorted(A_rref_rows_col))
+    pivots = list(pivots)
+
+    # Insert the pivot values
+    for i, Ai in enumerate(A_rref):
+        Ai[pivots[i]] = denom
+
+    A_rref_sdm = dict(enumerate(A_rref))
+
+    return A_rref_sdm, denom, pivots
+
+
+def sdm_nullspace_from_rref(A, one, ncols, pivots, nonzero_cols):
+    """Get nullspace from A which is in RREF"""
+    nonpivots = sorted(set(range(ncols)) - set(pivots))
+
+    K = []
+    for j in nonpivots:
+        Kj = {j:one}
+        for i in nonzero_cols.get(j, ()):
+            Kj[pivots[i]] = -A[i][j]
+        K.append(Kj)
+
+    return K, nonpivots
+
+
+def sdm_particular_from_rref(A, ncols, pivots):
+    """Get a particular solution from A which is in RREF"""
+    P = {}
+    for i, j in enumerate(pivots):
+        Ain = A[i].get(ncols-1, None)
+        if Ain is not None:
+            P[j] = Ain / A[i][j]
+    return P
+
+
+def sdm_berk(M, n, K):
+    """
+    Berkowitz algorithm for computing the characteristic polynomial.
+
+    Explanation
+    ===========
+
+    The Berkowitz algorithm is a division-free algorithm for computing the
+    characteristic polynomial of a matrix over any commutative ring using only
+    arithmetic in the coefficient ring. This implementation is for sparse
+    matrices represented in a dict-of-dicts format (like :class:`SDM`).
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> from sympy.polys.matrices.sdm import sdm_berk
+    >>> from sympy.polys.domains import ZZ
+    >>> M = {0: {0: ZZ(1), 1:ZZ(2)}, 1: {0:ZZ(3), 1:ZZ(4)}}
+    >>> sdm_berk(M, 2, ZZ)
+    {0: 1, 1: -5, 2: -2}
+    >>> Matrix([[1, 2], [3, 4]]).charpoly()
+    PurePoly(lambda**2 - 5*lambda - 2, lambda, domain='ZZ')
+
+    See Also
+    ========
+
+    sympy.polys.matrices.domainmatrix.DomainMatrix.charpoly
+        The high-level interface to this function.
+    sympy.polys.matrices.dense.ddm_berk
+        The dense version of this function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Samuelson%E2%80%93Berkowitz_algorithm
+    """
+    zero = K.zero
+    one = K.one
+
+    if n == 0:
+        return {0: one}
+    elif n == 1:
+        pdict = {0: one}
+        if M00 := M.get(0, {}).get(0, zero):
+            pdict[1] = -M00
+
+    # M = [[a, R],
+    #      [C, A]]
+    a, R, C, A = K.zero, {}, {}, defaultdict(dict)
+    for i, Mi in M.items():
+        for j, Mij in Mi.items():
+            if i and j:
+                A[i-1][j-1] = Mij
+            elif i:
+                C[i-1] = Mij
+            elif j:
+                R[j-1] = Mij
+            else:
+                a = Mij
+
+    # T = [       1,      0,    0,  0, 0, ... ]
+    #     [      -a,      1,    0,  0, 0, ... ]
+    #     [    -R*C,     -a,    1,  0, 0, ... ]
+    #     [  -R*A*C,   -R*C,   -a,  1, 0, ... ]
+    #     [-R*A^2*C, -R*A*C, -R*C, -a, 1, ... ]
+    #     [ ...                               ]
+    # T is (n+1) x n
+    #
+    # In the sparse case we might have A^m*C = 0 for some m making T banded
+    # rather than triangular so we just compute the nonzero entries of the
+    # first column rather than constructing the matrix explicitly.
+
+    AnC = C
+    RC = sdm_dotvec(R, C, K)
+
+    Tvals = [one, -a, -RC]
+    for i in range(3, n+1):
+        AnC = sdm_matvecmul(A, AnC, K)
+        if not AnC:
+            break
+        RAnC = sdm_dotvec(R, AnC, K)
+        Tvals.append(-RAnC)
+
+    # Strip trailing zeros
+    while Tvals and not Tvals[-1]:
+        Tvals.pop()
+
+    q = sdm_berk(A, n-1, K)
+
+    # This would be the explicit multiplication T*q but we can do better:
+    #
+    #  T = {}
+    #  for i in range(n+1):
+    #      Ti = {}
+    #      for j in range(max(0, i-len(Tvals)+1), min(i+1, n)):
+    #          Ti[j] = Tvals[i-j]
+    #      T[i] = Ti
+    #  Tq = sdm_matvecmul(T, q, K)
+    #
+    # In the sparse case q might be mostly zero. We know that T[i,j] is nonzero
+    # for i <= j < i + len(Tvals) so if q does not have a nonzero entry in that
+    # range then Tq[j] must be zero. We exploit this potential banded
+    # structure and the potential sparsity of q to compute Tq more efficiently.
+
+    Tvals = Tvals[::-1]
+
+    Tq = {}
+
+    for i in range(min(q), min(max(q)+len(Tvals), n+1)):
+        Ti = dict(enumerate(Tvals, i-len(Tvals)+1))
+        if Tqi := sdm_dotvec(Ti, q, K):
+            Tq[i] = Tqi
+
+    return Tq
diff --git a/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/modulargcd.py b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/modulargcd.py
new file mode 100644
index 0000000000000000000000000000000000000000..20dfd33d919703873e9fb5d3039abb351297df61
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/modulargcd.py
@@ -0,0 +1,2277 @@
+from sympy.core.symbol import Dummy
+from sympy.ntheory import nextprime
+from sympy.ntheory.modular import crt
+from sympy.polys.domains import PolynomialRing
+from sympy.polys.galoistools import (
+    gf_gcd, gf_from_dict, gf_gcdex, gf_div, gf_lcm)
+from sympy.polys.polyerrors import ModularGCDFailed
+
+from mpmath import sqrt
+import random
+
+
+def _trivial_gcd(f, g):
+    """
+    Compute the GCD of two polynomials in trivial cases, i.e. when one
+    or both polynomials are zero.
+    """
+    ring = f.ring
+
+    if not (f or g):
+        return ring.zero, ring.zero, ring.zero
+    elif not f:
+        if g.LC < ring.domain.zero:
+            return -g, ring.zero, -ring.one
+        else:
+            return g, ring.zero, ring.one
+    elif not g:
+        if f.LC < ring.domain.zero:
+            return -f, -ring.one, ring.zero
+        else:
+            return f, ring.one, ring.zero
+    return None
+
+
+def _gf_gcd(fp, gp, p):
+    r"""
+    Compute the GCD of two univariate polynomials in `\mathbb{Z}_p[x]`.
+    """
+    dom = fp.ring.domain
+
+    while gp:
+        rem = fp
+        deg = gp.degree()
+        lcinv = dom.invert(gp.LC, p)
+
+        while True:
+            degrem = rem.degree()
+            if degrem < deg:
+                break
+            rem = (rem - gp.mul_monom((degrem - deg,)).mul_ground(lcinv * rem.LC)).trunc_ground(p)
+
+        fp = gp
+        gp = rem
+
+    return fp.mul_ground(dom.invert(fp.LC, p)).trunc_ground(p)
+
+
+def _degree_bound_univariate(f, g):
+    r"""
+    Compute an upper bound for the degree of the GCD of two univariate
+    integer polynomials `f` and `g`.
+
+    The function chooses a suitable prime `p` and computes the GCD of
+    `f` and `g` in `\mathbb{Z}_p[x]`. The choice of `p` guarantees that
+    the degree in `\mathbb{Z}_p[x]` is greater than or equal to the degree
+    in `\mathbb{Z}[x]`.
+
+    Parameters
+    ==========
+
+    f : PolyElement
+        univariate integer polynomial
+    g : PolyElement
+        univariate integer polynomial
+
+    """
+    gamma = f.ring.domain.gcd(f.LC, g.LC)
+    p = 1
+
+    p = nextprime(p)
+    while gamma % p == 0:
+        p = nextprime(p)
+
+    fp = f.trunc_ground(p)
+    gp = g.trunc_ground(p)
+    hp = _gf_gcd(fp, gp, p)
+    deghp = hp.degree()
+    return deghp
+
+
+def _chinese_remainder_reconstruction_univariate(hp, hq, p, q):
+    r"""
+    Construct a polynomial `h_{pq}` in `\mathbb{Z}_{p q}[x]` such that
+
+    .. math ::
+
+        h_{pq} = h_p \; \mathrm{mod} \, p
+
+        h_{pq} = h_q \; \mathrm{mod} \, q
+
+    for relatively prime integers `p` and `q` and polynomials
+    `h_p` and `h_q` in `\mathbb{Z}_p[x]` and `\mathbb{Z}_q[x]`
+    respectively.
+
+    The coefficients of the polynomial `h_{pq}` are computed with the
+    Chinese Remainder Theorem. The symmetric representation in
+    `\mathbb{Z}_p[x]`, `\mathbb{Z}_q[x]` and `\mathbb{Z}_{p q}[x]` is used.
+    It is assumed that `h_p` and `h_q` have the same degree.
+
+    Parameters
+    ==========
+
+    hp : PolyElement
+        univariate integer polynomial with coefficients in `\mathbb{Z}_p`
+    hq : PolyElement
+        univariate integer polynomial with coefficients in `\mathbb{Z}_q`
+    p : Integer
+        modulus of `h_p`, relatively prime to `q`
+    q : Integer
+        modulus of `h_q`, relatively prime to `p`
+
+    Examples
+    ========
+
+    >>> from sympy.polys.modulargcd import _chinese_remainder_reconstruction_univariate
+    >>> from sympy.polys import ring, ZZ
+
+    >>> R, x = ring("x", ZZ)
+    >>> p = 3
+    >>> q = 5
+
+    >>> hp = -x**3 - 1
+    >>> hq = 2*x**3 - 2*x**2 + x
+
+    >>> hpq = _chinese_remainder_reconstruction_univariate(hp, hq, p, q)
+    >>> hpq
+    2*x**3 + 3*x**2 + 6*x + 5
+
+    >>> hpq.trunc_ground(p) == hp
+    True
+    >>> hpq.trunc_ground(q) == hq
+    True
+
+    """
+    n = hp.degree()
+    x = hp.ring.gens[0]
+    hpq = hp.ring.zero
+
+    for i in range(n+1):
+        hpq[(i,)] = crt([p, q], [hp.coeff(x**i), hq.coeff(x**i)], symmetric=True)[0]
+
+    hpq.strip_zero()
+    return hpq
+
+
+def modgcd_univariate(f, g):
+    r"""
+    Computes the GCD of two polynomials in `\mathbb{Z}[x]` using a modular
+    algorithm.
+
+    The algorithm computes the GCD of two univariate integer polynomials
+    `f` and `g` by computing the GCD in `\mathbb{Z}_p[x]` for suitable
+    primes `p` and then reconstructing the coefficients with the Chinese
+    Remainder Theorem. Trial division is only made for candidates which
+    are very likely the desired GCD.
+
+    Parameters
+    ==========
+
+    f : PolyElement
+        univariate integer polynomial
+    g : PolyElement
+        univariate integer polynomial
+
+    Returns
+    =======
+
+    h : PolyElement
+        GCD of the polynomials `f` and `g`
+    cff : PolyElement
+        cofactor of `f`, i.e. `\frac{f}{h}`
+    cfg : PolyElement
+        cofactor of `g`, i.e. `\frac{g}{h}`
+
+    Examples
+    ========
+
+    >>> from sympy.polys.modulargcd import modgcd_univariate
+    >>> from sympy.polys import ring, ZZ
+
+    >>> R, x = ring("x", ZZ)
+
+    >>> f = x**5 - 1
+    >>> g = x - 1
+
+    >>> h, cff, cfg = modgcd_univariate(f, g)
+    >>> h, cff, cfg
+    (x - 1, x**4 + x**3 + x**2 + x + 1, 1)
+
+    >>> cff * h == f
+    True
+    >>> cfg * h == g
+    True
+
+    >>> f = 6*x**2 - 6
+    >>> g = 2*x**2 + 4*x + 2
+
+    >>> h, cff, cfg = modgcd_univariate(f, g)
+    >>> h, cff, cfg
+    (2*x + 2, 3*x - 3, x + 1)
+
+    >>> cff * h == f
+    True
+    >>> cfg * h == g
+    True
+
+    References
+    ==========
+
+    1. [Monagan00]_
+
+    """
+    assert f.ring == g.ring and f.ring.domain.is_ZZ
+
+    result = _trivial_gcd(f, g)
+    if result is not None:
+        return result
+
+    ring = f.ring
+
+    cf, f = f.primitive()
+    cg, g = g.primitive()
+    ch = ring.domain.gcd(cf, cg)
+
+    bound = _degree_bound_univariate(f, g)
+    if bound == 0:
+        return ring(ch), f.mul_ground(cf // ch), g.mul_ground(cg // ch)
+
+    gamma = ring.domain.gcd(f.LC, g.LC)
+    m = 1
+    p = 1
+
+    while True:
+        p = nextprime(p)
+        while gamma % p == 0:
+            p = nextprime(p)
+
+        fp = f.trunc_ground(p)
+        gp = g.trunc_ground(p)
+        hp = _gf_gcd(fp, gp, p)
+        deghp = hp.degree()
+
+        if deghp > bound:
+            continue
+        elif deghp < bound:
+            m = 1
+            bound = deghp
+            continue
+
+        hp = hp.mul_ground(gamma).trunc_ground(p)
+        if m == 1:
+            m = p
+            hlastm = hp
+            continue
+
+        hm = _chinese_remainder_reconstruction_univariate(hp, hlastm, p, m)
+        m *= p
+
+        if not hm == hlastm:
+            hlastm = hm
+            continue
+
+        h = hm.quo_ground(hm.content())
+        fquo, frem = f.div(h)
+        gquo, grem = g.div(h)
+        if not frem and not grem:
+            if h.LC < 0:
+                ch = -ch
+            h = h.mul_ground(ch)
+            cff = fquo.mul_ground(cf // ch)
+            cfg = gquo.mul_ground(cg // ch)
+            return h, cff, cfg
+
+
+def _primitive(f, p):
+    r"""
+    Compute the content and the primitive part of a polynomial in
+    `\mathbb{Z}_p[x_0, \ldots, x_{k-2}, y] \cong \mathbb{Z}_p[y][x_0, \ldots, x_{k-2}]`.
+
+    Parameters
+    ==========
+
+    f : PolyElement
+        integer polynomial in `\mathbb{Z}_p[x0, \ldots, x{k-2}, y]`
+    p : Integer
+        modulus of `f`
+
+    Returns
+    =======
+
+    contf : PolyElement
+        integer polynomial in `\mathbb{Z}_p[y]`, content of `f`
+    ppf : PolyElement
+        primitive part of `f`, i.e. `\frac{f}{contf}`
+
+    Examples
+    ========
+
+    >>> from sympy.polys.modulargcd import _primitive
+    >>> from sympy.polys import ring, ZZ
+
+    >>> R, x, y = ring("x, y", ZZ)
+    >>> p = 3
+
+    >>> f = x**2*y**2 + x**2*y - y**2 - y
+    >>> _primitive(f, p)
+    (y**2 + y, x**2 - 1)
+
+    >>> R, x, y, z = ring("x, y, z", ZZ)
+
+    >>> f = x*y*z - y**2*z**2
+    >>> _primitive(f, p)
+    (z, x*y - y**2*z)
+
+    """
+    ring = f.ring
+    dom = ring.domain
+    k = ring.ngens
+
+    coeffs = {}
+    for monom, coeff in f.iterterms():
+        if monom[:-1] not in coeffs:
+            coeffs[monom[:-1]] = {}
+        coeffs[monom[:-1]][monom[-1]] = coeff
+
+    cont = []
+    for coeff in iter(coeffs.values()):
+        cont = gf_gcd(cont, gf_from_dict(coeff, p, dom), p, dom)
+
+    yring = ring.clone(symbols=ring.symbols[k-1])
+    contf = yring.from_dense(cont).trunc_ground(p)
+
+    return contf, f.quo(contf.set_ring(ring))
+
+
+def _deg(f):
+    r"""
+    Compute the degree of a multivariate polynomial
+    `f \in K[x_0, \ldots, x_{k-2}, y] \cong K[y][x_0, \ldots, x_{k-2}]`.
+
+    Parameters
+    ==========
+
+    f : PolyElement
+        polynomial in `K[x_0, \ldots, x_{k-2}, y]`
+
+    Returns
+    =======
+
+    degf : Integer tuple
+        degree of `f` in `x_0, \ldots, x_{k-2}`
+
+    Examples
+    ========
+
+    >>> from sympy.polys.modulargcd import _deg
+    >>> from sympy.polys import ring, ZZ
+
+    >>> R, x, y = ring("x, y", ZZ)
+
+    >>> f = x**2*y**2 + x**2*y - 1
+    >>> _deg(f)
+    (2,)
+
+    >>> R, x, y, z = ring("x, y, z", ZZ)
+
+    >>> f = x**2*y**2 + x**2*y - 1
+    >>> _deg(f)
+    (2, 2)
+
+    >>> f = x*y*z - y**2*z**2
+    >>> _deg(f)
+    (1, 1)
+
+    """
+    k = f.ring.ngens
+    degf = (0,) * (k-1)
+    for monom in f.itermonoms():
+        if monom[:-1] > degf:
+            degf = monom[:-1]
+    return degf
+
+
+def _LC(f):
+    r"""
+    Compute the leading coefficient of a multivariate polynomial
+    `f \in K[x_0, \ldots, x_{k-2}, y] \cong K[y][x_0, \ldots, x_{k-2}]`.
+
+    Parameters
+    ==========
+
+    f : PolyElement
+        polynomial in `K[x_0, \ldots, x_{k-2}, y]`
+
+    Returns
+    =======
+
+    lcf : PolyElement
+        polynomial in `K[y]`, leading coefficient of `f`
+
+    Examples
+    ========
+
+    >>> from sympy.polys.modulargcd import _LC
+    >>> from sympy.polys import ring, ZZ
+
+    >>> R, x, y = ring("x, y", ZZ)
+
+    >>> f = x**2*y**2 + x**2*y - 1
+    >>> _LC(f)
+    y**2 + y
+
+    >>> R, x, y, z = ring("x, y, z", ZZ)
+
+    >>> f = x**2*y**2 + x**2*y - 1
+    >>> _LC(f)
+    1
+
+    >>> f = x*y*z - y**2*z**2
+    >>> _LC(f)
+    z
+
+    """
+    ring = f.ring
+    k = ring.ngens
+    yring = ring.clone(symbols=ring.symbols[k-1])
+    y = yring.gens[0]
+    degf = _deg(f)
+
+    lcf = yring.zero
+    for monom, coeff in f.iterterms():
+        if monom[:-1] == degf:
+            lcf += coeff*y**monom[-1]
+    return lcf
+
+
+def _swap(f, i):
+    """
+    Make the variable `x_i` the leading one in a multivariate polynomial `f`.
+    """
+    ring = f.ring
+    fswap = ring.zero
+    for monom, coeff in f.iterterms():
+        monomswap = (monom[i],) + monom[:i] + monom[i+1:]
+        fswap[monomswap] = coeff
+    return fswap
+
+
+def _degree_bound_bivariate(f, g):
+    r"""
+    Compute upper degree bounds for the GCD of two bivariate
+    integer polynomials `f` and `g`.
+
+    The GCD is viewed as a polynomial in `\mathbb{Z}[y][x]` and the
+    function returns an upper bound for its degree and one for the degree
+    of its content. This is done by choosing a suitable prime `p` and
+    computing the GCD of the contents of `f \; \mathrm{mod} \, p` and
+    `g \; \mathrm{mod} \, p`. The choice of `p` guarantees that the degree
+    of the content in `\mathbb{Z}_p[y]` is greater than or equal to the
+    degree in `\mathbb{Z}[y]`. To obtain the degree bound in the variable
+    `x`, the polynomials are evaluated at `y = a` for a suitable
+    `a \in \mathbb{Z}_p` and then their GCD in `\mathbb{Z}_p[x]` is
+    computed. If no such `a` exists, i.e. the degree in `\mathbb{Z}_p[x]`
+    is always smaller than the one in `\mathbb{Z}[y][x]`, then the bound is
+    set to the minimum of the degrees of `f` and `g` in `x`.
+
+    Parameters
+    ==========
+
+    f : PolyElement
+        bivariate integer polynomial
+    g : PolyElement
+        bivariate integer polynomial
+
+    Returns
+    =======
+
+    xbound : Integer
+        upper bound for the degree of the GCD of the polynomials `f` and
+        `g` in the variable `x`
+    ycontbound : Integer
+        upper bound for the degree of the content of the GCD of the
+        polynomials `f` and `g` in the variable `y`
+
+    References
+    ==========
+
+    1. [Monagan00]_
+
+    """
+    ring = f.ring
+
+    gamma1 = ring.domain.gcd(f.LC, g.LC)
+    gamma2 = ring.domain.gcd(_swap(f, 1).LC, _swap(g, 1).LC)
+    badprimes = gamma1 * gamma2
+    p = 1
+
+    p = nextprime(p)
+    while badprimes % p == 0:
+        p = nextprime(p)
+
+    fp = f.trunc_ground(p)
+    gp = g.trunc_ground(p)
+    contfp, fp = _primitive(fp, p)
+    contgp, gp = _primitive(gp, p)
+    conthp = _gf_gcd(contfp, contgp, p) # polynomial in Z_p[y]
+    ycontbound = conthp.degree()
+
+    # polynomial in Z_p[y]
+    delta = _gf_gcd(_LC(fp), _LC(gp), p)
+
+    for a in range(p):
+        if not delta.evaluate(0, a) % p:
+            continue
+        fpa = fp.evaluate(1, a).trunc_ground(p)
+        gpa = gp.evaluate(1, a).trunc_ground(p)
+        hpa = _gf_gcd(fpa, gpa, p)
+        xbound = hpa.degree()
+        return xbound, ycontbound
+
+    return min(fp.degree(), gp.degree()), ycontbound
+
+
+def _chinese_remainder_reconstruction_multivariate(hp, hq, p, q):
+    r"""
+    Construct a polynomial `h_{pq}` in
+    `\mathbb{Z}_{p q}[x_0, \ldots, x_{k-1}]` such that
+
+    .. math ::
+
+        h_{pq} = h_p \; \mathrm{mod} \, p
+
+        h_{pq} = h_q \; \mathrm{mod} \, q
+
+    for relatively prime integers `p` and `q` and polynomials
+    `h_p` and `h_q` in `\mathbb{Z}_p[x_0, \ldots, x_{k-1}]` and
+    `\mathbb{Z}_q[x_0, \ldots, x_{k-1}]` respectively.
+
+    The coefficients of the polynomial `h_{pq}` are computed with the
+    Chinese Remainder Theorem. The symmetric representation in
+    `\mathbb{Z}_p[x_0, \ldots, x_{k-1}]`,
+    `\mathbb{Z}_q[x_0, \ldots, x_{k-1}]` and
+    `\mathbb{Z}_{p q}[x_0, \ldots, x_{k-1}]` is used.
+
+    Parameters
+    ==========
+
+    hp : PolyElement
+        multivariate integer polynomial with coefficients in `\mathbb{Z}_p`
+    hq : PolyElement
+        multivariate integer polynomial with coefficients in `\mathbb{Z}_q`
+    p : Integer
+        modulus of `h_p`, relatively prime to `q`
+    q : Integer
+        modulus of `h_q`, relatively prime to `p`
+
+    Examples
+    ========
+
+    >>> from sympy.polys.modulargcd import _chinese_remainder_reconstruction_multivariate
+    >>> from sympy.polys import ring, ZZ
+
+    >>> R, x, y = ring("x, y", ZZ)
+    >>> p = 3
+    >>> q = 5
+
+    >>> hp = x**3*y - x**2 - 1
+    >>> hq = -x**3*y - 2*x*y**2 + 2
+
+    >>> hpq = _chinese_remainder_reconstruction_multivariate(hp, hq, p, q)
+    >>> hpq
+    4*x**3*y + 5*x**2 + 3*x*y**2 + 2
+
+    >>> hpq.trunc_ground(p) == hp
+    True
+    >>> hpq.trunc_ground(q) == hq
+    True
+
+    >>> R, x, y, z = ring("x, y, z", ZZ)
+    >>> p = 6
+    >>> q = 5
+
+    >>> hp = 3*x**4 - y**3*z + z
+    >>> hq = -2*x**4 + z
+
+    >>> hpq = _chinese_remainder_reconstruction_multivariate(hp, hq, p, q)
+    >>> hpq
+    3*x**4 + 5*y**3*z + z
+
+    >>> hpq.trunc_ground(p) == hp
+    True
+    >>> hpq.trunc_ground(q) == hq
+    True
+
+    """
+    hpmonoms = set(hp.monoms())
+    hqmonoms = set(hq.monoms())
+    monoms = hpmonoms.intersection(hqmonoms)
+    hpmonoms.difference_update(monoms)
+    hqmonoms.difference_update(monoms)
+
+    zero = hp.ring.domain.zero
+
+    hpq = hp.ring.zero
+
+    if isinstance(hp.ring.domain, PolynomialRing):
+        crt_ = _chinese_remainder_reconstruction_multivariate
+    else:
+        def crt_(cp, cq, p, q):
+            return crt([p, q], [cp, cq], symmetric=True)[0]
+
+    for monom in monoms:
+        hpq[monom] = crt_(hp[monom], hq[monom], p, q)
+    for monom in hpmonoms:
+        hpq[monom] = crt_(hp[monom], zero, p, q)
+    for monom in hqmonoms:
+        hpq[monom] = crt_(zero, hq[monom], p, q)
+
+    return hpq
+
+
+def _interpolate_multivariate(evalpoints, hpeval, ring, i, p, ground=False):
+    r"""
+    Reconstruct a polynomial `h_p` in `\mathbb{Z}_p[x_0, \ldots, x_{k-1}]`
+    from a list of evaluation points in `\mathbb{Z}_p` and a list of
+    polynomials in
+    `\mathbb{Z}_p[x_0, \ldots, x_{i-1}, x_{i+1}, \ldots, x_{k-1}]`, which
+    are the images of `h_p` evaluated in the variable `x_i`.
+
+    It is also possible to reconstruct a parameter of the ground domain,
+    i.e. if `h_p` is a polynomial over `\mathbb{Z}_p[x_0, \ldots, x_{k-1}]`.
+    In this case, one has to set ``ground=True``.
+
+    Parameters
+    ==========
+
+    evalpoints : list of Integer objects
+        list of evaluation points in `\mathbb{Z}_p`
+    hpeval : list of PolyElement objects
+        list of polynomials in (resp. over)
+        `\mathbb{Z}_p[x_0, \ldots, x_{i-1}, x_{i+1}, \ldots, x_{k-1}]`,
+        images of `h_p` evaluated in the variable `x_i`
+    ring : PolyRing
+        `h_p` will be an element of this ring
+    i : Integer
+        index of the variable which has to be reconstructed
+    p : Integer
+        prime number, modulus of `h_p`
+    ground : Boolean
+        indicates whether `x_i` is in the ground domain, default is
+        ``False``
+
+    Returns
+    =======
+
+    hp : PolyElement
+        interpolated polynomial in (resp. over)
+        `\mathbb{Z}_p[x_0, \ldots, x_{k-1}]`
+
+    """
+    hp = ring.zero
+
+    if ground:
+        domain = ring.domain.domain
+        y = ring.domain.gens[i]
+    else:
+        domain = ring.domain
+        y = ring.gens[i]
+
+    for a, hpa in zip(evalpoints, hpeval):
+        numer = ring.one
+        denom = domain.one
+        for b in evalpoints:
+            if b == a:
+                continue
+
+            numer *= y - b
+            denom *= a - b
+
+        denom = domain.invert(denom, p)
+        coeff = numer.mul_ground(denom)
+        hp += hpa.set_ring(ring) * coeff
+
+    return hp.trunc_ground(p)
+
+
+def modgcd_bivariate(f, g):
+    r"""
+    Computes the GCD of two polynomials in `\mathbb{Z}[x, y]` using a
+    modular algorithm.
+
+    The algorithm computes the GCD of two bivariate integer polynomials
+    `f` and `g` by calculating the GCD in `\mathbb{Z}_p[x, y]` for
+    suitable primes `p` and then reconstructing the coefficients with the
+    Chinese Remainder Theorem. To compute the bivariate GCD over
+    `\mathbb{Z}_p`, the polynomials `f \; \mathrm{mod} \, p` and
+    `g \; \mathrm{mod} \, p` are evaluated at `y = a` for certain
+    `a \in \mathbb{Z}_p` and then their univariate GCD in `\mathbb{Z}_p[x]`
+    is computed. Interpolating those yields the bivariate GCD in
+    `\mathbb{Z}_p[x, y]`. To verify the result in `\mathbb{Z}[x, y]`, trial
+    division is done, but only for candidates which are very likely the
+    desired GCD.
+
+    Parameters
+    ==========
+
+    f : PolyElement
+        bivariate integer polynomial
+    g : PolyElement
+        bivariate integer polynomial
+
+    Returns
+    =======
+
+    h : PolyElement
+        GCD of the polynomials `f` and `g`
+    cff : PolyElement
+        cofactor of `f`, i.e. `\frac{f}{h}`
+    cfg : PolyElement
+        cofactor of `g`, i.e. `\frac{g}{h}`
+
+    Examples
+    ========
+
+    >>> from sympy.polys.modulargcd import modgcd_bivariate
+    >>> from sympy.polys import ring, ZZ
+
+    >>> R, x, y = ring("x, y", ZZ)
+
+    >>> f = x**2 - y**2
+    >>> g = x**2 + 2*x*y + y**2
+
+    >>> h, cff, cfg = modgcd_bivariate(f, g)
+    >>> h, cff, cfg
+    (x + y, x - y, x + y)
+
+    >>> cff * h == f
+    True
+    >>> cfg * h == g
+    True
+
+    >>> f = x**2*y - x**2 - 4*y + 4
+    >>> g = x + 2
+
+    >>> h, cff, cfg = modgcd_bivariate(f, g)
+    >>> h, cff, cfg
+    (x + 2, x*y - x - 2*y + 2, 1)
+
+    >>> cff * h == f
+    True
+    >>> cfg * h == g
+    True
+
+    References
+    ==========
+
+    1. [Monagan00]_
+
+    """
+    assert f.ring == g.ring and f.ring.domain.is_ZZ
+
+    result = _trivial_gcd(f, g)
+    if result is not None:
+        return result
+
+    ring = f.ring
+
+    cf, f = f.primitive()
+    cg, g = g.primitive()
+    ch = ring.domain.gcd(cf, cg)
+
+    xbound, ycontbound = _degree_bound_bivariate(f, g)
+    if xbound == ycontbound == 0:
+        return ring(ch), f.mul_ground(cf // ch), g.mul_ground(cg // ch)
+
+    fswap = _swap(f, 1)
+    gswap = _swap(g, 1)
+    degyf = fswap.degree()
+    degyg = gswap.degree()
+
+    ybound, xcontbound = _degree_bound_bivariate(fswap, gswap)
+    if ybound == xcontbound == 0:
+        return ring(ch), f.mul_ground(cf // ch), g.mul_ground(cg // ch)
+
+    # TODO: to improve performance, choose the main variable here
+
+    gamma1 = ring.domain.gcd(f.LC, g.LC)
+    gamma2 = ring.domain.gcd(fswap.LC, gswap.LC)
+    badprimes = gamma1 * gamma2
+    m = 1
+    p = 1
+
+    while True:
+        p = nextprime(p)
+        while badprimes % p == 0:
+            p = nextprime(p)
+
+        fp = f.trunc_ground(p)
+        gp = g.trunc_ground(p)
+        contfp, fp = _primitive(fp, p)
+        contgp, gp = _primitive(gp, p)
+        conthp = _gf_gcd(contfp, contgp, p) # monic polynomial in Z_p[y]
+        degconthp = conthp.degree()
+
+        if degconthp > ycontbound:
+            continue
+        elif degconthp < ycontbound:
+            m = 1
+            ycontbound = degconthp
+            continue
+
+        # polynomial in Z_p[y]
+        delta = _gf_gcd(_LC(fp), _LC(gp), p)
+
+        degcontfp = contfp.degree()
+        degcontgp = contgp.degree()
+        degdelta = delta.degree()
+
+        N = min(degyf - degcontfp, degyg - degcontgp,
+            ybound - ycontbound + degdelta) + 1
+
+        if p < N:
+            continue
+
+        n = 0
+        evalpoints = []
+        hpeval = []
+        unlucky = False
+
+        for a in range(p):
+            deltaa = delta.evaluate(0, a)
+            if not deltaa % p:
+                continue
+
+            fpa = fp.evaluate(1, a).trunc_ground(p)
+            gpa = gp.evaluate(1, a).trunc_ground(p)
+            hpa = _gf_gcd(fpa, gpa, p) # monic polynomial in Z_p[x]
+            deghpa = hpa.degree()
+
+            if deghpa > xbound:
+                continue
+            elif deghpa < xbound:
+                m = 1
+                xbound = deghpa
+                unlucky = True
+                break
+
+            hpa = hpa.mul_ground(deltaa).trunc_ground(p)
+            evalpoints.append(a)
+            hpeval.append(hpa)
+            n += 1
+
+            if n == N:
+                break
+
+        if unlucky:
+            continue
+        if n < N:
+            continue
+
+        hp = _interpolate_multivariate(evalpoints, hpeval, ring, 1, p)
+
+        hp = _primitive(hp, p)[1]
+        hp = hp * conthp.set_ring(ring)
+        degyhp = hp.degree(1)
+
+        if degyhp > ybound:
+            continue
+        if degyhp < ybound:
+            m = 1
+            ybound = degyhp
+            continue
+
+        hp = hp.mul_ground(gamma1).trunc_ground(p)
+        if m == 1:
+            m = p
+            hlastm = hp
+            continue
+
+        hm = _chinese_remainder_reconstruction_multivariate(hp, hlastm, p, m)
+        m *= p
+
+        if not hm == hlastm:
+            hlastm = hm
+            continue
+
+        h = hm.quo_ground(hm.content())
+        fquo, frem = f.div(h)
+        gquo, grem = g.div(h)
+        if not frem and not grem:
+            if h.LC < 0:
+                ch = -ch
+            h = h.mul_ground(ch)
+            cff = fquo.mul_ground(cf // ch)
+            cfg = gquo.mul_ground(cg // ch)
+            return h, cff, cfg
+
+
+def _modgcd_multivariate_p(f, g, p, degbound, contbound):
+    r"""
+    Compute the GCD of two polynomials in
+    `\mathbb{Z}_p[x_0, \ldots, x_{k-1}]`.
+
+    The algorithm reduces the problem step by step by evaluating the
+    polynomials `f` and `g` at `x_{k-1} = a` for suitable
+    `a \in \mathbb{Z}_p` and then calls itself recursively to compute the GCD
+    in `\mathbb{Z}_p[x_0, \ldots, x_{k-2}]`. If these recursive calls are
+    successful for enough evaluation points, the GCD in `k` variables is
+    interpolated, otherwise the algorithm returns ``None``. Every time a GCD
+    or a content is computed, their degrees are compared with the bounds. If
+    a degree greater then the bound is encountered, then the current call
+    returns ``None`` and a new evaluation point has to be chosen. If at some
+    point the degree is smaller, the correspondent bound is updated and the
+    algorithm fails.
+
+    Parameters
+    ==========
+
+    f : PolyElement
+        multivariate integer polynomial with coefficients in `\mathbb{Z}_p`
+    g : PolyElement
+        multivariate integer polynomial with coefficients in `\mathbb{Z}_p`
+    p : Integer
+        prime number, modulus of `f` and `g`
+    degbound : list of Integer objects
+        ``degbound[i]`` is an upper bound for the degree of the GCD of `f`
+        and `g` in the variable `x_i`
+    contbound : list of Integer objects
+        ``contbound[i]`` is an upper bound for the degree of the content of
+        the GCD in `\mathbb{Z}_p[x_i][x_0, \ldots, x_{i-1}]`,
+        ``contbound[0]`` is not used can therefore be chosen
+        arbitrarily.
+
+    Returns
+    =======
+
+    h : PolyElement
+        GCD of the polynomials `f` and `g` or ``None``
+
+    References
+    ==========
+
+    1. [Monagan00]_
+    2. [Brown71]_
+
+    """
+    ring = f.ring
+    k = ring.ngens
+
+    if k == 1:
+        h = _gf_gcd(f, g, p).trunc_ground(p)
+        degh = h.degree()
+
+        if degh > degbound[0]:
+            return None
+        if degh < degbound[0]:
+            degbound[0] = degh
+            raise ModularGCDFailed
+
+        return h
+
+    degyf = f.degree(k-1)
+    degyg = g.degree(k-1)
+
+    contf, f = _primitive(f, p)
+    contg, g = _primitive(g, p)
+
+    conth = _gf_gcd(contf, contg, p) # polynomial in Z_p[y]
+
+    degcontf = contf.degree()
+    degcontg = contg.degree()
+    degconth = conth.degree()
+
+    if degconth > contbound[k-1]:
+        return None
+    if degconth < contbound[k-1]:
+        contbound[k-1] = degconth
+        raise ModularGCDFailed
+
+    lcf = _LC(f)
+    lcg = _LC(g)
+
+    delta = _gf_gcd(lcf, lcg, p) # polynomial in Z_p[y]
+
+    evaltest = delta
+
+    for i in range(k-1):
+        evaltest *= _gf_gcd(_LC(_swap(f, i)), _LC(_swap(g, i)), p)
+
+    degdelta = delta.degree()
+
+    N = min(degyf - degcontf, degyg - degcontg,
+            degbound[k-1] - contbound[k-1] + degdelta) + 1
+
+    if p < N:
+        return None
+
+    n = 0
+    d = 0
+    evalpoints = []
+    heval = []
+    points = list(range(p))
+
+    while points:
+        a = random.sample(points, 1)[0]
+        points.remove(a)
+
+        if not evaltest.evaluate(0, a) % p:
+            continue
+
+        deltaa = delta.evaluate(0, a) % p
+
+        fa = f.evaluate(k-1, a).trunc_ground(p)
+        ga = g.evaluate(k-1, a).trunc_ground(p)
+
+        # polynomials in Z_p[x_0, ..., x_{k-2}]
+        ha = _modgcd_multivariate_p(fa, ga, p, degbound, contbound)
+
+        if ha is None:
+            d += 1
+            if d > n:
+                return None
+            continue
+
+        if ha.is_ground:
+            h = conth.set_ring(ring).trunc_ground(p)
+            return h
+
+        ha = ha.mul_ground(deltaa).trunc_ground(p)
+
+        evalpoints.append(a)
+        heval.append(ha)
+        n += 1
+
+        if n == N:
+            h = _interpolate_multivariate(evalpoints, heval, ring, k-1, p)
+
+            h = _primitive(h, p)[1] * conth.set_ring(ring)
+            degyh = h.degree(k-1)
+
+            if degyh > degbound[k-1]:
+                return None
+            if degyh < degbound[k-1]:
+                degbound[k-1] = degyh
+                raise ModularGCDFailed
+
+            return h
+
+    return None
+
+
+def modgcd_multivariate(f, g):
+    r"""
+    Compute the GCD of two polynomials in `\mathbb{Z}[x_0, \ldots, x_{k-1}]`
+    using a modular algorithm.
+
+    The algorithm computes the GCD of two multivariate integer polynomials
+    `f` and `g` by calculating the GCD in
+    `\mathbb{Z}_p[x_0, \ldots, x_{k-1}]` for suitable primes `p` and then
+    reconstructing the coefficients with the Chinese Remainder Theorem. To
+    compute the multivariate GCD over `\mathbb{Z}_p` the recursive
+    subroutine :func:`_modgcd_multivariate_p` is used. To verify the result in
+    `\mathbb{Z}[x_0, \ldots, x_{k-1}]`, trial division is done, but only for
+    candidates which are very likely the desired GCD.
+
+    Parameters
+    ==========
+
+    f : PolyElement
+        multivariate integer polynomial
+    g : PolyElement
+        multivariate integer polynomial
+
+    Returns
+    =======
+
+    h : PolyElement
+        GCD of the polynomials `f` and `g`
+    cff : PolyElement
+        cofactor of `f`, i.e. `\frac{f}{h}`
+    cfg : PolyElement
+        cofactor of `g`, i.e. `\frac{g}{h}`
+
+    Examples
+    ========
+
+    >>> from sympy.polys.modulargcd import modgcd_multivariate
+    >>> from sympy.polys import ring, ZZ
+
+    >>> R, x, y = ring("x, y", ZZ)
+
+    >>> f = x**2 - y**2
+    >>> g = x**2 + 2*x*y + y**2
+
+    >>> h, cff, cfg = modgcd_multivariate(f, g)
+    >>> h, cff, cfg
+    (x + y, x - y, x + y)
+
+    >>> cff * h == f
+    True
+    >>> cfg * h == g
+    True
+
+    >>> R, x, y, z = ring("x, y, z", ZZ)
+
+    >>> f = x*z**2 - y*z**2
+    >>> g = x**2*z + z
+
+    >>> h, cff, cfg = modgcd_multivariate(f, g)
+    >>> h, cff, cfg
+    (z, x*z - y*z, x**2 + 1)
+
+    >>> cff * h == f
+    True
+    >>> cfg * h == g
+    True
+
+    References
+    ==========
+
+    1. [Monagan00]_
+    2. [Brown71]_
+
+    See also
+    ========
+
+    _modgcd_multivariate_p
+
+    """
+    assert f.ring == g.ring and f.ring.domain.is_ZZ
+
+    result = _trivial_gcd(f, g)
+    if result is not None:
+        return result
+
+    ring = f.ring
+    k = ring.ngens
+
+    # divide out integer content
+    cf, f = f.primitive()
+    cg, g = g.primitive()
+    ch = ring.domain.gcd(cf, cg)
+
+    gamma = ring.domain.gcd(f.LC, g.LC)
+
+    badprimes = ring.domain.one
+    for i in range(k):
+        badprimes *= ring.domain.gcd(_swap(f, i).LC, _swap(g, i).LC)
+
+    degbound = [min(fdeg, gdeg) for fdeg, gdeg in zip(f.degrees(), g.degrees())]
+    contbound = list(degbound)
+
+    m = 1
+    p = 1
+
+    while True:
+        p = nextprime(p)
+        while badprimes % p == 0:
+            p = nextprime(p)
+
+        fp = f.trunc_ground(p)
+        gp = g.trunc_ground(p)
+
+        try:
+            # monic GCD of fp, gp in Z_p[x_0, ..., x_{k-2}, y]
+            hp = _modgcd_multivariate_p(fp, gp, p, degbound, contbound)
+        except ModularGCDFailed:
+            m = 1
+            continue
+
+        if hp is None:
+            continue
+
+        hp = hp.mul_ground(gamma).trunc_ground(p)
+        if m == 1:
+            m = p
+            hlastm = hp
+            continue
+
+        hm = _chinese_remainder_reconstruction_multivariate(hp, hlastm, p, m)
+        m *= p
+
+        if not hm == hlastm:
+            hlastm = hm
+            continue
+
+        h = hm.primitive()[1]
+        fquo, frem = f.div(h)
+        gquo, grem = g.div(h)
+        if not frem and not grem:
+            if h.LC < 0:
+                ch = -ch
+            h = h.mul_ground(ch)
+            cff = fquo.mul_ground(cf // ch)
+            cfg = gquo.mul_ground(cg // ch)
+            return h, cff, cfg
+
+
+def _gf_div(f, g, p):
+    r"""
+    Compute `\frac f g` modulo `p` for two univariate polynomials over
+    `\mathbb Z_p`.
+    """
+    ring = f.ring
+    densequo, denserem = gf_div(f.to_dense(), g.to_dense(), p, ring.domain)
+    return ring.from_dense(densequo), ring.from_dense(denserem)
+
+
+def _rational_function_reconstruction(c, p, m):
+    r"""
+    Reconstruct a rational function `\frac a b` in `\mathbb Z_p(t)` from
+
+    .. math::
+
+        c = \frac a b \; \mathrm{mod} \, m,
+
+    where `c` and `m` are polynomials in `\mathbb Z_p[t]` and `m` has
+    positive degree.
+
+    The algorithm is based on the Euclidean Algorithm. In general, `m` is
+    not irreducible, so it is possible that `b` is not invertible modulo
+    `m`. In that case ``None`` is returned.
+
+    Parameters
+    ==========
+
+    c : PolyElement
+        univariate polynomial in `\mathbb Z[t]`
+    p : Integer
+        prime number
+    m : PolyElement
+        modulus, not necessarily irreducible
+
+    Returns
+    =======
+
+    frac : FracElement
+        either `\frac a b` in `\mathbb Z(t)` or ``None``
+
+    References
+    ==========
+
+    1. [Hoeij04]_
+
+    """
+    ring = c.ring
+    domain = ring.domain
+    M = m.degree()
+    N = M // 2
+    D = M - N - 1
+
+    r0, s0 = m, ring.zero
+    r1, s1 = c, ring.one
+
+    while r1.degree() > N:
+        quo = _gf_div(r0, r1, p)[0]
+        r0, r1 = r1, (r0 - quo*r1).trunc_ground(p)
+        s0, s1 = s1, (s0 - quo*s1).trunc_ground(p)
+
+    a, b = r1, s1
+    if b.degree() > D or _gf_gcd(b, m, p) != 1:
+        return None
+
+    lc = b.LC
+    if lc != 1:
+        lcinv = domain.invert(lc, p)
+        a = a.mul_ground(lcinv).trunc_ground(p)
+        b = b.mul_ground(lcinv).trunc_ground(p)
+
+    field = ring.to_field()
+
+    return field(a) / field(b)
+
+
+def _rational_reconstruction_func_coeffs(hm, p, m, ring, k):
+    r"""
+    Reconstruct every coefficient `c_h` of a polynomial `h` in
+    `\mathbb Z_p(t_k)[t_1, \ldots, t_{k-1}][x, z]` from the corresponding
+    coefficient `c_{h_m}` of a polynomial `h_m` in
+    `\mathbb Z_p[t_1, \ldots, t_k][x, z] \cong \mathbb Z_p[t_k][t_1, \ldots, t_{k-1}][x, z]`
+    such that
+
+    .. math::
+
+        c_{h_m} = c_h \; \mathrm{mod} \, m,
+
+    where `m \in \mathbb Z_p[t]`.
+
+    The reconstruction is based on the Euclidean Algorithm. In general, `m`
+    is not irreducible, so it is possible that this fails for some
+    coefficient. In that case ``None`` is returned.
+
+    Parameters
+    ==========
+
+    hm : PolyElement
+        polynomial in `\mathbb Z[t_1, \ldots, t_k][x, z]`
+    p : Integer
+        prime number, modulus of `\mathbb Z_p`
+    m : PolyElement
+        modulus, polynomial in `\mathbb Z[t]`, not necessarily irreducible
+    ring : PolyRing
+        `\mathbb Z(t_k)[t_1, \ldots, t_{k-1}][x, z]`, `h` will be an
+        element of this ring
+    k : Integer
+        index of the parameter `t_k` which will be reconstructed
+
+    Returns
+    =======
+
+    h : PolyElement
+        reconstructed polynomial in
+        `\mathbb Z(t_k)[t_1, \ldots, t_{k-1}][x, z]` or ``None``
+
+    See also
+    ========
+
+    _rational_function_reconstruction
+
+    """
+    h = ring.zero
+
+    for monom, coeff in hm.iterterms():
+        if k == 0:
+            coeffh = _rational_function_reconstruction(coeff, p, m)
+
+            if not coeffh:
+                return None
+
+        else:
+            coeffh = ring.domain.zero
+            for mon, c in coeff.drop_to_ground(k).iterterms():
+                ch = _rational_function_reconstruction(c, p, m)
+
+                if not ch:
+                    return None
+
+                coeffh[mon] = ch
+
+        h[monom] = coeffh
+
+    return h
+
+
+def _gf_gcdex(f, g, p):
+    r"""
+    Extended Euclidean Algorithm for two univariate polynomials over
+    `\mathbb Z_p`.
+
+    Returns polynomials `s, t` and `h`, such that `h` is the GCD of `f` and
+    `g` and `sf + tg = h \; \mathrm{mod} \, p`.
+
+    """
+    ring = f.ring
+    s, t, h = gf_gcdex(f.to_dense(), g.to_dense(), p, ring.domain)
+    return ring.from_dense(s), ring.from_dense(t), ring.from_dense(h)
+
+
+def _trunc(f, minpoly, p):
+    r"""
+    Compute the reduced representation of a polynomial `f` in
+    `\mathbb Z_p[z] / (\check m_{\alpha}(z))[x]`
+
+    Parameters
+    ==========
+
+    f : PolyElement
+        polynomial in `\mathbb Z[x, z]`
+    minpoly : PolyElement
+        polynomial `\check m_{\alpha} \in \mathbb Z[z]`, not necessarily
+        irreducible
+    p : Integer
+        prime number, modulus of `\mathbb Z_p`
+
+    Returns
+    =======
+
+    ftrunc : PolyElement
+        polynomial in `\mathbb Z[x, z]`, reduced modulo
+        `\check m_{\alpha}(z)` and `p`
+
+    """
+    ring = f.ring
+    minpoly = minpoly.set_ring(ring)
+    p_ = ring.ground_new(p)
+
+    return f.trunc_ground(p).rem([minpoly, p_]).trunc_ground(p)
+
+
+def _euclidean_algorithm(f, g, minpoly, p):
+    r"""
+    Compute the monic GCD of two univariate polynomials in
+    `\mathbb{Z}_p[z]/(\check m_{\alpha}(z))[x]` with the Euclidean
+    Algorithm.
+
+    In general, `\check m_{\alpha}(z)` is not irreducible, so it is possible
+    that some leading coefficient is not invertible modulo
+    `\check m_{\alpha}(z)`. In that case ``None`` is returned.
+
+    Parameters
+    ==========
+
+    f, g : PolyElement
+        polynomials in `\mathbb Z[x, z]`
+    minpoly : PolyElement
+        polynomial in `\mathbb Z[z]`, not necessarily irreducible
+    p : Integer
+        prime number, modulus of `\mathbb Z_p`
+
+    Returns
+    =======
+
+    h : PolyElement
+        GCD of `f` and `g` in `\mathbb Z[z, x]` or ``None``, coefficients
+        are in `\left[ -\frac{p-1} 2, \frac{p-1} 2 \right]`
+
+    """
+    ring = f.ring
+
+    f = _trunc(f, minpoly, p)
+    g = _trunc(g, minpoly, p)
+
+    while g:
+        rem = f
+        deg = g.degree(0) # degree in x
+        lcinv, _, gcd = _gf_gcdex(ring.dmp_LC(g), minpoly, p)
+
+        if not gcd == 1:
+            return None
+
+        while True:
+            degrem = rem.degree(0) # degree in x
+            if degrem < deg:
+                break
+            quo = (lcinv * ring.dmp_LC(rem)).set_ring(ring)
+            rem = _trunc(rem - g.mul_monom((degrem - deg, 0))*quo, minpoly, p)
+
+        f = g
+        g = rem
+
+    lcfinv = _gf_gcdex(ring.dmp_LC(f), minpoly, p)[0].set_ring(ring)
+
+    return _trunc(f * lcfinv, minpoly, p)
+
+
+def _trial_division(f, h, minpoly, p=None):
+    r"""
+    Check if `h` divides `f` in
+    `\mathbb K[t_1, \ldots, t_k][z]/(m_{\alpha}(z))`, where `\mathbb K` is
+    either `\mathbb Q` or `\mathbb Z_p`.
+
+    This algorithm is based on pseudo division and does not use any
+    fractions. By default `\mathbb K` is `\mathbb Q`, if a prime number `p`
+    is given, `\mathbb Z_p` is chosen instead.
+
+    Parameters
+    ==========
+
+    f, h : PolyElement
+        polynomials in `\mathbb Z[t_1, \ldots, t_k][x, z]`
+    minpoly : PolyElement
+        polynomial `m_{\alpha}(z)` in `\mathbb Z[t_1, \ldots, t_k][z]`
+    p : Integer or None
+        if `p` is given, `\mathbb K` is set to `\mathbb Z_p` instead of
+        `\mathbb Q`, default is ``None``
+
+    Returns
+    =======
+
+    rem : PolyElement
+        remainder of `\frac f h`
+
+    References
+    ==========
+
+    .. [1] [Hoeij02]_
+
+    """
+    ring = f.ring
+
+    zxring = ring.clone(symbols=(ring.symbols[1], ring.symbols[0]))
+
+    minpoly = minpoly.set_ring(ring)
+
+    rem = f
+
+    degrem = rem.degree()
+    degh = h.degree()
+    degm = minpoly.degree(1)
+
+    lch = _LC(h).set_ring(ring)
+    lcm = minpoly.LC
+
+    while rem and degrem >= degh:
+        # polynomial in Z[t_1, ..., t_k][z]
+        lcrem = _LC(rem).set_ring(ring)
+        rem = rem*lch - h.mul_monom((degrem - degh, 0))*lcrem
+        if p:
+            rem = rem.trunc_ground(p)
+        degrem = rem.degree(1)
+
+        while rem and degrem >= degm:
+            # polynomial in Z[t_1, ..., t_k][x]
+            lcrem = _LC(rem.set_ring(zxring)).set_ring(ring)
+            rem = rem.mul_ground(lcm) - minpoly.mul_monom((0, degrem - degm))*lcrem
+            if p:
+                rem = rem.trunc_ground(p)
+            degrem = rem.degree(1)
+
+        degrem = rem.degree()
+
+    return rem
+
+
+def _evaluate_ground(f, i, a):
+    r"""
+    Evaluate a polynomial `f` at `a` in the `i`-th variable of the ground
+    domain.
+    """
+    ring = f.ring.clone(domain=f.ring.domain.ring.drop(i))
+    fa = ring.zero
+
+    for monom, coeff in f.iterterms():
+        fa[monom] = coeff.evaluate(i, a)
+
+    return fa
+
+
+def _func_field_modgcd_p(f, g, minpoly, p):
+    r"""
+    Compute the GCD of two polynomials `f` and `g` in
+    `\mathbb Z_p(t_1, \ldots, t_k)[z]/(\check m_\alpha(z))[x]`.
+
+    The algorithm reduces the problem step by step by evaluating the
+    polynomials `f` and `g` at `t_k = a` for suitable `a \in \mathbb Z_p`
+    and then calls itself recursively to compute the GCD in
+    `\mathbb Z_p(t_1, \ldots, t_{k-1})[z]/(\check m_\alpha(z))[x]`. If these
+    recursive calls are successful, the GCD over `k` variables is
+    interpolated, otherwise the algorithm returns ``None``. After
+    interpolation, Rational Function Reconstruction is used to obtain the
+    correct coefficients. If this fails, a new evaluation point has to be
+    chosen, otherwise the desired polynomial is obtained by clearing
+    denominators. The result is verified with a fraction free trial
+    division.
+
+    Parameters
+    ==========
+
+    f, g : PolyElement
+        polynomials in `\mathbb Z[t_1, \ldots, t_k][x, z]`
+    minpoly : PolyElement
+        polynomial in `\mathbb Z[t_1, \ldots, t_k][z]`, not necessarily
+        irreducible
+    p : Integer
+        prime number, modulus of `\mathbb Z_p`
+
+    Returns
+    =======
+
+    h : PolyElement
+        primitive associate in `\mathbb Z[t_1, \ldots, t_k][x, z]` of the
+        GCD of the polynomials `f` and `g`  or ``None``, coefficients are
+        in `\left[ -\frac{p-1} 2, \frac{p-1} 2 \right]`
+
+    References
+    ==========
+
+    1. [Hoeij04]_
+
+    """
+    ring = f.ring
+    domain = ring.domain # Z[t_1, ..., t_k]
+
+    if isinstance(domain, PolynomialRing):
+        k = domain.ngens
+    else:
+        return _euclidean_algorithm(f, g, minpoly, p)
+
+    if k == 1:
+        qdomain = domain.ring.to_field()
+    else:
+        qdomain = domain.ring.drop_to_ground(k - 1)
+        qdomain = qdomain.clone(domain=qdomain.domain.ring.to_field())
+
+    qring = ring.clone(domain=qdomain) # = Z(t_k)[t_1, ..., t_{k-1}][x, z]
+
+    n = 1
+    d = 1
+
+    # polynomial in Z_p[t_1, ..., t_k][z]
+    gamma = ring.dmp_LC(f) * ring.dmp_LC(g)
+    # polynomial in Z_p[t_1, ..., t_k]
+    delta = minpoly.LC
+
+    evalpoints = []
+    heval = []
+    LMlist = []
+    points = list(range(p))
+
+    while points:
+        a = random.sample(points, 1)[0]
+        points.remove(a)
+
+        if k == 1:
+            test = delta.evaluate(k-1, a) % p == 0
+        else:
+            test = delta.evaluate(k-1, a).trunc_ground(p) == 0
+
+        if test:
+            continue
+
+        gammaa = _evaluate_ground(gamma, k-1, a)
+        minpolya = _evaluate_ground(minpoly, k-1, a)
+
+        if gammaa.rem([minpolya, gammaa.ring(p)]) == 0:
+            continue
+
+        fa = _evaluate_ground(f, k-1, a)
+        ga = _evaluate_ground(g, k-1, a)
+
+        # polynomial in Z_p[x, t_1, ..., t_{k-1}, z]/(minpoly)
+        ha = _func_field_modgcd_p(fa, ga, minpolya, p)
+
+        if ha is None:
+            d += 1
+            if d > n:
+                return None
+            continue
+
+        if ha == 1:
+            return ha
+
+        LM = [ha.degree()] + [0]*(k-1)
+        if k > 1:
+            for monom, coeff in ha.iterterms():
+                if monom[0] == LM[0] and coeff.LM > tuple(LM[1:]):
+                    LM[1:] = coeff.LM
+
+        evalpoints_a = [a]
+        heval_a = [ha]
+        if k == 1:
+            m = qring.domain.get_ring().one
+        else:
+            m = qring.domain.domain.get_ring().one
+
+        t = m.ring.gens[0]
+
+        for b, hb, LMhb in zip(evalpoints, heval, LMlist):
+            if LMhb == LM:
+                evalpoints_a.append(b)
+                heval_a.append(hb)
+                m *= (t - b)
+
+        m = m.trunc_ground(p)
+        evalpoints.append(a)
+        heval.append(ha)
+        LMlist.append(LM)
+        n += 1
+
+        # polynomial in Z_p[t_1, ..., t_k][x, z]
+        h = _interpolate_multivariate(evalpoints_a, heval_a, ring, k-1, p, ground=True)
+
+        # polynomial in Z_p(t_k)[t_1, ..., t_{k-1}][x, z]
+        h = _rational_reconstruction_func_coeffs(h, p, m, qring, k-1)
+
+        if h is None:
+            continue
+
+        if k == 1:
+            dom = qring.domain.field
+            den = dom.ring.one
+
+            for coeff in h.itercoeffs():
+                den = dom.ring.from_dense(gf_lcm(den.to_dense(), coeff.denom.to_dense(),
+                        p, dom.domain))
+
+        else:
+            dom = qring.domain.domain.field
+            den = dom.ring.one
+
+            for coeff in h.itercoeffs():
+                for c in coeff.itercoeffs():
+                    den = dom.ring.from_dense(gf_lcm(den.to_dense(), c.denom.to_dense(),
+                            p, dom.domain))
+
+        den = qring.domain_new(den.trunc_ground(p))
+        h = ring(h.mul_ground(den).as_expr()).trunc_ground(p)
+
+        if not _trial_division(f, h, minpoly, p) and not _trial_division(g, h, minpoly, p):
+            return h
+
+    return None
+
+
+def _integer_rational_reconstruction(c, m, domain):
+    r"""
+    Reconstruct a rational number `\frac a b` from
+
+    .. math::
+
+        c = \frac a b \; \mathrm{mod} \, m,
+
+    where `c` and `m` are integers.
+
+    The algorithm is based on the Euclidean Algorithm. In general, `m` is
+    not a prime number, so it is possible that `b` is not invertible modulo
+    `m`. In that case ``None`` is returned.
+
+    Parameters
+    ==========
+
+    c : Integer
+        `c = \frac a b \; \mathrm{mod} \, m`
+    m : Integer
+        modulus, not necessarily prime
+    domain : IntegerRing
+        `a, b, c` are elements of ``domain``
+
+    Returns
+    =======
+
+    frac : Rational
+        either `\frac a b` in `\mathbb Q` or ``None``
+
+    References
+    ==========
+
+    1. [Wang81]_
+
+    """
+    if c < 0:
+        c += m
+
+    r0, s0 = m, domain.zero
+    r1, s1 = c, domain.one
+
+    bound = sqrt(m / 2) # still correct if replaced by ZZ.sqrt(m // 2) ?
+
+    while int(r1) >= bound:
+        quo = r0 // r1
+        r0, r1 = r1, r0 - quo*r1
+        s0, s1 = s1, s0 - quo*s1
+
+    if abs(int(s1)) >= bound:
+        return None
+
+    if s1 < 0:
+        a, b = -r1, -s1
+    elif s1 > 0:
+        a, b = r1, s1
+    else:
+        return None
+
+    field = domain.get_field()
+
+    return field(a) / field(b)
+
+
+def _rational_reconstruction_int_coeffs(hm, m, ring):
+    r"""
+    Reconstruct every rational coefficient `c_h` of a polynomial `h` in
+    `\mathbb Q[t_1, \ldots, t_k][x, z]` from the corresponding integer
+    coefficient `c_{h_m}` of a polynomial `h_m` in
+    `\mathbb Z[t_1, \ldots, t_k][x, z]` such that
+
+    .. math::
+
+        c_{h_m} = c_h \; \mathrm{mod} \, m,
+
+    where `m \in \mathbb Z`.
+
+    The reconstruction is based on the Euclidean Algorithm. In general,
+    `m` is not a prime number, so it is possible that this fails for some
+    coefficient. In that case ``None`` is returned.
+
+    Parameters
+    ==========
+
+    hm : PolyElement
+        polynomial in `\mathbb Z[t_1, \ldots, t_k][x, z]`
+    m : Integer
+        modulus, not necessarily prime
+    ring : PolyRing
+        `\mathbb Q[t_1, \ldots, t_k][x, z]`, `h` will be an element of this
+        ring
+
+    Returns
+    =======
+
+    h : PolyElement
+        reconstructed polynomial in `\mathbb Q[t_1, \ldots, t_k][x, z]` or
+        ``None``
+
+    See also
+    ========
+
+    _integer_rational_reconstruction
+
+    """
+    h = ring.zero
+
+    if isinstance(ring.domain, PolynomialRing):
+        reconstruction = _rational_reconstruction_int_coeffs
+        domain = ring.domain.ring
+    else:
+        reconstruction = _integer_rational_reconstruction
+        domain = hm.ring.domain
+
+    for monom, coeff in hm.iterterms():
+        coeffh = reconstruction(coeff, m, domain)
+
+        if not coeffh:
+            return None
+
+        h[monom] = coeffh
+
+    return h
+
+
+def _func_field_modgcd_m(f, g, minpoly):
+    r"""
+    Compute the GCD of two polynomials in
+    `\mathbb Q(t_1, \ldots, t_k)[z]/(m_{\alpha}(z))[x]` using a modular
+    algorithm.
+
+    The algorithm computes the GCD of two polynomials `f` and `g` by
+    calculating the GCD in
+    `\mathbb Z_p(t_1, \ldots, t_k)[z] / (\check m_{\alpha}(z))[x]` for
+    suitable primes `p` and the primitive associate `\check m_{\alpha}(z)`
+    of `m_{\alpha}(z)`. Then the coefficients are reconstructed with the
+    Chinese Remainder Theorem and Rational Reconstruction. To compute the
+    GCD over `\mathbb Z_p(t_1, \ldots, t_k)[z] / (\check m_{\alpha})[x]`,
+    the recursive subroutine ``_func_field_modgcd_p`` is used. To verify the
+    result in `\mathbb Q(t_1, \ldots, t_k)[z] / (m_{\alpha}(z))[x]`, a
+    fraction free trial division is used.
+
+    Parameters
+    ==========
+
+    f, g : PolyElement
+        polynomials in `\mathbb Z[t_1, \ldots, t_k][x, z]`
+    minpoly : PolyElement
+        irreducible polynomial in `\mathbb Z[t_1, \ldots, t_k][z]`
+
+    Returns
+    =======
+
+    h : PolyElement
+        the primitive associate in `\mathbb Z[t_1, \ldots, t_k][x, z]` of
+        the GCD of `f` and `g`
+
+    Examples
+    ========
+
+    >>> from sympy.polys.modulargcd import _func_field_modgcd_m
+    >>> from sympy.polys import ring, ZZ
+
+    >>> R, x, z = ring('x, z', ZZ)
+    >>> minpoly = (z**2 - 2).drop(0)
+
+    >>> f = x**2 + 2*x*z + 2
+    >>> g = x + z
+    >>> _func_field_modgcd_m(f, g, minpoly)
+    x + z
+
+    >>> D, t = ring('t', ZZ)
+    >>> R, x, z = ring('x, z', D)
+    >>> minpoly = (z**2-3).drop(0)
+
+    >>> f = x**2 + (t + 1)*x*z + 3*t
+    >>> g = x*z + 3*t
+    >>> _func_field_modgcd_m(f, g, minpoly)
+    x + t*z
+
+    References
+    ==========
+
+    1. [Hoeij04]_
+
+    See also
+    ========
+
+    _func_field_modgcd_p
+
+    """
+    ring = f.ring
+    domain = ring.domain
+
+    if isinstance(domain, PolynomialRing):
+        k = domain.ngens
+        QQdomain = domain.ring.clone(domain=domain.domain.get_field())
+        QQring = ring.clone(domain=QQdomain)
+    else:
+        k = 0
+        QQring = ring.clone(domain=ring.domain.get_field())
+
+    cf, f = f.primitive()
+    cg, g = g.primitive()
+
+    # polynomial in Z[t_1, ..., t_k][z]
+    gamma = ring.dmp_LC(f) * ring.dmp_LC(g)
+    # polynomial in Z[t_1, ..., t_k]
+    delta = minpoly.LC
+
+    p = 1
+    primes = []
+    hplist = []
+    LMlist = []
+
+    while True:
+        p = nextprime(p)
+
+        if gamma.trunc_ground(p) == 0:
+            continue
+
+        if k == 0:
+            test = (delta % p == 0)
+        else:
+            test = (delta.trunc_ground(p) == 0)
+
+        if test:
+            continue
+
+        fp = f.trunc_ground(p)
+        gp = g.trunc_ground(p)
+        minpolyp = minpoly.trunc_ground(p)
+
+        hp = _func_field_modgcd_p(fp, gp, minpolyp, p)
+
+        if hp is None:
+            continue
+
+        if hp == 1:
+            return ring.one
+
+        LM = [hp.degree()] + [0]*k
+        if k > 0:
+            for monom, coeff in hp.iterterms():
+                if monom[0] == LM[0] and coeff.LM > tuple(LM[1:]):
+                    LM[1:] = coeff.LM
+
+        hm = hp
+        m = p
+
+        for q, hq, LMhq in zip(primes, hplist, LMlist):
+            if LMhq == LM:
+                hm = _chinese_remainder_reconstruction_multivariate(hq, hm, q, m)
+                m *= q
+
+        primes.append(p)
+        hplist.append(hp)
+        LMlist.append(LM)
+
+        hm = _rational_reconstruction_int_coeffs(hm, m, QQring)
+
+        if hm is None:
+            continue
+
+        if k == 0:
+            h = hm.clear_denoms()[1]
+        else:
+            den = domain.domain.one
+            for coeff in hm.itercoeffs():
+                den = domain.domain.lcm(den, coeff.clear_denoms()[0])
+            h = hm.mul_ground(den)
+
+        # convert back to Z[t_1, ..., t_k][x, z] from Q[t_1, ..., t_k][x, z]
+        h = h.set_ring(ring)
+        h = h.primitive()[1]
+
+        if not (_trial_division(f.mul_ground(cf), h, minpoly) or
+            _trial_division(g.mul_ground(cg), h, minpoly)):
+            return h
+
+
+def _to_ZZ_poly(f, ring):
+    r"""
+    Compute an associate of a polynomial
+    `f \in \mathbb Q(\alpha)[x_0, \ldots, x_{n-1}]` in
+    `\mathbb Z[x_1, \ldots, x_{n-1}][z] / (\check m_{\alpha}(z))[x_0]`,
+    where `\check m_{\alpha}(z) \in \mathbb Z[z]` is the primitive associate
+    of the minimal polynomial `m_{\alpha}(z)` of `\alpha` over
+    `\mathbb Q`.
+
+    Parameters
+    ==========
+
+    f : PolyElement
+        polynomial in `\mathbb Q(\alpha)[x_0, \ldots, x_{n-1}]`
+    ring : PolyRing
+        `\mathbb Z[x_1, \ldots, x_{n-1}][x_0, z]`
+
+    Returns
+    =======
+
+    f_ : PolyElement
+        associate of `f` in
+        `\mathbb Z[x_1, \ldots, x_{n-1}][x_0, z]`
+
+    """
+    f_ = ring.zero
+
+    if isinstance(ring.domain, PolynomialRing):
+        domain = ring.domain.domain
+    else:
+        domain = ring.domain
+
+    den = domain.one
+
+    for coeff in f.itercoeffs():
+        for c in coeff.to_list():
+            if c:
+                den = domain.lcm(den, c.denominator)
+
+    for monom, coeff in f.iterterms():
+        coeff = coeff.to_list()
+        m = ring.domain.one
+        if isinstance(ring.domain, PolynomialRing):
+            m = m.mul_monom(monom[1:])
+        n = len(coeff)
+
+        for i in range(n):
+            if coeff[i]:
+                c = domain.convert(coeff[i] * den) * m
+
+                if (monom[0], n-i-1) not in f_:
+                    f_[(monom[0], n-i-1)] = c
+                else:
+                    f_[(monom[0], n-i-1)] += c
+
+    return f_
+
+
+def _to_ANP_poly(f, ring):
+    r"""
+    Convert a polynomial
+    `f \in \mathbb Z[x_1, \ldots, x_{n-1}][z]/(\check m_{\alpha}(z))[x_0]`
+    to a polynomial in `\mathbb Q(\alpha)[x_0, \ldots, x_{n-1}]`,
+    where `\check m_{\alpha}(z) \in \mathbb Z[z]` is the primitive associate
+    of the minimal polynomial `m_{\alpha}(z)` of `\alpha` over
+    `\mathbb Q`.
+
+    Parameters
+    ==========
+
+    f : PolyElement
+        polynomial in `\mathbb Z[x_1, \ldots, x_{n-1}][x_0, z]`
+    ring : PolyRing
+        `\mathbb Q(\alpha)[x_0, \ldots, x_{n-1}]`
+
+    Returns
+    =======
+
+    f_ : PolyElement
+        polynomial in `\mathbb Q(\alpha)[x_0, \ldots, x_{n-1}]`
+
+    """
+    domain = ring.domain
+    f_ = ring.zero
+
+    if isinstance(f.ring.domain, PolynomialRing):
+        for monom, coeff in f.iterterms():
+            for mon, coef in coeff.iterterms():
+                m = (monom[0],) + mon
+                c = domain([domain.domain(coef)] + [0]*monom[1])
+
+                if m not in f_:
+                    f_[m] = c
+                else:
+                    f_[m] += c
+
+    else:
+        for monom, coeff in f.iterterms():
+            m = (monom[0],)
+            c = domain([domain.domain(coeff)] + [0]*monom[1])
+
+            if m not in f_:
+                f_[m] = c
+            else:
+                f_[m] += c
+
+    return f_
+
+
+def _minpoly_from_dense(minpoly, ring):
+    r"""
+    Change representation of the minimal polynomial from ``DMP`` to
+    ``PolyElement`` for a given ring.
+    """
+    minpoly_ = ring.zero
+
+    for monom, coeff in minpoly.terms():
+        minpoly_[monom] = ring.domain(coeff)
+
+    return minpoly_
+
+
+def _primitive_in_x0(f):
+    r"""
+    Compute the content in `x_0` and the primitive part of a polynomial `f`
+    in
+    `\mathbb Q(\alpha)[x_0, x_1, \ldots, x_{n-1}] \cong \mathbb Q(\alpha)[x_1, \ldots, x_{n-1}][x_0]`.
+    """
+    fring = f.ring
+    ring = fring.drop_to_ground(*range(1, fring.ngens))
+    dom = ring.domain.ring
+    f_ = ring(f.as_expr())
+    cont = dom.zero
+
+    for coeff in f_.itercoeffs():
+        cont = func_field_modgcd(cont, coeff)[0]
+        if cont == dom.one:
+            return cont, f
+
+    return cont, f.quo(cont.set_ring(fring))
+
+
+# TODO: add support for algebraic function fields
+def func_field_modgcd(f, g):
+    r"""
+    Compute the GCD of two polynomials `f` and `g` in
+    `\mathbb Q(\alpha)[x_0, \ldots, x_{n-1}]` using a modular algorithm.
+
+    The algorithm first computes the primitive associate
+    `\check m_{\alpha}(z)` of the minimal polynomial `m_{\alpha}` in
+    `\mathbb{Z}[z]` and the primitive associates of `f` and `g` in
+    `\mathbb{Z}[x_1, \ldots, x_{n-1}][z]/(\check m_{\alpha})[x_0]`. Then it
+    computes the GCD in
+    `\mathbb Q(x_1, \ldots, x_{n-1})[z]/(m_{\alpha}(z))[x_0]`.
+    This is done by calculating the GCD in
+    `\mathbb{Z}_p(x_1, \ldots, x_{n-1})[z]/(\check m_{\alpha}(z))[x_0]` for
+    suitable primes `p` and then reconstructing the coefficients with the
+    Chinese Remainder Theorem and Rational Reconstuction. The GCD over
+    `\mathbb{Z}_p(x_1, \ldots, x_{n-1})[z]/(\check m_{\alpha}(z))[x_0]` is
+    computed with a recursive subroutine, which evaluates the polynomials at
+    `x_{n-1} = a` for suitable evaluation points `a \in \mathbb Z_p` and
+    then calls itself recursively until the ground domain does no longer
+    contain any parameters. For
+    `\mathbb{Z}_p[z]/(\check m_{\alpha}(z))[x_0]` the Euclidean Algorithm is
+    used. The results of those recursive calls are then interpolated and
+    Rational Function Reconstruction is used to obtain the correct
+    coefficients. The results, both in
+    `\mathbb Q(x_1, \ldots, x_{n-1})[z]/(m_{\alpha}(z))[x_0]` and
+    `\mathbb{Z}_p(x_1, \ldots, x_{n-1})[z]/(\check m_{\alpha}(z))[x_0]`, are
+    verified by a fraction free trial division.
+
+    Apart from the above GCD computation some GCDs in
+    `\mathbb Q(\alpha)[x_1, \ldots, x_{n-1}]` have to be calculated,
+    because treating the polynomials as univariate ones can result in
+    a spurious content of the GCD. For this ``func_field_modgcd`` is
+    called recursively.
+
+    Parameters
+    ==========
+
+    f, g : PolyElement
+        polynomials in `\mathbb Q(\alpha)[x_0, \ldots, x_{n-1}]`
+
+    Returns
+    =======
+
+    h : PolyElement
+        monic GCD of the polynomials `f` and `g`
+    cff : PolyElement
+        cofactor of `f`, i.e. `\frac f h`
+    cfg : PolyElement
+        cofactor of `g`, i.e. `\frac g h`
+
+    Examples
+    ========
+
+    >>> from sympy.polys.modulargcd import func_field_modgcd
+    >>> from sympy.polys import AlgebraicField, QQ, ring
+    >>> from sympy import sqrt
+
+    >>> A = AlgebraicField(QQ, sqrt(2))
+    >>> R, x = ring('x', A)
+
+    >>> f = x**2 - 2
+    >>> g = x + sqrt(2)
+
+    >>> h, cff, cfg = func_field_modgcd(f, g)
+
+    >>> h == x + sqrt(2)
+    True
+    >>> cff * h == f
+    True
+    >>> cfg * h == g
+    True
+
+    >>> R, x, y = ring('x, y', A)
+
+    >>> f = x**2 + 2*sqrt(2)*x*y + 2*y**2
+    >>> g = x + sqrt(2)*y
+
+    >>> h, cff, cfg = func_field_modgcd(f, g)
+
+    >>> h == x + sqrt(2)*y
+    True
+    >>> cff * h == f
+    True
+    >>> cfg * h == g
+    True
+
+    >>> f = x + sqrt(2)*y
+    >>> g = x + y
+
+    >>> h, cff, cfg = func_field_modgcd(f, g)
+
+    >>> h == R.one
+    True
+    >>> cff * h == f
+    True
+    >>> cfg * h == g
+    True
+
+    References
+    ==========
+
+    1. [Hoeij04]_
+
+    """
+    ring = f.ring
+    domain = ring.domain
+    n = ring.ngens
+
+    assert ring == g.ring and domain.is_Algebraic
+
+    result = _trivial_gcd(f, g)
+    if result is not None:
+        return result
+
+    z = Dummy('z')
+
+    ZZring = ring.clone(symbols=ring.symbols + (z,), domain=domain.domain.get_ring())
+
+    if n == 1:
+        f_ = _to_ZZ_poly(f, ZZring)
+        g_ = _to_ZZ_poly(g, ZZring)
+        minpoly = ZZring.drop(0).from_dense(domain.mod.to_list())
+
+        h = _func_field_modgcd_m(f_, g_, minpoly)
+        h = _to_ANP_poly(h, ring)
+
+    else:
+        # contx0f in Q(a)[x_1, ..., x_{n-1}], f in Q(a)[x_0, ..., x_{n-1}]
+        contx0f, f = _primitive_in_x0(f)
+        contx0g, g = _primitive_in_x0(g)
+        contx0h = func_field_modgcd(contx0f, contx0g)[0]
+
+        ZZring_ = ZZring.drop_to_ground(*range(1, n))
+
+        f_ = _to_ZZ_poly(f, ZZring_)
+        g_ = _to_ZZ_poly(g, ZZring_)
+        minpoly = _minpoly_from_dense(domain.mod, ZZring_.drop(0))
+
+        h = _func_field_modgcd_m(f_, g_, minpoly)
+        h = _to_ANP_poly(h, ring)
+
+        contx0h_, h = _primitive_in_x0(h)
+        h *= contx0h.set_ring(ring)
+        f *= contx0f.set_ring(ring)
+        g *= contx0g.set_ring(ring)
+
+    h = h.quo_ground(h.LC)
+
+    return h, f.quo(h), g.quo(h)
diff --git a/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/orderings.py b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/orderings.py
new file mode 100644
index 0000000000000000000000000000000000000000..b6ed575d5103440e1e8ebda4c53c4149d3badf11
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/orderings.py
@@ -0,0 +1,286 @@
+"""Definitions of monomial orderings. """
+
+from __future__ import annotations
+
+__all__ = ["lex", "grlex", "grevlex", "ilex", "igrlex", "igrevlex"]
+
+from sympy.core import Symbol
+from sympy.utilities.iterables import iterable
+
+class MonomialOrder:
+    """Base class for monomial orderings. """
+
+    alias: str | None = None
+    is_global: bool | None = None
+    is_default = False
+
+    def __repr__(self):
+        return self.__class__.__name__ + "()"
+
+    def __str__(self):
+        return self.alias
+
+    def __call__(self, monomial):
+        raise NotImplementedError
+
+    def __eq__(self, other):
+        return self.__class__ == other.__class__
+
+    def __hash__(self):
+        return hash(self.__class__)
+
+    def __ne__(self, other):
+        return not (self == other)
+
+class LexOrder(MonomialOrder):
+    """Lexicographic order of monomials. """
+
+    alias = 'lex'
+    is_global = True
+    is_default = True
+
+    def __call__(self, monomial):
+        return monomial
+
+class GradedLexOrder(MonomialOrder):
+    """Graded lexicographic order of monomials. """
+
+    alias = 'grlex'
+    is_global = True
+
+    def __call__(self, monomial):
+        return (sum(monomial), monomial)
+
+class ReversedGradedLexOrder(MonomialOrder):
+    """Reversed graded lexicographic order of monomials. """
+
+    alias = 'grevlex'
+    is_global = True
+
+    def __call__(self, monomial):
+        return (sum(monomial), tuple(reversed([-m for m in monomial])))
+
+class ProductOrder(MonomialOrder):
+    """
+    A product order built from other monomial orders.
+
+    Given (not necessarily total) orders O1, O2, ..., On, their product order
+    P is defined as M1 > M2 iff there exists i such that O1(M1) = O2(M2),
+    ..., Oi(M1) = Oi(M2), O{i+1}(M1) > O{i+1}(M2).
+
+    Product orders are typically built from monomial orders on different sets
+    of variables.
+
+    ProductOrder is constructed by passing a list of pairs
+    [(O1, L1), (O2, L2), ...] where Oi are MonomialOrders and Li are callables.
+    Upon comparison, the Li are passed the total monomial, and should filter
+    out the part of the monomial to pass to Oi.
+
+    Examples
+    ========
+
+    We can use a lexicographic order on x_1, x_2 and also on
+    y_1, y_2, y_3, and their product on {x_i, y_i} as follows:
+
+    >>> from sympy.polys.orderings import lex, grlex, ProductOrder
+    >>> P = ProductOrder(
+    ...     (lex, lambda m: m[:2]), # lex order on x_1 and x_2 of monomial
+    ...     (grlex, lambda m: m[2:]) # grlex on y_1, y_2, y_3
+    ... )
+    >>> P((2, 1, 1, 0, 0)) > P((1, 10, 0, 2, 0))
+    True
+
+    Here the exponent `2` of `x_1` in the first monomial
+    (`x_1^2 x_2 y_1`) is bigger than the exponent `1` of `x_1` in the
+    second monomial (`x_1 x_2^10 y_2^2`), so the first monomial is greater
+    in the product ordering.
+
+    >>> P((2, 1, 1, 0, 0)) < P((2, 1, 0, 2, 0))
+    True
+
+    Here the exponents of `x_1` and `x_2` agree, so the grlex order on
+    `y_1, y_2, y_3` is used to decide the ordering. In this case the monomial
+    `y_2^2` is ordered larger than `y_1`, since for the grlex order the degree
+    of the monomial is most important.
+    """
+
+    def __init__(self, *args):
+        self.args = args
+
+    def __call__(self, monomial):
+        return tuple(O(lamda(monomial)) for (O, lamda) in self.args)
+
+    def __repr__(self):
+        contents = [repr(x[0]) for x in self.args]
+        return self.__class__.__name__ + '(' + ", ".join(contents) + ')'
+
+    def __str__(self):
+        contents = [str(x[0]) for x in self.args]
+        return self.__class__.__name__ + '(' + ", ".join(contents) + ')'
+
+    def __eq__(self, other):
+        if not isinstance(other, ProductOrder):
+            return False
+        return self.args == other.args
+
+    def __hash__(self):
+        return hash((self.__class__, self.args))
+
+    @property
+    def is_global(self):
+        if all(o.is_global is True for o, _ in self.args):
+            return True
+        if all(o.is_global is False for o, _ in self.args):
+            return False
+        return None
+
+class InverseOrder(MonomialOrder):
+    """
+    The "inverse" of another monomial order.
+
+    If O is any monomial order, we can construct another monomial order iO
+    such that `A >_{iO} B` if and only if `B >_O A`. This is useful for
+    constructing local orders.
+
+    Note that many algorithms only work with *global* orders.
+
+    For example, in the inverse lexicographic order on a single variable `x`,
+    high powers of `x` count as small:
+
+    >>> from sympy.polys.orderings import lex, InverseOrder
+    >>> ilex = InverseOrder(lex)
+    >>> ilex((5,)) < ilex((0,))
+    True
+    """
+
+    def __init__(self, O):
+        self.O = O
+
+    def __str__(self):
+        return "i" + str(self.O)
+
+    def __call__(self, monomial):
+        def inv(l):
+            if iterable(l):
+                return tuple(inv(x) for x in l)
+            return -l
+        return inv(self.O(monomial))
+
+    @property
+    def is_global(self):
+        if self.O.is_global is True:
+            return False
+        if self.O.is_global is False:
+            return True
+        return None
+
+    def __eq__(self, other):
+        return isinstance(other, InverseOrder) and other.O == self.O
+
+    def __hash__(self):
+        return hash((self.__class__, self.O))
+
+lex = LexOrder()
+grlex = GradedLexOrder()
+grevlex = ReversedGradedLexOrder()
+ilex = InverseOrder(lex)
+igrlex = InverseOrder(grlex)
+igrevlex = InverseOrder(grevlex)
+
+_monomial_key = {
+    'lex': lex,
+    'grlex': grlex,
+    'grevlex': grevlex,
+    'ilex': ilex,
+    'igrlex': igrlex,
+    'igrevlex': igrevlex
+}
+
+def monomial_key(order=None, gens=None):
+    """
+    Return a function defining admissible order on monomials.
+
+    The result of a call to :func:`monomial_key` is a function which should
+    be used as a key to :func:`sorted` built-in function, to provide order
+    in a set of monomials of the same length.
+
+    Currently supported monomial orderings are:
+
+    1. lex       - lexicographic order (default)
+    2. grlex     - graded lexicographic order
+    3. grevlex   - reversed graded lexicographic order
+    4. ilex, igrlex, igrevlex - the corresponding inverse orders
+
+    If the ``order`` input argument is not a string but has ``__call__``
+    attribute, then it will pass through with an assumption that the
+    callable object defines an admissible order on monomials.
+
+    If the ``gens`` input argument contains a list of generators, the
+    resulting key function can be used to sort SymPy ``Expr`` objects.
+
+    """
+    if order is None:
+        order = lex
+
+    if isinstance(order, Symbol):
+        order = str(order)
+
+    if isinstance(order, str):
+        try:
+            order = _monomial_key[order]
+        except KeyError:
+            raise ValueError("supported monomial orderings are 'lex', 'grlex' and 'grevlex', got %r" % order)
+    if hasattr(order, '__call__'):
+        if gens is not None:
+            def _order(expr):
+                return order(expr.as_poly(*gens).degree_list())
+            return _order
+        return order
+    else:
+        raise ValueError("monomial ordering specification must be a string or a callable, got %s" % order)
+
+class _ItemGetter:
+    """Helper class to return a subsequence of values."""
+
+    def __init__(self, seq):
+        self.seq = tuple(seq)
+
+    def __call__(self, m):
+        return tuple(m[idx] for idx in self.seq)
+
+    def __eq__(self, other):
+        if not isinstance(other, _ItemGetter):
+            return False
+        return self.seq == other.seq
+
+def build_product_order(arg, gens):
+    """
+    Build a monomial order on ``gens``.
+
+    ``arg`` should be a tuple of iterables. The first element of each iterable
+    should be a string or monomial order (will be passed to monomial_key),
+    the others should be subsets of the generators. This function will build
+    the corresponding product order.
+
+    For example, build a product of two grlex orders:
+
+    >>> from sympy.polys.orderings import build_product_order
+    >>> from sympy.abc import x, y, z, t
+
+    >>> O = build_product_order((("grlex", x, y), ("grlex", z, t)), [x, y, z, t])
+    >>> O((1, 2, 3, 4))
+    ((3, (1, 2)), (7, (3, 4)))
+
+    """
+    gens2idx = {}
+    for i, g in enumerate(gens):
+        gens2idx[g] = i
+    order = []
+    for expr in arg:
+        name = expr[0]
+        var = expr[1:]
+
+        def makelambda(var):
+            return _ItemGetter(gens2idx[g] for g in var)
+        order.append((monomial_key(name), makelambda(var)))
+    return ProductOrder(*order)
diff --git a/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/polyoptions.py b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/polyoptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..739437ff50ba3586479b692bd1123b602dedd8b7
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/polyoptions.py
@@ -0,0 +1,786 @@
+"""Options manager for :class:`~.Poly` and public API functions. """
+
+from __future__ import annotations
+
+__all__ = ["Options"]
+
+from sympy.core import Basic, sympify
+from sympy.polys.polyerrors import GeneratorsError, OptionError, FlagError
+from sympy.utilities import numbered_symbols, topological_sort, public
+from sympy.utilities.iterables import has_dups, is_sequence
+
+import sympy.polys
+
+import re
+
+class Option:
+    """Base class for all kinds of options. """
+
+    option: str | None = None
+
+    is_Flag = False
+
+    requires: list[str] = []
+    excludes: list[str] = []
+
+    after: list[str] = []
+    before: list[str] = []
+
+    @classmethod
+    def default(cls):
+        return None
+
+    @classmethod
+    def preprocess(cls, option):
+        return None
+
+    @classmethod
+    def postprocess(cls, options):
+        pass
+
+
+class Flag(Option):
+    """Base class for all kinds of flags. """
+
+    is_Flag = True
+
+
+class BooleanOption(Option):
+    """An option that must have a boolean value or equivalent assigned. """
+
+    @classmethod
+    def preprocess(cls, value):
+        if value in [True, False]:
+            return bool(value)
+        else:
+            raise OptionError("'%s' must have a boolean value assigned, got %s" % (cls.option, value))
+
+
+class OptionType(type):
+    """Base type for all options that does registers options. """
+
+    def __init__(cls, *args, **kwargs):
+        @property
+        def getter(self):
+            try:
+                return self[cls.option]
+            except KeyError:
+                return cls.default()
+
+        setattr(Options, cls.option, getter)
+        Options.__options__[cls.option] = cls
+
+
+@public
+class Options(dict):
+    """
+    Options manager for polynomial manipulation module.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.polyoptions import Options
+    >>> from sympy.polys.polyoptions import build_options
+
+    >>> from sympy.abc import x, y, z
+
+    >>> Options((x, y, z), {'domain': 'ZZ'})
+    {'auto': False, 'domain': ZZ, 'gens': (x, y, z)}
+
+    >>> build_options((x, y, z), {'domain': 'ZZ'})
+    {'auto': False, 'domain': ZZ, 'gens': (x, y, z)}
+
+    **Options**
+
+    * Expand --- boolean option
+    * Gens --- option
+    * Wrt --- option
+    * Sort --- option
+    * Order --- option
+    * Field --- boolean option
+    * Greedy --- boolean option
+    * Domain --- option
+    * Split --- boolean option
+    * Gaussian --- boolean option
+    * Extension --- option
+    * Modulus --- option
+    * Symmetric --- boolean option
+    * Strict --- boolean option
+
+    **Flags**
+
+    * Auto --- boolean flag
+    * Frac --- boolean flag
+    * Formal --- boolean flag
+    * Polys --- boolean flag
+    * Include --- boolean flag
+    * All --- boolean flag
+    * Gen --- flag
+    * Series --- boolean flag
+
+    """
+
+    __order__ = None
+    __options__: dict[str, type[Option]] = {}
+
+    def __init__(self, gens, args, flags=None, strict=False):
+        dict.__init__(self)
+
+        if gens and args.get('gens', ()):
+            raise OptionError(
+                "both '*gens' and keyword argument 'gens' supplied")
+        elif gens:
+            args = dict(args)
+            args['gens'] = gens
+
+        defaults = args.pop('defaults', {})
+
+        def preprocess_options(args):
+            for option, value in args.items():
+                try:
+                    cls = self.__options__[option]
+                except KeyError:
+                    raise OptionError("'%s' is not a valid option" % option)
+
+                if issubclass(cls, Flag):
+                    if flags is None or option not in flags:
+                        if strict:
+                            raise OptionError("'%s' flag is not allowed in this context" % option)
+
+                if value is not None:
+                    self[option] = cls.preprocess(value)
+
+        preprocess_options(args)
+
+        for key in dict(defaults):
+            if key in self:
+                del defaults[key]
+            else:
+                for option in self.keys():
+                    cls = self.__options__[option]
+
+                    if key in cls.excludes:
+                        del defaults[key]
+                        break
+
+        preprocess_options(defaults)
+
+        for option in self.keys():
+            cls = self.__options__[option]
+
+            for require_option in cls.requires:
+                if self.get(require_option) is None:
+                    raise OptionError("'%s' option is only allowed together with '%s'" % (option, require_option))
+
+            for exclude_option in cls.excludes:
+                if self.get(exclude_option) is not None:
+                    raise OptionError("'%s' option is not allowed together with '%s'" % (option, exclude_option))
+
+        for option in self.__order__:
+            self.__options__[option].postprocess(self)
+
+    @classmethod
+    def _init_dependencies_order(cls):
+        """Resolve the order of options' processing. """
+        if cls.__order__ is None:
+            vertices, edges = [], set()
+
+            for name, option in cls.__options__.items():
+                vertices.append(name)
+
+                edges.update((_name, name) for _name in option.after)
+
+                edges.update((name, _name) for _name in option.before)
+
+            try:
+                cls.__order__ = topological_sort((vertices, list(edges)))
+            except ValueError:
+                raise RuntimeError(
+                    "cycle detected in sympy.polys options framework")
+
+    def clone(self, updates={}):
+        """Clone ``self`` and update specified options. """
+        obj = dict.__new__(self.__class__)
+
+        for option, value in self.items():
+            obj[option] = value
+
+        for option, value in updates.items():
+            obj[option] = value
+
+        return obj
+
+    def __setattr__(self, attr, value):
+        if attr in self.__options__:
+            self[attr] = value
+        else:
+            super().__setattr__(attr, value)
+
+    @property
+    def args(self):
+        args = {}
+
+        for option, value in self.items():
+            if value is not None and option != 'gens':
+                cls = self.__options__[option]
+
+                if not issubclass(cls, Flag):
+                    args[option] = value
+
+        return args
+
+    @property
+    def options(self):
+        options = {}
+
+        for option, cls in self.__options__.items():
+            if not issubclass(cls, Flag):
+                options[option] = getattr(self, option)
+
+        return options
+
+    @property
+    def flags(self):
+        flags = {}
+
+        for option, cls in self.__options__.items():
+            if issubclass(cls, Flag):
+                flags[option] = getattr(self, option)
+
+        return flags
+
+
+class Expand(BooleanOption, metaclass=OptionType):
+    """``expand`` option to polynomial manipulation functions. """
+
+    option = 'expand'
+
+    requires: list[str] = []
+    excludes: list[str] = []
+
+    @classmethod
+    def default(cls):
+        return True
+
+
+class Gens(Option, metaclass=OptionType):
+    """``gens`` option to polynomial manipulation functions. """
+
+    option = 'gens'
+
+    requires: list[str] = []
+    excludes: list[str] = []
+
+    @classmethod
+    def default(cls):
+        return ()
+
+    @classmethod
+    def preprocess(cls, gens):
+        if isinstance(gens, Basic):
+            gens = (gens,)
+        elif len(gens) == 1 and is_sequence(gens[0]):
+            gens = gens[0]
+
+        if gens == (None,):
+            gens = ()
+        elif has_dups(gens):
+            raise GeneratorsError("duplicated generators: %s" % str(gens))
+        elif any(gen.is_commutative is False for gen in gens):
+            raise GeneratorsError("non-commutative generators: %s" % str(gens))
+
+        return tuple(gens)
+
+
+class Wrt(Option, metaclass=OptionType):
+    """``wrt`` option to polynomial manipulation functions. """
+
+    option = 'wrt'
+
+    requires: list[str] = []
+    excludes: list[str] = []
+
+    _re_split = re.compile(r"\s*,\s*|\s+")
+
+    @classmethod
+    def preprocess(cls, wrt):
+        if isinstance(wrt, Basic):
+            return [str(wrt)]
+        elif isinstance(wrt, str):
+            wrt = wrt.strip()
+            if wrt.endswith(','):
+                raise OptionError('Bad input: missing parameter.')
+            if not wrt:
+                return []
+            return list(cls._re_split.split(wrt))
+        elif hasattr(wrt, '__getitem__'):
+            return list(map(str, wrt))
+        else:
+            raise OptionError("invalid argument for 'wrt' option")
+
+
+class Sort(Option, metaclass=OptionType):
+    """``sort`` option to polynomial manipulation functions. """
+
+    option = 'sort'
+
+    requires: list[str] = []
+    excludes: list[str] = []
+
+    @classmethod
+    def default(cls):
+        return []
+
+    @classmethod
+    def preprocess(cls, sort):
+        if isinstance(sort, str):
+            return [ gen.strip() for gen in sort.split('>') ]
+        elif hasattr(sort, '__getitem__'):
+            return list(map(str, sort))
+        else:
+            raise OptionError("invalid argument for 'sort' option")
+
+
+class Order(Option, metaclass=OptionType):
+    """``order`` option to polynomial manipulation functions. """
+
+    option = 'order'
+
+    requires: list[str] = []
+    excludes: list[str] = []
+
+    @classmethod
+    def default(cls):
+        return sympy.polys.orderings.lex
+
+    @classmethod
+    def preprocess(cls, order):
+        return sympy.polys.orderings.monomial_key(order)
+
+
+class Field(BooleanOption, metaclass=OptionType):
+    """``field`` option to polynomial manipulation functions. """
+
+    option = 'field'
+
+    requires: list[str] = []
+    excludes = ['domain', 'split', 'gaussian']
+
+
+class Greedy(BooleanOption, metaclass=OptionType):
+    """``greedy`` option to polynomial manipulation functions. """
+
+    option = 'greedy'
+
+    requires: list[str] = []
+    excludes = ['domain', 'split', 'gaussian', 'extension', 'modulus', 'symmetric']
+
+
+class Composite(BooleanOption, metaclass=OptionType):
+    """``composite`` option to polynomial manipulation functions. """
+
+    option = 'composite'
+
+    @classmethod
+    def default(cls):
+        return None
+
+    requires: list[str] = []
+    excludes = ['domain', 'split', 'gaussian', 'extension', 'modulus', 'symmetric']
+
+
+class Domain(Option, metaclass=OptionType):
+    """``domain`` option to polynomial manipulation functions. """
+
+    option = 'domain'
+
+    requires: list[str] = []
+    excludes = ['field', 'greedy', 'split', 'gaussian', 'extension']
+
+    after = ['gens']
+
+    _re_realfield = re.compile(r"^(R|RR)(_(\d+))?$")
+    _re_complexfield = re.compile(r"^(C|CC)(_(\d+))?$")
+    _re_finitefield = re.compile(r"^(FF|GF)\((\d+)\)$")
+    _re_polynomial = re.compile(r"^(Z|ZZ|Q|QQ|ZZ_I|QQ_I|R|RR|C|CC)\[(.+)\]$")
+    _re_fraction = re.compile(r"^(Z|ZZ|Q|QQ)\((.+)\)$")
+    _re_algebraic = re.compile(r"^(Q|QQ)\<(.+)\>$")
+
+    @classmethod
+    def preprocess(cls, domain):
+        if isinstance(domain, sympy.polys.domains.Domain):
+            return domain
+        elif hasattr(domain, 'to_domain'):
+            return domain.to_domain()
+        elif isinstance(domain, str):
+            if domain in ['Z', 'ZZ']:
+                return sympy.polys.domains.ZZ
+
+            if domain in ['Q', 'QQ']:
+                return sympy.polys.domains.QQ
+
+            if domain == 'ZZ_I':
+                return sympy.polys.domains.ZZ_I
+
+            if domain == 'QQ_I':
+                return sympy.polys.domains.QQ_I
+
+            if domain == 'EX':
+                return sympy.polys.domains.EX
+
+            r = cls._re_realfield.match(domain)
+
+            if r is not None:
+                _, _, prec = r.groups()
+
+                if prec is None:
+                    return sympy.polys.domains.RR
+                else:
+                    return sympy.polys.domains.RealField(int(prec))
+
+            r = cls._re_complexfield.match(domain)
+
+            if r is not None:
+                _, _, prec = r.groups()
+
+                if prec is None:
+                    return sympy.polys.domains.CC
+                else:
+                    return sympy.polys.domains.ComplexField(int(prec))
+
+            r = cls._re_finitefield.match(domain)
+
+            if r is not None:
+                return sympy.polys.domains.FF(int(r.groups()[1]))
+
+            r = cls._re_polynomial.match(domain)
+
+            if r is not None:
+                ground, gens = r.groups()
+
+                gens = list(map(sympify, gens.split(',')))
+
+                if ground in ['Z', 'ZZ']:
+                    return sympy.polys.domains.ZZ.poly_ring(*gens)
+                elif ground in ['Q', 'QQ']:
+                    return sympy.polys.domains.QQ.poly_ring(*gens)
+                elif ground in ['R', 'RR']:
+                    return sympy.polys.domains.RR.poly_ring(*gens)
+                elif ground == 'ZZ_I':
+                    return sympy.polys.domains.ZZ_I.poly_ring(*gens)
+                elif ground == 'QQ_I':
+                    return sympy.polys.domains.QQ_I.poly_ring(*gens)
+                else:
+                    return sympy.polys.domains.CC.poly_ring(*gens)
+
+            r = cls._re_fraction.match(domain)
+
+            if r is not None:
+                ground, gens = r.groups()
+
+                gens = list(map(sympify, gens.split(',')))
+
+                if ground in ['Z', 'ZZ']:
+                    return sympy.polys.domains.ZZ.frac_field(*gens)
+                else:
+                    return sympy.polys.domains.QQ.frac_field(*gens)
+
+            r = cls._re_algebraic.match(domain)
+
+            if r is not None:
+                gens = list(map(sympify, r.groups()[1].split(',')))
+                return sympy.polys.domains.QQ.algebraic_field(*gens)
+
+        raise OptionError('expected a valid domain specification, got %s' % domain)
+
+    @classmethod
+    def postprocess(cls, options):
+        if 'gens' in options and 'domain' in options and options['domain'].is_Composite and \
+                (set(options['domain'].symbols) & set(options['gens'])):
+            raise GeneratorsError(
+                "ground domain and generators interfere together")
+        elif ('gens' not in options or not options['gens']) and \
+                'domain' in options and options['domain'] == sympy.polys.domains.EX:
+            raise GeneratorsError("you have to provide generators because EX domain was requested")
+
+
+class Split(BooleanOption, metaclass=OptionType):
+    """``split`` option to polynomial manipulation functions. """
+
+    option = 'split'
+
+    requires: list[str] = []
+    excludes = ['field', 'greedy', 'domain', 'gaussian', 'extension',
+        'modulus', 'symmetric']
+
+    @classmethod
+    def postprocess(cls, options):
+        if 'split' in options:
+            raise NotImplementedError("'split' option is not implemented yet")
+
+
+class Gaussian(BooleanOption, metaclass=OptionType):
+    """``gaussian`` option to polynomial manipulation functions. """
+
+    option = 'gaussian'
+
+    requires: list[str] = []
+    excludes = ['field', 'greedy', 'domain', 'split', 'extension',
+        'modulus', 'symmetric']
+
+    @classmethod
+    def postprocess(cls, options):
+        if 'gaussian' in options and options['gaussian'] is True:
+            options['domain'] = sympy.polys.domains.QQ_I
+            Extension.postprocess(options)
+
+
+class Extension(Option, metaclass=OptionType):
+    """``extension`` option to polynomial manipulation functions. """
+
+    option = 'extension'
+
+    requires: list[str] = []
+    excludes = ['greedy', 'domain', 'split', 'gaussian', 'modulus',
+        'symmetric']
+
+    @classmethod
+    def preprocess(cls, extension):
+        if extension == 1:
+            return bool(extension)
+        elif extension == 0:
+            raise OptionError("'False' is an invalid argument for 'extension'")
+        else:
+            if not hasattr(extension, '__iter__'):
+                extension = {extension}
+            else:
+                if not extension:
+                    extension = None
+                else:
+                    extension = set(extension)
+
+            return extension
+
+    @classmethod
+    def postprocess(cls, options):
+        if 'extension' in options and options['extension'] is not True:
+            options['domain'] = sympy.polys.domains.QQ.algebraic_field(
+                *options['extension'])
+
+
+class Modulus(Option, metaclass=OptionType):
+    """``modulus`` option to polynomial manipulation functions. """
+
+    option = 'modulus'
+
+    requires: list[str] = []
+    excludes = ['greedy', 'split', 'domain', 'gaussian', 'extension']
+
+    @classmethod
+    def preprocess(cls, modulus):
+        modulus = sympify(modulus)
+
+        if modulus.is_Integer and modulus > 0:
+            return int(modulus)
+        else:
+            raise OptionError(
+                "'modulus' must a positive integer, got %s" % modulus)
+
+    @classmethod
+    def postprocess(cls, options):
+        if 'modulus' in options:
+            modulus = options['modulus']
+            symmetric = options.get('symmetric', True)
+            options['domain'] = sympy.polys.domains.FF(modulus, symmetric)
+
+
+class Symmetric(BooleanOption, metaclass=OptionType):
+    """``symmetric`` option to polynomial manipulation functions. """
+
+    option = 'symmetric'
+
+    requires = ['modulus']
+    excludes = ['greedy', 'domain', 'split', 'gaussian', 'extension']
+
+
+class Strict(BooleanOption, metaclass=OptionType):
+    """``strict`` option to polynomial manipulation functions. """
+
+    option = 'strict'
+
+    @classmethod
+    def default(cls):
+        return True
+
+
+class Auto(BooleanOption, Flag, metaclass=OptionType):
+    """``auto`` flag to polynomial manipulation functions. """
+
+    option = 'auto'
+
+    after = ['field', 'domain', 'extension', 'gaussian']
+
+    @classmethod
+    def default(cls):
+        return True
+
+    @classmethod
+    def postprocess(cls, options):
+        if ('domain' in options or 'field' in options) and 'auto' not in options:
+            options['auto'] = False
+
+
+class Frac(BooleanOption, Flag, metaclass=OptionType):
+    """``auto`` option to polynomial manipulation functions. """
+
+    option = 'frac'
+
+    @classmethod
+    def default(cls):
+        return False
+
+
+class Formal(BooleanOption, Flag, metaclass=OptionType):
+    """``formal`` flag to polynomial manipulation functions. """
+
+    option = 'formal'
+
+    @classmethod
+    def default(cls):
+        return False
+
+
+class Polys(BooleanOption, Flag, metaclass=OptionType):
+    """``polys`` flag to polynomial manipulation functions. """
+
+    option = 'polys'
+
+
+class Include(BooleanOption, Flag, metaclass=OptionType):
+    """``include`` flag to polynomial manipulation functions. """
+
+    option = 'include'
+
+    @classmethod
+    def default(cls):
+        return False
+
+
+class All(BooleanOption, Flag, metaclass=OptionType):
+    """``all`` flag to polynomial manipulation functions. """
+
+    option = 'all'
+
+    @classmethod
+    def default(cls):
+        return False
+
+
+class Gen(Flag, metaclass=OptionType):
+    """``gen`` flag to polynomial manipulation functions. """
+
+    option = 'gen'
+
+    @classmethod
+    def default(cls):
+        return 0
+
+    @classmethod
+    def preprocess(cls, gen):
+        if isinstance(gen, (Basic, int)):
+            return gen
+        else:
+            raise OptionError("invalid argument for 'gen' option")
+
+
+class Series(BooleanOption, Flag, metaclass=OptionType):
+    """``series`` flag to polynomial manipulation functions. """
+
+    option = 'series'
+
+    @classmethod
+    def default(cls):
+        return False
+
+
+class Symbols(Flag, metaclass=OptionType):
+    """``symbols`` flag to polynomial manipulation functions. """
+
+    option = 'symbols'
+
+    @classmethod
+    def default(cls):
+        return numbered_symbols('s', start=1)
+
+    @classmethod
+    def preprocess(cls, symbols):
+        if hasattr(symbols, '__iter__'):
+            return iter(symbols)
+        else:
+            raise OptionError("expected an iterator or iterable container, got %s" % symbols)
+
+
+class Method(Flag, metaclass=OptionType):
+    """``method`` flag to polynomial manipulation functions. """
+
+    option = 'method'
+
+    @classmethod
+    def preprocess(cls, method):
+        if isinstance(method, str):
+            return method.lower()
+        else:
+            raise OptionError("expected a string, got %s" % method)
+
+
+def build_options(gens, args=None):
+    """Construct options from keyword arguments or ... options. """
+    if args is None:
+        gens, args = (), gens
+
+    if len(args) != 1 or 'opt' not in args or gens:
+        return Options(gens, args)
+    else:
+        return args['opt']
+
+
+def allowed_flags(args, flags):
+    """
+    Allow specified flags to be used in the given context.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.polyoptions import allowed_flags
+    >>> from sympy.polys.domains import ZZ
+
+    >>> allowed_flags({'domain': ZZ}, [])
+
+    >>> allowed_flags({'domain': ZZ, 'frac': True}, [])
+    Traceback (most recent call last):
+    ...
+    FlagError: 'frac' flag is not allowed in this context
+
+    >>> allowed_flags({'domain': ZZ, 'frac': True}, ['frac'])
+
+    """
+    flags = set(flags)
+
+    for arg in args.keys():
+        try:
+            if Options.__options__[arg].is_Flag and arg not in flags:
+                raise FlagError(
+                    "'%s' flag is not allowed in this context" % arg)
+        except KeyError:
+            raise OptionError("'%s' is not a valid option" % arg)
+
+
+def set_defaults(options, **defaults):
+    """Update options with default values. """
+    if 'defaults' not in options:
+        options = dict(options)
+        options['defaults'] = defaults
+
+    return options
+
+Options._init_dependencies_order()
diff --git a/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/rings.py b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/rings.py
new file mode 100644
index 0000000000000000000000000000000000000000..7e3db5d3997b10735395b3d130246eaaddd918b6
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/rings.py
@@ -0,0 +1,3013 @@
+"""Sparse polynomial rings. """
+
+from __future__ import annotations
+from typing import Any
+
+from operator import add, mul, lt, le, gt, ge
+from functools import reduce
+from types import GeneratorType
+
+from sympy.core.expr import Expr
+from sympy.core.intfunc import igcd
+from sympy.core.symbol import Symbol, symbols as _symbols
+from sympy.core.sympify import CantSympify, sympify
+from sympy.ntheory.multinomial import multinomial_coefficients
+from sympy.polys.compatibility import IPolys
+from sympy.polys.constructor import construct_domain
+from sympy.polys.densebasic import ninf, dmp_to_dict, dmp_from_dict
+from sympy.polys.domains.domainelement import DomainElement
+from sympy.polys.domains.polynomialring import PolynomialRing
+from sympy.polys.heuristicgcd import heugcd
+from sympy.polys.monomials import MonomialOps
+from sympy.polys.orderings import lex
+from sympy.polys.polyerrors import (
+    CoercionFailed, GeneratorsError,
+    ExactQuotientFailed, MultivariatePolynomialError)
+from sympy.polys.polyoptions import (Domain as DomainOpt,
+                                     Order as OrderOpt, build_options)
+from sympy.polys.polyutils import (expr_from_dict, _dict_reorder,
+                                   _parallel_dict_from_expr)
+from sympy.printing.defaults import DefaultPrinting
+from sympy.utilities import public, subsets
+from sympy.utilities.iterables import is_sequence
+from sympy.utilities.magic import pollute
+
+@public
+def ring(symbols, domain, order=lex):
+    """Construct a polynomial ring returning ``(ring, x_1, ..., x_n)``.
+
+    Parameters
+    ==========
+
+    symbols : str
+        Symbol/Expr or sequence of str, Symbol/Expr (non-empty)
+    domain : :class:`~.Domain` or coercible
+    order : :class:`~.MonomialOrder` or coercible, optional, defaults to ``lex``
+
+    Examples
+    ========
+
+    >>> from sympy.polys.rings import ring
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.orderings import lex
+
+    >>> R, x, y, z = ring("x,y,z", ZZ, lex)
+    >>> R
+    Polynomial ring in x, y, z over ZZ with lex order
+    >>> x + y + z
+    x + y + z
+    >>> type(_)
+    <class 'sympy.polys.rings.PolyElement'>
+
+    """
+    _ring = PolyRing(symbols, domain, order)
+    return (_ring,) + _ring.gens
+
+@public
+def xring(symbols, domain, order=lex):
+    """Construct a polynomial ring returning ``(ring, (x_1, ..., x_n))``.
+
+    Parameters
+    ==========
+
+    symbols : str
+        Symbol/Expr or sequence of str, Symbol/Expr (non-empty)
+    domain : :class:`~.Domain` or coercible
+    order : :class:`~.MonomialOrder` or coercible, optional, defaults to ``lex``
+
+    Examples
+    ========
+
+    >>> from sympy.polys.rings import xring
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.orderings import lex
+
+    >>> R, (x, y, z) = xring("x,y,z", ZZ, lex)
+    >>> R
+    Polynomial ring in x, y, z over ZZ with lex order
+    >>> x + y + z
+    x + y + z
+    >>> type(_)
+    <class 'sympy.polys.rings.PolyElement'>
+
+    """
+    _ring = PolyRing(symbols, domain, order)
+    return (_ring, _ring.gens)
+
+@public
+def vring(symbols, domain, order=lex):
+    """Construct a polynomial ring and inject ``x_1, ..., x_n`` into the global namespace.
+
+    Parameters
+    ==========
+
+    symbols : str
+        Symbol/Expr or sequence of str, Symbol/Expr (non-empty)
+    domain : :class:`~.Domain` or coercible
+    order : :class:`~.MonomialOrder` or coercible, optional, defaults to ``lex``
+
+    Examples
+    ========
+
+    >>> from sympy.polys.rings import vring
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.orderings import lex
+
+    >>> vring("x,y,z", ZZ, lex)
+    Polynomial ring in x, y, z over ZZ with lex order
+    >>> x + y + z # noqa:
+    x + y + z
+    >>> type(_)
+    <class 'sympy.polys.rings.PolyElement'>
+
+    """
+    _ring = PolyRing(symbols, domain, order)
+    pollute([ sym.name for sym in _ring.symbols ], _ring.gens)
+    return _ring
+
+@public
+def sring(exprs, *symbols, **options):
+    """Construct a ring deriving generators and domain from options and input expressions.
+
+    Parameters
+    ==========
+
+    exprs : :class:`~.Expr` or sequence of :class:`~.Expr` (sympifiable)
+    symbols : sequence of :class:`~.Symbol`/:class:`~.Expr`
+    options : keyword arguments understood by :class:`~.Options`
+
+    Examples
+    ========
+
+    >>> from sympy import sring, symbols
+
+    >>> x, y, z = symbols("x,y,z")
+    >>> R, f = sring(x + 2*y + 3*z)
+    >>> R
+    Polynomial ring in x, y, z over ZZ with lex order
+    >>> f
+    x + 2*y + 3*z
+    >>> type(_)
+    <class 'sympy.polys.rings.PolyElement'>
+
+    """
+    single = False
+
+    if not is_sequence(exprs):
+        exprs, single = [exprs], True
+
+    exprs = list(map(sympify, exprs))
+    opt = build_options(symbols, options)
+
+    # TODO: rewrite this so that it doesn't use expand() (see poly()).
+    reps, opt = _parallel_dict_from_expr(exprs, opt)
+
+    if opt.domain is None:
+        coeffs = sum([ list(rep.values()) for rep in reps ], [])
+
+        opt.domain, coeffs_dom = construct_domain(coeffs, opt=opt)
+
+        coeff_map = dict(zip(coeffs, coeffs_dom))
+        reps = [{m: coeff_map[c] for m, c in rep.items()} for rep in reps]
+
+    _ring = PolyRing(opt.gens, opt.domain, opt.order)
+    polys = list(map(_ring.from_dict, reps))
+
+    if single:
+        return (_ring, polys[0])
+    else:
+        return (_ring, polys)
+
+def _parse_symbols(symbols):
+    if isinstance(symbols, str):
+        return _symbols(symbols, seq=True) if symbols else ()
+    elif isinstance(symbols, Expr):
+        return (symbols,)
+    elif is_sequence(symbols):
+        if all(isinstance(s, str) for s in symbols):
+            return _symbols(symbols)
+        elif all(isinstance(s, Expr) for s in symbols):
+            return symbols
+
+    raise GeneratorsError("expected a string, Symbol or expression or a non-empty sequence of strings, Symbols or expressions")
+
+_ring_cache: dict[Any, Any] = {}
+
+class PolyRing(DefaultPrinting, IPolys):
+    """Multivariate distributed polynomial ring. """
+
+    def __new__(cls, symbols, domain, order=lex):
+        symbols = tuple(_parse_symbols(symbols))
+        ngens = len(symbols)
+        domain = DomainOpt.preprocess(domain)
+        order = OrderOpt.preprocess(order)
+
+        _hash_tuple = (cls.__name__, symbols, ngens, domain, order)
+        obj = _ring_cache.get(_hash_tuple)
+
+        if obj is None:
+            if domain.is_Composite and set(symbols) & set(domain.symbols):
+                raise GeneratorsError("polynomial ring and it's ground domain share generators")
+
+            obj = object.__new__(cls)
+            obj._hash_tuple = _hash_tuple
+            obj._hash = hash(_hash_tuple)
+            obj.dtype = type("PolyElement", (PolyElement,), {"ring": obj})
+            obj.symbols = symbols
+            obj.ngens = ngens
+            obj.domain = domain
+            obj.order = order
+
+            obj.zero_monom = (0,)*ngens
+            obj.gens = obj._gens()
+            obj._gens_set = set(obj.gens)
+
+            obj._one = [(obj.zero_monom, domain.one)]
+
+            if ngens:
+                # These expect monomials in at least one variable
+                codegen = MonomialOps(ngens)
+                obj.monomial_mul = codegen.mul()
+                obj.monomial_pow = codegen.pow()
+                obj.monomial_mulpow = codegen.mulpow()
+                obj.monomial_ldiv = codegen.ldiv()
+                obj.monomial_div = codegen.div()
+                obj.monomial_lcm = codegen.lcm()
+                obj.monomial_gcd = codegen.gcd()
+            else:
+                monunit = lambda a, b: ()
+                obj.monomial_mul = monunit
+                obj.monomial_pow = monunit
+                obj.monomial_mulpow = lambda a, b, c: ()
+                obj.monomial_ldiv = monunit
+                obj.monomial_div = monunit
+                obj.monomial_lcm = monunit
+                obj.monomial_gcd = monunit
+
+
+            if order is lex:
+                obj.leading_expv = max
+            else:
+                obj.leading_expv = lambda f: max(f, key=order)
+
+            for symbol, generator in zip(obj.symbols, obj.gens):
+                if isinstance(symbol, Symbol):
+                    name = symbol.name
+
+                    if not hasattr(obj, name):
+                        setattr(obj, name, generator)
+
+            _ring_cache[_hash_tuple] = obj
+
+        return obj
+
+    def _gens(self):
+        """Return a list of polynomial generators. """
+        one = self.domain.one
+        _gens = []
+        for i in range(self.ngens):
+            expv = self.monomial_basis(i)
+            poly = self.zero
+            poly[expv] = one
+            _gens.append(poly)
+        return tuple(_gens)
+
+    def __getnewargs__(self):
+        return (self.symbols, self.domain, self.order)
+
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        del state["leading_expv"]
+
+        for key in state:
+            if key.startswith("monomial_"):
+                del state[key]
+
+        return state
+
+    def __hash__(self):
+        return self._hash
+
+    def __eq__(self, other):
+        return isinstance(other, PolyRing) and \
+            (self.symbols, self.domain, self.ngens, self.order) == \
+            (other.symbols, other.domain, other.ngens, other.order)
+
+    def __ne__(self, other):
+        return not self == other
+
+    def clone(self, symbols=None, domain=None, order=None):
+        return self.__class__(symbols or self.symbols, domain or self.domain, order or self.order)
+
+    def monomial_basis(self, i):
+        """Return the ith-basis element. """
+        basis = [0]*self.ngens
+        basis[i] = 1
+        return tuple(basis)
+
+    @property
+    def zero(self):
+        return self.dtype()
+
+    @property
+    def one(self):
+        return self.dtype(self._one)
+
+    def domain_new(self, element, orig_domain=None):
+        return self.domain.convert(element, orig_domain)
+
+    def ground_new(self, coeff):
+        return self.term_new(self.zero_monom, coeff)
+
+    def term_new(self, monom, coeff):
+        coeff = self.domain_new(coeff)
+        poly = self.zero
+        if coeff:
+            poly[monom] = coeff
+        return poly
+
+    def ring_new(self, element):
+        if isinstance(element, PolyElement):
+            if self == element.ring:
+                return element
+            elif isinstance(self.domain, PolynomialRing) and self.domain.ring == element.ring:
+                return self.ground_new(element)
+            else:
+                raise NotImplementedError("conversion")
+        elif isinstance(element, str):
+            raise NotImplementedError("parsing")
+        elif isinstance(element, dict):
+            return self.from_dict(element)
+        elif isinstance(element, list):
+            try:
+                return self.from_terms(element)
+            except ValueError:
+                return self.from_list(element)
+        elif isinstance(element, Expr):
+            return self.from_expr(element)
+        else:
+            return self.ground_new(element)
+
+    __call__ = ring_new
+
+    def from_dict(self, element, orig_domain=None):
+        domain_new = self.domain_new
+        poly = self.zero
+
+        for monom, coeff in element.items():
+            coeff = domain_new(coeff, orig_domain)
+            if coeff:
+                poly[monom] = coeff
+
+        return poly
+
+    def from_terms(self, element, orig_domain=None):
+        return self.from_dict(dict(element), orig_domain)
+
+    def from_list(self, element):
+        return self.from_dict(dmp_to_dict(element, self.ngens-1, self.domain))
+
+    def _rebuild_expr(self, expr, mapping):
+        domain = self.domain
+
+        def _rebuild(expr):
+            generator = mapping.get(expr)
+
+            if generator is not None:
+                return generator
+            elif expr.is_Add:
+                return reduce(add, list(map(_rebuild, expr.args)))
+            elif expr.is_Mul:
+                return reduce(mul, list(map(_rebuild, expr.args)))
+            else:
+                # XXX: Use as_base_exp() to handle Pow(x, n) and also exp(n)
+                # XXX: E can be a generator e.g. sring([exp(2)]) -> ZZ[E]
+                base, exp = expr.as_base_exp()
+                if exp.is_Integer and exp > 1:
+                    return _rebuild(base)**int(exp)
+                else:
+                    return self.ground_new(domain.convert(expr))
+
+        return _rebuild(sympify(expr))
+
+    def from_expr(self, expr):
+        mapping = dict(list(zip(self.symbols, self.gens)))
+
+        try:
+            poly = self._rebuild_expr(expr, mapping)
+        except CoercionFailed:
+            raise ValueError("expected an expression convertible to a polynomial in %s, got %s" % (self, expr))
+        else:
+            return self.ring_new(poly)
+
+    def index(self, gen):
+        """Compute index of ``gen`` in ``self.gens``. """
+        if gen is None:
+            if self.ngens:
+                i = 0
+            else:
+                i = -1  # indicate impossible choice
+        elif isinstance(gen, int):
+            i = gen
+
+            if 0 <= i and i < self.ngens:
+                pass
+            elif -self.ngens <= i and i <= -1:
+                i = -i - 1
+            else:
+                raise ValueError("invalid generator index: %s" % gen)
+        elif isinstance(gen, self.dtype):
+            try:
+                i = self.gens.index(gen)
+            except ValueError:
+                raise ValueError("invalid generator: %s" % gen)
+        elif isinstance(gen, str):
+            try:
+                i = self.symbols.index(gen)
+            except ValueError:
+                raise ValueError("invalid generator: %s" % gen)
+        else:
+            raise ValueError("expected a polynomial generator, an integer, a string or None, got %s" % gen)
+
+        return i
+
+    def drop(self, *gens):
+        """Remove specified generators from this ring. """
+        indices = set(map(self.index, gens))
+        symbols = [ s for i, s in enumerate(self.symbols) if i not in indices ]
+
+        if not symbols:
+            return self.domain
+        else:
+            return self.clone(symbols=symbols)
+
+    def __getitem__(self, key):
+        symbols = self.symbols[key]
+
+        if not symbols:
+            return self.domain
+        else:
+            return self.clone(symbols=symbols)
+
+    def to_ground(self):
+        # TODO: should AlgebraicField be a Composite domain?
+        if self.domain.is_Composite or hasattr(self.domain, 'domain'):
+            return self.clone(domain=self.domain.domain)
+        else:
+            raise ValueError("%s is not a composite domain" % self.domain)
+
+    def to_domain(self):
+        return PolynomialRing(self)
+
+    def to_field(self):
+        from sympy.polys.fields import FracField
+        return FracField(self.symbols, self.domain, self.order)
+
+    @property
+    def is_univariate(self):
+        return len(self.gens) == 1
+
+    @property
+    def is_multivariate(self):
+        return len(self.gens) > 1
+
+    def add(self, *objs):
+        """
+        Add a sequence of polynomials or containers of polynomials.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.rings import ring
+        >>> from sympy.polys.domains import ZZ
+
+        >>> R, x = ring("x", ZZ)
+        >>> R.add([ x**2 + 2*i + 3 for i in range(4) ])
+        4*x**2 + 24
+        >>> _.factor_list()
+        (4, [(x**2 + 6, 1)])
+
+        """
+        p = self.zero
+
+        for obj in objs:
+            if is_sequence(obj, include=GeneratorType):
+                p += self.add(*obj)
+            else:
+                p += obj
+
+        return p
+
+    def mul(self, *objs):
+        """
+        Multiply a sequence of polynomials or containers of polynomials.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.rings import ring
+        >>> from sympy.polys.domains import ZZ
+
+        >>> R, x = ring("x", ZZ)
+        >>> R.mul([ x**2 + 2*i + 3 for i in range(4) ])
+        x**8 + 24*x**6 + 206*x**4 + 744*x**2 + 945
+        >>> _.factor_list()
+        (1, [(x**2 + 3, 1), (x**2 + 5, 1), (x**2 + 7, 1), (x**2 + 9, 1)])
+
+        """
+        p = self.one
+
+        for obj in objs:
+            if is_sequence(obj, include=GeneratorType):
+                p *= self.mul(*obj)
+            else:
+                p *= obj
+
+        return p
+
+    def drop_to_ground(self, *gens):
+        r"""
+        Remove specified generators from the ring and inject them into
+        its domain.
+        """
+        indices = set(map(self.index, gens))
+        symbols = [s for i, s in enumerate(self.symbols) if i not in indices]
+        gens = [gen for i, gen in enumerate(self.gens) if i not in indices]
+
+        if not symbols:
+            return self
+        else:
+            return self.clone(symbols=symbols, domain=self.drop(*gens))
+
+    def compose(self, other):
+        """Add the generators of ``other`` to ``self``"""
+        if self != other:
+            syms = set(self.symbols).union(set(other.symbols))
+            return self.clone(symbols=list(syms))
+        else:
+            return self
+
+    def add_gens(self, symbols):
+        """Add the elements of ``symbols`` as generators to ``self``"""
+        syms = set(self.symbols).union(set(symbols))
+        return self.clone(symbols=list(syms))
+
+    def symmetric_poly(self, n):
+        """
+        Return the elementary symmetric polynomial of degree *n* over
+        this ring's generators.
+        """
+        if n < 0 or n > self.ngens:
+            raise ValueError("Cannot generate symmetric polynomial of order %s for %s" % (n, self.gens))
+        elif not n:
+            return self.one
+        else:
+            poly = self.zero
+            for s in subsets(range(self.ngens), int(n)):
+                monom = tuple(int(i in s) for i in range(self.ngens))
+                poly += self.term_new(monom, self.domain.one)
+            return poly
+
+
+class PolyElement(DomainElement, DefaultPrinting, CantSympify, dict):
+    """Element of multivariate distributed polynomial ring. """
+
+    def new(self, init):
+        return self.__class__(init)
+
+    def parent(self):
+        return self.ring.to_domain()
+
+    def __getnewargs__(self):
+        return (self.ring, list(self.iterterms()))
+
+    _hash = None
+
+    def __hash__(self):
+        # XXX: This computes a hash of a dictionary, but currently we don't
+        # protect dictionary from being changed so any use site modifications
+        # will make hashing go wrong. Use this feature with caution until we
+        # figure out how to make a safe API without compromising speed of this
+        # low-level class.
+        _hash = self._hash
+        if _hash is None:
+            self._hash = _hash = hash((self.ring, frozenset(self.items())))
+        return _hash
+
+    def copy(self):
+        """Return a copy of polynomial self.
+
+        Polynomials are mutable; if one is interested in preserving
+        a polynomial, and one plans to use inplace operations, one
+        can copy the polynomial. This method makes a shallow copy.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.domains import ZZ
+        >>> from sympy.polys.rings import ring
+
+        >>> R, x, y = ring('x, y', ZZ)
+        >>> p = (x + y)**2
+        >>> p1 = p.copy()
+        >>> p2 = p
+        >>> p[R.zero_monom] = 3
+        >>> p
+        x**2 + 2*x*y + y**2 + 3
+        >>> p1
+        x**2 + 2*x*y + y**2
+        >>> p2
+        x**2 + 2*x*y + y**2 + 3
+
+        """
+        return self.new(self)
+
+    def set_ring(self, new_ring):
+        if self.ring == new_ring:
+            return self
+        elif self.ring.symbols != new_ring.symbols:
+            terms = list(zip(*_dict_reorder(self, self.ring.symbols, new_ring.symbols)))
+            return new_ring.from_terms(terms, self.ring.domain)
+        else:
+            return new_ring.from_dict(self, self.ring.domain)
+
+    def as_expr(self, *symbols):
+        if not symbols:
+            symbols = self.ring.symbols
+        elif len(symbols) != self.ring.ngens:
+            raise ValueError(
+                "Wrong number of symbols, expected %s got %s" %
+                (self.ring.ngens, len(symbols))
+            )
+
+        return expr_from_dict(self.as_expr_dict(), *symbols)
+
+    def as_expr_dict(self):
+        to_sympy = self.ring.domain.to_sympy
+        return {monom: to_sympy(coeff) for monom, coeff in self.iterterms()}
+
+    def clear_denoms(self):
+        domain = self.ring.domain
+
+        if not domain.is_Field or not domain.has_assoc_Ring:
+            return domain.one, self
+
+        ground_ring = domain.get_ring()
+        common = ground_ring.one
+        lcm = ground_ring.lcm
+        denom = domain.denom
+
+        for coeff in self.values():
+            common = lcm(common, denom(coeff))
+
+        poly = self.new([ (k, v*common) for k, v in self.items() ])
+        return common, poly
+
+    def strip_zero(self):
+        """Eliminate monomials with zero coefficient. """
+        for k, v in list(self.items()):
+            if not v:
+                del self[k]
+
+    def __eq__(p1, p2):
+        """Equality test for polynomials.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.domains import ZZ
+        >>> from sympy.polys.rings import ring
+
+        >>> _, x, y = ring('x, y', ZZ)
+        >>> p1 = (x + y)**2 + (x - y)**2
+        >>> p1 == 4*x*y
+        False
+        >>> p1 == 2*(x**2 + y**2)
+        True
+
+        """
+        if not p2:
+            return not p1
+        elif isinstance(p2, PolyElement) and p2.ring == p1.ring:
+            return dict.__eq__(p1, p2)
+        elif len(p1) > 1:
+            return False
+        else:
+            return p1.get(p1.ring.zero_monom) == p2
+
+    def __ne__(p1, p2):
+        return not p1 == p2
+
+    def almosteq(p1, p2, tolerance=None):
+        """Approximate equality test for polynomials. """
+        ring = p1.ring
+
+        if isinstance(p2, ring.dtype):
+            if set(p1.keys()) != set(p2.keys()):
+                return False
+
+            almosteq = ring.domain.almosteq
+
+            for k in p1.keys():
+                if not almosteq(p1[k], p2[k], tolerance):
+                    return False
+            return True
+        elif len(p1) > 1:
+            return False
+        else:
+            try:
+                p2 = ring.domain.convert(p2)
+            except CoercionFailed:
+                return False
+            else:
+                return ring.domain.almosteq(p1.const(), p2, tolerance)
+
+    def sort_key(self):
+        return (len(self), self.terms())
+
+    def _cmp(p1, p2, op):
+        if isinstance(p2, p1.ring.dtype):
+            return op(p1.sort_key(), p2.sort_key())
+        else:
+            return NotImplemented
+
+    def __lt__(p1, p2):
+        return p1._cmp(p2, lt)
+    def __le__(p1, p2):
+        return p1._cmp(p2, le)
+    def __gt__(p1, p2):
+        return p1._cmp(p2, gt)
+    def __ge__(p1, p2):
+        return p1._cmp(p2, ge)
+
+    def _drop(self, gen):
+        ring = self.ring
+        i = ring.index(gen)
+
+        if ring.ngens == 1:
+            return i, ring.domain
+        else:
+            symbols = list(ring.symbols)
+            del symbols[i]
+            return i, ring.clone(symbols=symbols)
+
+    def drop(self, gen):
+        i, ring = self._drop(gen)
+
+        if self.ring.ngens == 1:
+            if self.is_ground:
+                return self.coeff(1)
+            else:
+                raise ValueError("Cannot drop %s" % gen)
+        else:
+            poly = ring.zero
+
+            for k, v in self.items():
+                if k[i] == 0:
+                    K = list(k)
+                    del K[i]
+                    poly[tuple(K)] = v
+                else:
+                    raise ValueError("Cannot drop %s" % gen)
+
+            return poly
+
+    def _drop_to_ground(self, gen):
+        ring = self.ring
+        i = ring.index(gen)
+
+        symbols = list(ring.symbols)
+        del symbols[i]
+        return i, ring.clone(symbols=symbols, domain=ring[i])
+
+    def drop_to_ground(self, gen):
+        if self.ring.ngens == 1:
+            raise ValueError("Cannot drop only generator to ground")
+
+        i, ring = self._drop_to_ground(gen)
+        poly = ring.zero
+        gen = ring.domain.gens[0]
+
+        for monom, coeff in self.iterterms():
+            mon = monom[:i] + monom[i+1:]
+            if mon not in poly:
+                poly[mon] = (gen**monom[i]).mul_ground(coeff)
+            else:
+                poly[mon] += (gen**monom[i]).mul_ground(coeff)
+
+        return poly
+
+    def to_dense(self):
+        return dmp_from_dict(self, self.ring.ngens-1, self.ring.domain)
+
+    def to_dict(self):
+        return dict(self)
+
+    def str(self, printer, precedence, exp_pattern, mul_symbol):
+        if not self:
+            return printer._print(self.ring.domain.zero)
+        prec_mul = precedence["Mul"]
+        prec_atom = precedence["Atom"]
+        ring = self.ring
+        symbols = ring.symbols
+        ngens = ring.ngens
+        zm = ring.zero_monom
+        sexpvs = []
+        for expv, coeff in self.terms():
+            negative = ring.domain.is_negative(coeff)
+            sign = " - " if negative else " + "
+            sexpvs.append(sign)
+            if expv == zm:
+                scoeff = printer._print(coeff)
+                if negative and scoeff.startswith("-"):
+                    scoeff = scoeff[1:]
+            else:
+                if negative:
+                    coeff = -coeff
+                if coeff != self.ring.domain.one:
+                    scoeff = printer.parenthesize(coeff, prec_mul, strict=True)
+                else:
+                    scoeff = ''
+            sexpv = []
+            for i in range(ngens):
+                exp = expv[i]
+                if not exp:
+                    continue
+                symbol = printer.parenthesize(symbols[i], prec_atom, strict=True)
+                if exp != 1:
+                    if exp != int(exp) or exp < 0:
+                        sexp = printer.parenthesize(exp, prec_atom, strict=False)
+                    else:
+                        sexp = exp
+                    sexpv.append(exp_pattern % (symbol, sexp))
+                else:
+                    sexpv.append('%s' % symbol)
+            if scoeff:
+                sexpv = [scoeff] + sexpv
+            sexpvs.append(mul_symbol.join(sexpv))
+        if sexpvs[0] in [" + ", " - "]:
+            head = sexpvs.pop(0)
+            if head == " - ":
+                sexpvs.insert(0, "-")
+        return "".join(sexpvs)
+
+    @property
+    def is_generator(self):
+        return self in self.ring._gens_set
+
+    @property
+    def is_ground(self):
+        return not self or (len(self) == 1 and self.ring.zero_monom in self)
+
+    @property
+    def is_monomial(self):
+        return not self or (len(self) == 1 and self.LC == 1)
+
+    @property
+    def is_term(self):
+        return len(self) <= 1
+
+    @property
+    def is_negative(self):
+        return self.ring.domain.is_negative(self.LC)
+
+    @property
+    def is_positive(self):
+        return self.ring.domain.is_positive(self.LC)
+
+    @property
+    def is_nonnegative(self):
+        return self.ring.domain.is_nonnegative(self.LC)
+
+    @property
+    def is_nonpositive(self):
+        return self.ring.domain.is_nonpositive(self.LC)
+
+    @property
+    def is_zero(f):
+        return not f
+
+    @property
+    def is_one(f):
+        return f == f.ring.one
+
+    @property
+    def is_monic(f):
+        return f.ring.domain.is_one(f.LC)
+
+    @property
+    def is_primitive(f):
+        return f.ring.domain.is_one(f.content())
+
+    @property
+    def is_linear(f):
+        return all(sum(monom) <= 1 for monom in f.itermonoms())
+
+    @property
+    def is_quadratic(f):
+        return all(sum(monom) <= 2 for monom in f.itermonoms())
+
+    @property
+    def is_squarefree(f):
+        if not f.ring.ngens:
+            return True
+        return f.ring.dmp_sqf_p(f)
+
+    @property
+    def is_irreducible(f):
+        if not f.ring.ngens:
+            return True
+        return f.ring.dmp_irreducible_p(f)
+
+    @property
+    def is_cyclotomic(f):
+        if f.ring.is_univariate:
+            return f.ring.dup_cyclotomic_p(f)
+        else:
+            raise MultivariatePolynomialError("cyclotomic polynomial")
+
+    def __neg__(self):
+        return self.new([ (monom, -coeff) for monom, coeff in self.iterterms() ])
+
+    def __pos__(self):
+        return self
+
+    def __add__(p1, p2):
+        """Add two polynomials.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.domains import ZZ
+        >>> from sympy.polys.rings import ring
+
+        >>> _, x, y = ring('x, y', ZZ)
+        >>> (x + y)**2 + (x - y)**2
+        2*x**2 + 2*y**2
+
+        """
+        if not p2:
+            return p1.copy()
+        ring = p1.ring
+        if isinstance(p2, ring.dtype):
+            p = p1.copy()
+            get = p.get
+            zero = ring.domain.zero
+            for k, v in p2.items():
+                v = get(k, zero) + v
+                if v:
+                    p[k] = v
+                else:
+                    del p[k]
+            return p
+        elif isinstance(p2, PolyElement):
+            if isinstance(ring.domain, PolynomialRing) and ring.domain.ring == p2.ring:
+                pass
+            elif isinstance(p2.ring.domain, PolynomialRing) and p2.ring.domain.ring == ring:
+                return p2.__radd__(p1)
+            else:
+                return NotImplemented
+
+        try:
+            cp2 = ring.domain_new(p2)
+        except CoercionFailed:
+            return NotImplemented
+        else:
+            p = p1.copy()
+            if not cp2:
+                return p
+            zm = ring.zero_monom
+            if zm not in p1.keys():
+                p[zm] = cp2
+            else:
+                if p2 == -p[zm]:
+                    del p[zm]
+                else:
+                    p[zm] += cp2
+            return p
+
+    def __radd__(p1, n):
+        p = p1.copy()
+        if not n:
+            return p
+        ring = p1.ring
+        try:
+            n = ring.domain_new(n)
+        except CoercionFailed:
+            return NotImplemented
+        else:
+            zm = ring.zero_monom
+            if zm not in p1.keys():
+                p[zm] = n
+            else:
+                if n == -p[zm]:
+                    del p[zm]
+                else:
+                    p[zm] += n
+            return p
+
+    def __sub__(p1, p2):
+        """Subtract polynomial p2 from p1.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.domains import ZZ
+        >>> from sympy.polys.rings import ring
+
+        >>> _, x, y = ring('x, y', ZZ)
+        >>> p1 = x + y**2
+        >>> p2 = x*y + y**2
+        >>> p1 - p2
+        -x*y + x
+
+        """
+        if not p2:
+            return p1.copy()
+        ring = p1.ring
+        if isinstance(p2, ring.dtype):
+            p = p1.copy()
+            get = p.get
+            zero = ring.domain.zero
+            for k, v in p2.items():
+                v = get(k, zero) - v
+                if v:
+                    p[k] = v
+                else:
+                    del p[k]
+            return p
+        elif isinstance(p2, PolyElement):
+            if isinstance(ring.domain, PolynomialRing) and ring.domain.ring == p2.ring:
+                pass
+            elif isinstance(p2.ring.domain, PolynomialRing) and p2.ring.domain.ring == ring:
+                return p2.__rsub__(p1)
+            else:
+                return NotImplemented
+
+        try:
+            p2 = ring.domain_new(p2)
+        except CoercionFailed:
+            return NotImplemented
+        else:
+            p = p1.copy()
+            zm = ring.zero_monom
+            if zm not in p1.keys():
+                p[zm] = -p2
+            else:
+                if p2 == p[zm]:
+                    del p[zm]
+                else:
+                    p[zm] -= p2
+            return p
+
+    def __rsub__(p1, n):
+        """n - p1 with n convertible to the coefficient domain.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.domains import ZZ
+        >>> from sympy.polys.rings import ring
+
+        >>> _, x, y = ring('x, y', ZZ)
+        >>> p = x + y
+        >>> 4 - p
+        -x - y + 4
+
+        """
+        ring = p1.ring
+        try:
+            n = ring.domain_new(n)
+        except CoercionFailed:
+            return NotImplemented
+        else:
+            p = ring.zero
+            for expv in p1:
+                p[expv] = -p1[expv]
+            p += n
+            return p
+
+    def __mul__(p1, p2):
+        """Multiply two polynomials.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.domains import QQ
+        >>> from sympy.polys.rings import ring
+
+        >>> _, x, y = ring('x, y', QQ)
+        >>> p1 = x + y
+        >>> p2 = x - y
+        >>> p1*p2
+        x**2 - y**2
+
+        """
+        ring = p1.ring
+        p = ring.zero
+        if not p1 or not p2:
+            return p
+        elif isinstance(p2, ring.dtype):
+            get = p.get
+            zero = ring.domain.zero
+            monomial_mul = ring.monomial_mul
+            p2it = list(p2.items())
+            for exp1, v1 in p1.items():
+                for exp2, v2 in p2it:
+                    exp = monomial_mul(exp1, exp2)
+                    p[exp] = get(exp, zero) + v1*v2
+            p.strip_zero()
+            return p
+        elif isinstance(p2, PolyElement):
+            if isinstance(ring.domain, PolynomialRing) and ring.domain.ring == p2.ring:
+                pass
+            elif isinstance(p2.ring.domain, PolynomialRing) and p2.ring.domain.ring == ring:
+                return p2.__rmul__(p1)
+            else:
+                return NotImplemented
+
+        try:
+            p2 = ring.domain_new(p2)
+        except CoercionFailed:
+            return NotImplemented
+        else:
+            for exp1, v1 in p1.items():
+                v = v1*p2
+                if v:
+                    p[exp1] = v
+            return p
+
+    def __rmul__(p1, p2):
+        """p2 * p1 with p2 in the coefficient domain of p1.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.domains import ZZ
+        >>> from sympy.polys.rings import ring
+
+        >>> _, x, y = ring('x, y', ZZ)
+        >>> p = x + y
+        >>> 4 * p
+        4*x + 4*y
+
+        """
+        p = p1.ring.zero
+        if not p2:
+            return p
+        try:
+            p2 = p.ring.domain_new(p2)
+        except CoercionFailed:
+            return NotImplemented
+        else:
+            for exp1, v1 in p1.items():
+                v = p2*v1
+                if v:
+                    p[exp1] = v
+            return p
+
+    def __pow__(self, n):
+        """raise polynomial to power `n`
+
+        Examples
+        ========
+
+        >>> from sympy.polys.domains import ZZ
+        >>> from sympy.polys.rings import ring
+
+        >>> _, x, y = ring('x, y', ZZ)
+        >>> p = x + y**2
+        >>> p**3
+        x**3 + 3*x**2*y**2 + 3*x*y**4 + y**6
+
+        """
+        ring = self.ring
+
+        if not n:
+            if self:
+                return ring.one
+            else:
+                raise ValueError("0**0")
+        elif len(self) == 1:
+            monom, coeff = list(self.items())[0]
+            p = ring.zero
+            if coeff == ring.domain.one:
+                p[ring.monomial_pow(monom, n)] = coeff
+            else:
+                p[ring.monomial_pow(monom, n)] = coeff**n
+            return p
+
+        # For ring series, we need negative and rational exponent support only
+        # with monomials.
+        n = int(n)
+        if n < 0:
+            raise ValueError("Negative exponent")
+
+        elif n == 1:
+            return self.copy()
+        elif n == 2:
+            return self.square()
+        elif n == 3:
+            return self*self.square()
+        elif len(self) <= 5: # TODO: use an actual density measure
+            return self._pow_multinomial(n)
+        else:
+            return self._pow_generic(n)
+
+    def _pow_generic(self, n):
+        p = self.ring.one
+        c = self
+
+        while True:
+            if n & 1:
+                p = p*c
+                n -= 1
+                if not n:
+                    break
+
+            c = c.square()
+            n = n // 2
+
+        return p
+
+    def _pow_multinomial(self, n):
+        multinomials = multinomial_coefficients(len(self), n).items()
+        monomial_mulpow = self.ring.monomial_mulpow
+        zero_monom = self.ring.zero_monom
+        terms = self.items()
+        zero = self.ring.domain.zero
+        poly = self.ring.zero
+
+        for multinomial, multinomial_coeff in multinomials:
+            product_monom = zero_monom
+            product_coeff = multinomial_coeff
+
+            for exp, (monom, coeff) in zip(multinomial, terms):
+                if exp:
+                    product_monom = monomial_mulpow(product_monom, monom, exp)
+                    product_coeff *= coeff**exp
+
+            monom = tuple(product_monom)
+            coeff = product_coeff
+
+            coeff = poly.get(monom, zero) + coeff
+
+            if coeff:
+                poly[monom] = coeff
+            elif monom in poly:
+                del poly[monom]
+
+        return poly
+
+    def square(self):
+        """square of a polynomial
+
+        Examples
+        ========
+
+        >>> from sympy.polys.rings import ring
+        >>> from sympy.polys.domains import ZZ
+
+        >>> _, x, y = ring('x, y', ZZ)
+        >>> p = x + y**2
+        >>> p.square()
+        x**2 + 2*x*y**2 + y**4
+
+        """
+        ring = self.ring
+        p = ring.zero
+        get = p.get
+        keys = list(self.keys())
+        zero = ring.domain.zero
+        monomial_mul = ring.monomial_mul
+        for i in range(len(keys)):
+            k1 = keys[i]
+            pk = self[k1]
+            for j in range(i):
+                k2 = keys[j]
+                exp = monomial_mul(k1, k2)
+                p[exp] = get(exp, zero) + pk*self[k2]
+        p = p.imul_num(2)
+        get = p.get
+        for k, v in self.items():
+            k2 = monomial_mul(k, k)
+            p[k2] = get(k2, zero) + v**2
+        p.strip_zero()
+        return p
+
+    def __divmod__(p1, p2):
+        ring = p1.ring
+
+        if not p2:
+            raise ZeroDivisionError("polynomial division")
+        elif isinstance(p2, ring.dtype):
+            return p1.div(p2)
+        elif isinstance(p2, PolyElement):
+            if isinstance(ring.domain, PolynomialRing) and ring.domain.ring == p2.ring:
+                pass
+            elif isinstance(p2.ring.domain, PolynomialRing) and p2.ring.domain.ring == ring:
+                return p2.__rdivmod__(p1)
+            else:
+                return NotImplemented
+
+        try:
+            p2 = ring.domain_new(p2)
+        except CoercionFailed:
+            return NotImplemented
+        else:
+            return (p1.quo_ground(p2), p1.rem_ground(p2))
+
+    def __rdivmod__(p1, p2):
+        return NotImplemented
+
+    def __mod__(p1, p2):
+        ring = p1.ring
+
+        if not p2:
+            raise ZeroDivisionError("polynomial division")
+        elif isinstance(p2, ring.dtype):
+            return p1.rem(p2)
+        elif isinstance(p2, PolyElement):
+            if isinstance(ring.domain, PolynomialRing) and ring.domain.ring == p2.ring:
+                pass
+            elif isinstance(p2.ring.domain, PolynomialRing) and p2.ring.domain.ring == ring:
+                return p2.__rmod__(p1)
+            else:
+                return NotImplemented
+
+        try:
+            p2 = ring.domain_new(p2)
+        except CoercionFailed:
+            return NotImplemented
+        else:
+            return p1.rem_ground(p2)
+
+    def __rmod__(p1, p2):
+        return NotImplemented
+
+    def __truediv__(p1, p2):
+        ring = p1.ring
+
+        if not p2:
+            raise ZeroDivisionError("polynomial division")
+        elif isinstance(p2, ring.dtype):
+            if p2.is_monomial:
+                return p1*(p2**(-1))
+            else:
+                return p1.quo(p2)
+        elif isinstance(p2, PolyElement):
+            if isinstance(ring.domain, PolynomialRing) and ring.domain.ring == p2.ring:
+                pass
+            elif isinstance(p2.ring.domain, PolynomialRing) and p2.ring.domain.ring == ring:
+                return p2.__rtruediv__(p1)
+            else:
+                return NotImplemented
+
+        try:
+            p2 = ring.domain_new(p2)
+        except CoercionFailed:
+            return NotImplemented
+        else:
+            return p1.quo_ground(p2)
+
+    def __rtruediv__(p1, p2):
+        return NotImplemented
+
+    __floordiv__ = __truediv__
+    __rfloordiv__ = __rtruediv__
+
+    # TODO: use // (__floordiv__) for exquo()?
+
+    def _term_div(self):
+        zm = self.ring.zero_monom
+        domain = self.ring.domain
+        domain_quo = domain.quo
+        monomial_div = self.ring.monomial_div
+
+        if domain.is_Field:
+            def term_div(a_lm_a_lc, b_lm_b_lc):
+                a_lm, a_lc = a_lm_a_lc
+                b_lm, b_lc = b_lm_b_lc
+                if b_lm == zm: # apparently this is a very common case
+                    monom = a_lm
+                else:
+                    monom = monomial_div(a_lm, b_lm)
+                if monom is not None:
+                    return monom, domain_quo(a_lc, b_lc)
+                else:
+                    return None
+        else:
+            def term_div(a_lm_a_lc, b_lm_b_lc):
+                a_lm, a_lc = a_lm_a_lc
+                b_lm, b_lc = b_lm_b_lc
+                if b_lm == zm: # apparently this is a very common case
+                    monom = a_lm
+                else:
+                    monom = monomial_div(a_lm, b_lm)
+                if not (monom is None or a_lc % b_lc):
+                    return monom, domain_quo(a_lc, b_lc)
+                else:
+                    return None
+
+        return term_div
+
+    def div(self, fv):
+        """Division algorithm, see [CLO] p64.
+
+        fv array of polynomials
+           return qv, r such that
+           self = sum(fv[i]*qv[i]) + r
+
+        All polynomials are required not to be Laurent polynomials.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.rings import ring
+        >>> from sympy.polys.domains import ZZ
+
+        >>> _, x, y = ring('x, y', ZZ)
+        >>> f = x**3
+        >>> f0 = x - y**2
+        >>> f1 = x - y
+        >>> qv, r = f.div((f0, f1))
+        >>> qv[0]
+        x**2 + x*y**2 + y**4
+        >>> qv[1]
+        0
+        >>> r
+        y**6
+
+        """
+        ring = self.ring
+        ret_single = False
+        if isinstance(fv, PolyElement):
+            ret_single = True
+            fv = [fv]
+        if not all(fv):
+            raise ZeroDivisionError("polynomial division")
+        if not self:
+            if ret_single:
+                return ring.zero, ring.zero
+            else:
+                return [], ring.zero
+        for f in fv:
+            if f.ring != ring:
+                raise ValueError('self and f must have the same ring')
+        s = len(fv)
+        qv = [ring.zero for i in range(s)]
+        p = self.copy()
+        r = ring.zero
+        term_div = self._term_div()
+        expvs = [fx.leading_expv() for fx in fv]
+        while p:
+            i = 0
+            divoccurred = 0
+            while i < s and divoccurred == 0:
+                expv = p.leading_expv()
+                term = term_div((expv, p[expv]), (expvs[i], fv[i][expvs[i]]))
+                if term is not None:
+                    expv1, c = term
+                    qv[i] = qv[i]._iadd_monom((expv1, c))
+                    p = p._iadd_poly_monom(fv[i], (expv1, -c))
+                    divoccurred = 1
+                else:
+                    i += 1
+            if not divoccurred:
+                expv =  p.leading_expv()
+                r = r._iadd_monom((expv, p[expv]))
+                del p[expv]
+        if expv == ring.zero_monom:
+            r += p
+        if ret_single:
+            if not qv:
+                return ring.zero, r
+            else:
+                return qv[0], r
+        else:
+            return qv, r
+
+    def rem(self, G):
+        f = self
+        if isinstance(G, PolyElement):
+            G = [G]
+        if not all(G):
+            raise ZeroDivisionError("polynomial division")
+        ring = f.ring
+        domain = ring.domain
+        zero = domain.zero
+        monomial_mul = ring.monomial_mul
+        r = ring.zero
+        term_div = f._term_div()
+        ltf = f.LT
+        f = f.copy()
+        get = f.get
+        while f:
+            for g in G:
+                tq = term_div(ltf, g.LT)
+                if tq is not None:
+                    m, c = tq
+                    for mg, cg in g.iterterms():
+                        m1 = monomial_mul(mg, m)
+                        c1 = get(m1, zero) - c*cg
+                        if not c1:
+                            del f[m1]
+                        else:
+                            f[m1] = c1
+                    ltm = f.leading_expv()
+                    if ltm is not None:
+                        ltf = ltm, f[ltm]
+
+                    break
+            else:
+                ltm, ltc = ltf
+                if ltm in r:
+                    r[ltm] += ltc
+                else:
+                    r[ltm] = ltc
+                del f[ltm]
+                ltm = f.leading_expv()
+                if ltm is not None:
+                    ltf = ltm, f[ltm]
+
+        return r
+
+    def quo(f, G):
+        return f.div(G)[0]
+
+    def exquo(f, G):
+        q, r = f.div(G)
+
+        if not r:
+            return q
+        else:
+            raise ExactQuotientFailed(f, G)
+
+    def _iadd_monom(self, mc):
+        """add to self the monomial coeff*x0**i0*x1**i1*...
+        unless self is a generator -- then just return the sum of the two.
+
+        mc is a tuple, (monom, coeff), where monomial is (i0, i1, ...)
+
+        Examples
+        ========
+
+        >>> from sympy.polys.rings import ring
+        >>> from sympy.polys.domains import ZZ
+
+        >>> _, x, y = ring('x, y', ZZ)
+        >>> p = x**4 + 2*y
+        >>> m = (1, 2)
+        >>> p1 = p._iadd_monom((m, 5))
+        >>> p1
+        x**4 + 5*x*y**2 + 2*y
+        >>> p1 is p
+        True
+        >>> p = x
+        >>> p1 = p._iadd_monom((m, 5))
+        >>> p1
+        5*x*y**2 + x
+        >>> p1 is p
+        False
+
+        """
+        if self in self.ring._gens_set:
+            cpself = self.copy()
+        else:
+            cpself = self
+        expv, coeff = mc
+        c = cpself.get(expv)
+        if c is None:
+            cpself[expv] = coeff
+        else:
+            c += coeff
+            if c:
+                cpself[expv] = c
+            else:
+                del cpself[expv]
+        return cpself
+
+    def _iadd_poly_monom(self, p2, mc):
+        """add to self the product of (p)*(coeff*x0**i0*x1**i1*...)
+        unless self is a generator -- then just return the sum of the two.
+
+        mc is a tuple, (monom, coeff), where monomial is (i0, i1, ...)
+
+        Examples
+        ========
+
+        >>> from sympy.polys.rings import ring
+        >>> from sympy.polys.domains import ZZ
+
+        >>> _, x, y, z = ring('x, y, z', ZZ)
+        >>> p1 = x**4 + 2*y
+        >>> p2 = y + z
+        >>> m = (1, 2, 3)
+        >>> p1 = p1._iadd_poly_monom(p2, (m, 3))
+        >>> p1
+        x**4 + 3*x*y**3*z**3 + 3*x*y**2*z**4 + 2*y
+
+        """
+        p1 = self
+        if p1 in p1.ring._gens_set:
+            p1 = p1.copy()
+        (m, c) = mc
+        get = p1.get
+        zero = p1.ring.domain.zero
+        monomial_mul = p1.ring.monomial_mul
+        for k, v in p2.items():
+            ka = monomial_mul(k, m)
+            coeff = get(ka, zero) + v*c
+            if coeff:
+                p1[ka] = coeff
+            else:
+                del p1[ka]
+        return p1
+
+    def degree(f, x=None):
+        """
+        The leading degree in ``x`` or the main variable.
+
+        Note that the degree of 0 is negative infinity (``float('-inf')``)
+
+        """
+        i = f.ring.index(x)
+
+        if not f:
+            return ninf
+        elif i < 0:
+            return 0
+        else:
+            return max(monom[i] for monom in f.itermonoms())
+
+    def degrees(f):
+        """
+        A tuple containing leading degrees in all variables.
+
+        Note that the degree of 0 is negative infinity (``float('-inf')``)
+
+        """
+        if not f:
+            return (ninf,)*f.ring.ngens
+        else:
+            return tuple(map(max, list(zip(*f.itermonoms()))))
+
+    def tail_degree(f, x=None):
+        """
+        The tail degree in ``x`` or the main variable.
+
+        Note that the degree of 0 is negative infinity (``float('-inf')``)
+
+        """
+        i = f.ring.index(x)
+
+        if not f:
+            return ninf
+        elif i < 0:
+            return 0
+        else:
+            return min(monom[i] for monom in f.itermonoms())
+
+    def tail_degrees(f):
+        """
+        A tuple containing tail degrees in all variables.
+
+        Note that the degree of 0 is negative infinity (``float('-inf')``)
+
+        """
+        if not f:
+            return (ninf,)*f.ring.ngens
+        else:
+            return tuple(map(min, list(zip(*f.itermonoms()))))
+
+    def leading_expv(self):
+        """Leading monomial tuple according to the monomial ordering.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.rings import ring
+        >>> from sympy.polys.domains import ZZ
+
+        >>> _, x, y, z = ring('x, y, z', ZZ)
+        >>> p = x**4 + x**3*y + x**2*z**2 + z**7
+        >>> p.leading_expv()
+        (4, 0, 0)
+
+        """
+        if self:
+            return self.ring.leading_expv(self)
+        else:
+            return None
+
+    def _get_coeff(self, expv):
+        return self.get(expv, self.ring.domain.zero)
+
+    def coeff(self, element):
+        """
+        Returns the coefficient that stands next to the given monomial.
+
+        Parameters
+        ==========
+
+        element : PolyElement (with ``is_monomial = True``) or 1
+
+        Examples
+        ========
+
+        >>> from sympy.polys.rings import ring
+        >>> from sympy.polys.domains import ZZ
+
+        >>> _, x, y, z = ring("x,y,z", ZZ)
+        >>> f = 3*x**2*y - x*y*z + 7*z**3 + 23
+
+        >>> f.coeff(x**2*y)
+        3
+        >>> f.coeff(x*y)
+        0
+        >>> f.coeff(1)
+        23
+
+        """
+        if element == 1:
+            return self._get_coeff(self.ring.zero_monom)
+        elif isinstance(element, self.ring.dtype):
+            terms = list(element.iterterms())
+            if len(terms) == 1:
+                monom, coeff = terms[0]
+                if coeff == self.ring.domain.one:
+                    return self._get_coeff(monom)
+
+        raise ValueError("expected a monomial, got %s" % element)
+
+    def const(self):
+        """Returns the constant coefficient. """
+        return self._get_coeff(self.ring.zero_monom)
+
+    @property
+    def LC(self):
+        return self._get_coeff(self.leading_expv())
+
+    @property
+    def LM(self):
+        expv = self.leading_expv()
+        if expv is None:
+            return self.ring.zero_monom
+        else:
+            return expv
+
+    def leading_monom(self):
+        """
+        Leading monomial as a polynomial element.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.rings import ring
+        >>> from sympy.polys.domains import ZZ
+
+        >>> _, x, y = ring('x, y', ZZ)
+        >>> (3*x*y + y**2).leading_monom()
+        x*y
+
+        """
+        p = self.ring.zero
+        expv = self.leading_expv()
+        if expv:
+            p[expv] = self.ring.domain.one
+        return p
+
+    @property
+    def LT(self):
+        expv = self.leading_expv()
+        if expv is None:
+            return (self.ring.zero_monom, self.ring.domain.zero)
+        else:
+            return (expv, self._get_coeff(expv))
+
+    def leading_term(self):
+        """Leading term as a polynomial element.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.rings import ring
+        >>> from sympy.polys.domains import ZZ
+
+        >>> _, x, y = ring('x, y', ZZ)
+        >>> (3*x*y + y**2).leading_term()
+        3*x*y
+
+        """
+        p = self.ring.zero
+        expv = self.leading_expv()
+        if expv is not None:
+            p[expv] = self[expv]
+        return p
+
+    def _sorted(self, seq, order):
+        if order is None:
+            order = self.ring.order
+        else:
+            order = OrderOpt.preprocess(order)
+
+        if order is lex:
+            return sorted(seq, key=lambda monom: monom[0], reverse=True)
+        else:
+            return sorted(seq, key=lambda monom: order(monom[0]), reverse=True)
+
+    def coeffs(self, order=None):
+        """Ordered list of polynomial coefficients.
+
+        Parameters
+        ==========
+
+        order : :class:`~.MonomialOrder` or coercible, optional
+
+        Examples
+        ========
+
+        >>> from sympy.polys.rings import ring
+        >>> from sympy.polys.domains import ZZ
+        >>> from sympy.polys.orderings import lex, grlex
+
+        >>> _, x, y = ring("x, y", ZZ, lex)
+        >>> f = x*y**7 + 2*x**2*y**3
+
+        >>> f.coeffs()
+        [2, 1]
+        >>> f.coeffs(grlex)
+        [1, 2]
+
+        """
+        return [ coeff for _, coeff in self.terms(order) ]
+
+    def monoms(self, order=None):
+        """Ordered list of polynomial monomials.
+
+        Parameters
+        ==========
+
+        order : :class:`~.MonomialOrder` or coercible, optional
+
+        Examples
+        ========
+
+        >>> from sympy.polys.rings import ring
+        >>> from sympy.polys.domains import ZZ
+        >>> from sympy.polys.orderings import lex, grlex
+
+        >>> _, x, y = ring("x, y", ZZ, lex)
+        >>> f = x*y**7 + 2*x**2*y**3
+
+        >>> f.monoms()
+        [(2, 3), (1, 7)]
+        >>> f.monoms(grlex)
+        [(1, 7), (2, 3)]
+
+        """
+        return [ monom for monom, _ in self.terms(order) ]
+
+    def terms(self, order=None):
+        """Ordered list of polynomial terms.
+
+        Parameters
+        ==========
+
+        order : :class:`~.MonomialOrder` or coercible, optional
+
+        Examples
+        ========
+
+        >>> from sympy.polys.rings import ring
+        >>> from sympy.polys.domains import ZZ
+        >>> from sympy.polys.orderings import lex, grlex
+
+        >>> _, x, y = ring("x, y", ZZ, lex)
+        >>> f = x*y**7 + 2*x**2*y**3
+
+        >>> f.terms()
+        [((2, 3), 2), ((1, 7), 1)]
+        >>> f.terms(grlex)
+        [((1, 7), 1), ((2, 3), 2)]
+
+        """
+        return self._sorted(list(self.items()), order)
+
+    def itercoeffs(self):
+        """Iterator over coefficients of a polynomial. """
+        return iter(self.values())
+
+    def itermonoms(self):
+        """Iterator over monomials of a polynomial. """
+        return iter(self.keys())
+
+    def iterterms(self):
+        """Iterator over terms of a polynomial. """
+        return iter(self.items())
+
+    def listcoeffs(self):
+        """Unordered list of polynomial coefficients. """
+        return list(self.values())
+
+    def listmonoms(self):
+        """Unordered list of polynomial monomials. """
+        return list(self.keys())
+
+    def listterms(self):
+        """Unordered list of polynomial terms. """
+        return list(self.items())
+
+    def imul_num(p, c):
+        """multiply inplace the polynomial p by an element in the
+        coefficient ring, provided p is not one of the generators;
+        else multiply not inplace
+
+        Examples
+        ========
+
+        >>> from sympy.polys.rings import ring
+        >>> from sympy.polys.domains import ZZ
+
+        >>> _, x, y = ring('x, y', ZZ)
+        >>> p = x + y**2
+        >>> p1 = p.imul_num(3)
+        >>> p1
+        3*x + 3*y**2
+        >>> p1 is p
+        True
+        >>> p = x
+        >>> p1 = p.imul_num(3)
+        >>> p1
+        3*x
+        >>> p1 is p
+        False
+
+        """
+        if p in p.ring._gens_set:
+            return p*c
+        if not c:
+            p.clear()
+            return
+        for exp in p:
+            p[exp] *= c
+        return p
+
+    def content(f):
+        """Returns GCD of polynomial's coefficients. """
+        domain = f.ring.domain
+        cont = domain.zero
+        gcd = domain.gcd
+
+        for coeff in f.itercoeffs():
+            cont = gcd(cont, coeff)
+
+        return cont
+
+    def primitive(f):
+        """Returns content and a primitive polynomial. """
+        cont = f.content()
+        return cont, f.quo_ground(cont)
+
+    def monic(f):
+        """Divides all coefficients by the leading coefficient. """
+        if not f:
+            return f
+        else:
+            return f.quo_ground(f.LC)
+
+    def mul_ground(f, x):
+        if not x:
+            return f.ring.zero
+
+        terms = [ (monom, coeff*x) for monom, coeff in f.iterterms() ]
+        return f.new(terms)
+
+    def mul_monom(f, monom):
+        monomial_mul = f.ring.monomial_mul
+        terms = [ (monomial_mul(f_monom, monom), f_coeff) for f_monom, f_coeff in f.items() ]
+        return f.new(terms)
+
+    def mul_term(f, term):
+        monom, coeff = term
+
+        if not f or not coeff:
+            return f.ring.zero
+        elif monom == f.ring.zero_monom:
+            return f.mul_ground(coeff)
+
+        monomial_mul = f.ring.monomial_mul
+        terms = [ (monomial_mul(f_monom, monom), f_coeff*coeff) for f_monom, f_coeff in f.items() ]
+        return f.new(terms)
+
+    def quo_ground(f, x):
+        domain = f.ring.domain
+
+        if not x:
+            raise ZeroDivisionError('polynomial division')
+        if not f or x == domain.one:
+            return f
+
+        if domain.is_Field:
+            quo = domain.quo
+            terms = [ (monom, quo(coeff, x)) for monom, coeff in f.iterterms() ]
+        else:
+            terms = [ (monom, coeff // x) for monom, coeff in f.iterterms() if not (coeff % x) ]
+
+        return f.new(terms)
+
+    def quo_term(f, term):
+        monom, coeff = term
+
+        if not coeff:
+            raise ZeroDivisionError("polynomial division")
+        elif not f:
+            return f.ring.zero
+        elif monom == f.ring.zero_monom:
+            return f.quo_ground(coeff)
+
+        term_div = f._term_div()
+
+        terms = [ term_div(t, term) for t in f.iterterms() ]
+        return f.new([ t for t in terms if t is not None ])
+
+    def trunc_ground(f, p):
+        if f.ring.domain.is_ZZ:
+            terms = []
+
+            for monom, coeff in f.iterterms():
+                coeff = coeff % p
+
+                if coeff > p // 2:
+                    coeff = coeff - p
+
+                terms.append((monom, coeff))
+        else:
+            terms = [ (monom, coeff % p) for monom, coeff in f.iterterms() ]
+
+        poly = f.new(terms)
+        poly.strip_zero()
+        return poly
+
+    rem_ground = trunc_ground
+
+    def extract_ground(self, g):
+        f = self
+        fc = f.content()
+        gc = g.content()
+
+        gcd = f.ring.domain.gcd(fc, gc)
+
+        f = f.quo_ground(gcd)
+        g = g.quo_ground(gcd)
+
+        return gcd, f, g
+
+    def _norm(f, norm_func):
+        if not f:
+            return f.ring.domain.zero
+        else:
+            ground_abs = f.ring.domain.abs
+            return norm_func([ ground_abs(coeff) for coeff in f.itercoeffs() ])
+
+    def max_norm(f):
+        return f._norm(max)
+
+    def l1_norm(f):
+        return f._norm(sum)
+
+    def deflate(f, *G):
+        ring = f.ring
+        polys = [f] + list(G)
+
+        J = [0]*ring.ngens
+
+        for p in polys:
+            for monom in p.itermonoms():
+                for i, m in enumerate(monom):
+                    J[i] = igcd(J[i], m)
+
+        for i, b in enumerate(J):
+            if not b:
+                J[i] = 1
+
+        J = tuple(J)
+
+        if all(b == 1 for b in J):
+            return J, polys
+
+        H = []
+
+        for p in polys:
+            h = ring.zero
+
+            for I, coeff in p.iterterms():
+                N = [ i // j for i, j in zip(I, J) ]
+                h[tuple(N)] = coeff
+
+            H.append(h)
+
+        return J, H
+
+    def inflate(f, J):
+        poly = f.ring.zero
+
+        for I, coeff in f.iterterms():
+            N = [ i*j for i, j in zip(I, J) ]
+            poly[tuple(N)] = coeff
+
+        return poly
+
+    def lcm(self, g):
+        f = self
+        domain = f.ring.domain
+
+        if not domain.is_Field:
+            fc, f = f.primitive()
+            gc, g = g.primitive()
+            c = domain.lcm(fc, gc)
+
+        h = (f*g).quo(f.gcd(g))
+
+        if not domain.is_Field:
+            return h.mul_ground(c)
+        else:
+            return h.monic()
+
+    def gcd(f, g):
+        return f.cofactors(g)[0]
+
+    def cofactors(f, g):
+        if not f and not g:
+            zero = f.ring.zero
+            return zero, zero, zero
+        elif not f:
+            h, cff, cfg = f._gcd_zero(g)
+            return h, cff, cfg
+        elif not g:
+            h, cfg, cff = g._gcd_zero(f)
+            return h, cff, cfg
+        elif len(f) == 1:
+            h, cff, cfg = f._gcd_monom(g)
+            return h, cff, cfg
+        elif len(g) == 1:
+            h, cfg, cff = g._gcd_monom(f)
+            return h, cff, cfg
+
+        J, (f, g) = f.deflate(g)
+        h, cff, cfg = f._gcd(g)
+
+        return (h.inflate(J), cff.inflate(J), cfg.inflate(J))
+
+    def _gcd_zero(f, g):
+        one, zero = f.ring.one, f.ring.zero
+        if g.is_nonnegative:
+            return g, zero, one
+        else:
+            return -g, zero, -one
+
+    def _gcd_monom(f, g):
+        ring = f.ring
+        ground_gcd = ring.domain.gcd
+        ground_quo = ring.domain.quo
+        monomial_gcd = ring.monomial_gcd
+        monomial_ldiv = ring.monomial_ldiv
+        mf, cf = list(f.iterterms())[0]
+        _mgcd, _cgcd = mf, cf
+        for mg, cg in g.iterterms():
+            _mgcd = monomial_gcd(_mgcd, mg)
+            _cgcd = ground_gcd(_cgcd, cg)
+        h = f.new([(_mgcd, _cgcd)])
+        cff = f.new([(monomial_ldiv(mf, _mgcd), ground_quo(cf, _cgcd))])
+        cfg = f.new([(monomial_ldiv(mg, _mgcd), ground_quo(cg, _cgcd)) for mg, cg in g.iterterms()])
+        return h, cff, cfg
+
+    def _gcd(f, g):
+        ring = f.ring
+
+        if ring.domain.is_QQ:
+            return f._gcd_QQ(g)
+        elif ring.domain.is_ZZ:
+            return f._gcd_ZZ(g)
+        else: # TODO: don't use dense representation (port PRS algorithms)
+            return ring.dmp_inner_gcd(f, g)
+
+    def _gcd_ZZ(f, g):
+        return heugcd(f, g)
+
+    def _gcd_QQ(self, g):
+        f = self
+        ring = f.ring
+        new_ring = ring.clone(domain=ring.domain.get_ring())
+
+        cf, f = f.clear_denoms()
+        cg, g = g.clear_denoms()
+
+        f = f.set_ring(new_ring)
+        g = g.set_ring(new_ring)
+
+        h, cff, cfg = f._gcd_ZZ(g)
+
+        h = h.set_ring(ring)
+        c, h = h.LC, h.monic()
+
+        cff = cff.set_ring(ring).mul_ground(ring.domain.quo(c, cf))
+        cfg = cfg.set_ring(ring).mul_ground(ring.domain.quo(c, cg))
+
+        return h, cff, cfg
+
+    def cancel(self, g):
+        """
+        Cancel common factors in a rational function ``f/g``.
+
+        Examples
+        ========
+
+        >>> from sympy.polys import ring, ZZ
+        >>> R, x,y = ring("x,y", ZZ)
+
+        >>> (2*x**2 - 2).cancel(x**2 - 2*x + 1)
+        (2*x + 2, x - 1)
+
+        """
+        f = self
+        ring = f.ring
+
+        if not f:
+            return f, ring.one
+
+        domain = ring.domain
+
+        if not (domain.is_Field and domain.has_assoc_Ring):
+            _, p, q = f.cofactors(g)
+        else:
+            new_ring = ring.clone(domain=domain.get_ring())
+
+            cq, f = f.clear_denoms()
+            cp, g = g.clear_denoms()
+
+            f = f.set_ring(new_ring)
+            g = g.set_ring(new_ring)
+
+            _, p, q = f.cofactors(g)
+            _, cp, cq = new_ring.domain.cofactors(cp, cq)
+
+            p = p.set_ring(ring)
+            q = q.set_ring(ring)
+
+            p = p.mul_ground(cp)
+            q = q.mul_ground(cq)
+
+        # Make canonical with respect to sign or quadrant in the case of ZZ_I
+        # or QQ_I. This ensures that the LC of the denominator is canonical by
+        # multiplying top and bottom by a unit of the ring.
+        u = q.canonical_unit()
+        if u == domain.one:
+            p, q = p, q
+        elif u == -domain.one:
+            p, q = -p, -q
+        else:
+            p = p.mul_ground(u)
+            q = q.mul_ground(u)
+
+        return p, q
+
+    def canonical_unit(f):
+        domain = f.ring.domain
+        return domain.canonical_unit(f.LC)
+
+    def diff(f, x):
+        """Computes partial derivative in ``x``.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.rings import ring
+        >>> from sympy.polys.domains import ZZ
+
+        >>> _, x, y = ring("x,y", ZZ)
+        >>> p = x + x**2*y**3
+        >>> p.diff(x)
+        2*x*y**3 + 1
+
+        """
+        ring = f.ring
+        i = ring.index(x)
+        m = ring.monomial_basis(i)
+        g = ring.zero
+        for expv, coeff in f.iterterms():
+            if expv[i]:
+                e = ring.monomial_ldiv(expv, m)
+                g[e] = ring.domain_new(coeff*expv[i])
+        return g
+
+    def __call__(f, *values):
+        if 0 < len(values) <= f.ring.ngens:
+            return f.evaluate(list(zip(f.ring.gens, values)))
+        else:
+            raise ValueError("expected at least 1 and at most %s values, got %s" % (f.ring.ngens, len(values)))
+
+    def evaluate(self, x, a=None):
+        f = self
+
+        if isinstance(x, list) and a is None:
+            (X, a), x = x[0], x[1:]
+            f = f.evaluate(X, a)
+
+            if not x:
+                return f
+            else:
+                x = [ (Y.drop(X), a) for (Y, a) in x ]
+                return f.evaluate(x)
+
+        ring = f.ring
+        i = ring.index(x)
+        a = ring.domain.convert(a)
+
+        if ring.ngens == 1:
+            result = ring.domain.zero
+
+            for (n,), coeff in f.iterterms():
+                result += coeff*a**n
+
+            return result
+        else:
+            poly = ring.drop(x).zero
+
+            for monom, coeff in f.iterterms():
+                n, monom = monom[i], monom[:i] + monom[i+1:]
+                coeff = coeff*a**n
+
+                if monom in poly:
+                    coeff = coeff + poly[monom]
+
+                    if coeff:
+                        poly[monom] = coeff
+                    else:
+                        del poly[monom]
+                else:
+                    if coeff:
+                        poly[monom] = coeff
+
+            return poly
+
+    def subs(self, x, a=None):
+        f = self
+
+        if isinstance(x, list) and a is None:
+            for X, a in x:
+                f = f.subs(X, a)
+            return f
+
+        ring = f.ring
+        i = ring.index(x)
+        a = ring.domain.convert(a)
+
+        if ring.ngens == 1:
+            result = ring.domain.zero
+
+            for (n,), coeff in f.iterterms():
+                result += coeff*a**n
+
+            return ring.ground_new(result)
+        else:
+            poly = ring.zero
+
+            for monom, coeff in f.iterterms():
+                n, monom = monom[i], monom[:i] + (0,) + monom[i+1:]
+                coeff = coeff*a**n
+
+                if monom in poly:
+                    coeff = coeff + poly[monom]
+
+                    if coeff:
+                        poly[monom] = coeff
+                    else:
+                        del poly[monom]
+                else:
+                    if coeff:
+                        poly[monom] = coeff
+
+            return poly
+
+    def symmetrize(self):
+        r"""
+        Rewrite *self* in terms of elementary symmetric polynomials.
+
+        Explanation
+        ===========
+
+        If this :py:class:`~.PolyElement` belongs to a ring of $n$ variables,
+        we can try to write it as a function of the elementary symmetric
+        polynomials on $n$ variables. We compute a symmetric part, and a
+        remainder for any part we were not able to symmetrize.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.rings import ring
+        >>> from sympy.polys.domains import ZZ
+        >>> R, x, y = ring("x,y", ZZ)
+
+        >>> f = x**2 + y**2
+        >>> f.symmetrize()
+        (x**2 - 2*y, 0, [(x, x + y), (y, x*y)])
+
+        >>> f = x**2 - y**2
+        >>> f.symmetrize()
+        (x**2 - 2*y, -2*y**2, [(x, x + y), (y, x*y)])
+
+        Returns
+        =======
+
+        Triple ``(p, r, m)``
+            ``p`` is a :py:class:`~.PolyElement` that represents our attempt
+            to express *self* as a function of elementary symmetric
+            polynomials. Each variable in ``p`` stands for one of the
+            elementary symmetric polynomials. The correspondence is given
+            by ``m``.
+
+            ``r`` is the remainder.
+
+            ``m`` is a list of pairs, giving the mapping from variables in
+            ``p`` to elementary symmetric polynomials.
+
+            The triple satisfies the equation ``p.compose(m) + r == self``.
+            If the remainder ``r`` is zero, *self* is symmetric. If it is
+            nonzero, we were not able to represent *self* as symmetric.
+
+        See Also
+        ========
+
+        sympy.polys.polyfuncs.symmetrize
+
+        References
+        ==========
+
+        .. [1] Lauer, E. Algorithms for symmetrical polynomials, Proc. 1976
+            ACM Symp. on Symbolic and Algebraic Computing, NY 242-247.
+            https://dl.acm.org/doi/pdf/10.1145/800205.806342
+
+        """
+        f = self.copy()
+        ring = f.ring
+        n = ring.ngens
+
+        if not n:
+            return f, ring.zero, []
+
+        polys = [ring.symmetric_poly(i+1) for i in range(n)]
+
+        poly_powers = {}
+        def get_poly_power(i, n):
+            if (i, n) not in poly_powers:
+                poly_powers[(i, n)] = polys[i]**n
+            return poly_powers[(i, n)]
+
+        indices = list(range(n - 1))
+        weights = list(range(n, 0, -1))
+
+        symmetric = ring.zero
+
+        while f:
+            _height, _monom, _coeff = -1, None, None
+
+            for i, (monom, coeff) in enumerate(f.terms()):
+                if all(monom[i] >= monom[i + 1] for i in indices):
+                    height = max(n*m for n, m in zip(weights, monom))
+
+                    if height > _height:
+                        _height, _monom, _coeff = height, monom, coeff
+
+            if _height != -1:
+                monom, coeff = _monom, _coeff
+            else:
+                break
+
+            exponents = []
+            for m1, m2 in zip(monom, monom[1:] + (0,)):
+                exponents.append(m1 - m2)
+
+            symmetric += ring.term_new(tuple(exponents), coeff)
+
+            product = coeff
+            for i, n in enumerate(exponents):
+                product *= get_poly_power(i, n)
+            f -= product
+
+        mapping = list(zip(ring.gens, polys))
+
+        return symmetric, f, mapping
+
+    def compose(f, x, a=None):
+        ring = f.ring
+        poly = ring.zero
+        gens_map = dict(zip(ring.gens, range(ring.ngens)))
+
+        if a is not None:
+            replacements = [(x, a)]
+        else:
+            if isinstance(x, list):
+                replacements = list(x)
+            elif isinstance(x, dict):
+                replacements = sorted(x.items(), key=lambda k: gens_map[k[0]])
+            else:
+                raise ValueError("expected a generator, value pair a sequence of such pairs")
+
+        for k, (x, g) in enumerate(replacements):
+            replacements[k] = (gens_map[x], ring.ring_new(g))
+
+        for monom, coeff in f.iterterms():
+            monom = list(monom)
+            subpoly = ring.one
+
+            for i, g in replacements:
+                n, monom[i] = monom[i], 0
+                if n:
+                    subpoly *= g**n
+
+            subpoly = subpoly.mul_term((tuple(monom), coeff))
+            poly += subpoly
+
+        return poly
+
+    def coeff_wrt(self, x, deg):
+        """
+        Coefficient of ``self`` with respect to ``x**deg``.
+
+        Treating ``self`` as a univariate polynomial in ``x`` this finds the
+        coefficient of ``x**deg`` as a polynomial in the other generators.
+
+        Parameters
+        ==========
+
+        x : generator or generator index
+            The generator or generator index to compute the expression for.
+        deg : int
+            The degree of the monomial to compute the expression for.
+
+        Returns
+        =======
+
+        :py:class:`~.PolyElement`
+            The coefficient of ``x**deg`` as a polynomial in the same ring.
+
+        Examples
+        ========
+
+        >>> from sympy.polys import ring, ZZ
+        >>> R, x, y, z = ring("x, y, z", ZZ)
+
+        >>> p = 2*x**4 + 3*y**4 + 10*z**2 + 10*x*z**2
+        >>> deg = 2
+        >>> p.coeff_wrt(2, deg) # Using the generator index
+        10*x + 10
+        >>> p.coeff_wrt(z, deg) # Using the generator
+        10*x + 10
+        >>> p.coeff(z**2) # shows the difference between coeff and coeff_wrt
+        10
+
+        See Also
+        ========
+
+        coeff, coeffs
+
+        """
+        p = self
+        i = p.ring.index(x)
+        terms = [(m, c) for m, c in p.iterterms() if m[i] == deg]
+
+        if not terms:
+            return p.ring.zero
+
+        monoms, coeffs = zip(*terms)
+        monoms = [m[:i] + (0,) + m[i + 1:] for m in monoms]
+        return p.ring.from_dict(dict(zip(monoms, coeffs)))
+
+    def prem(self, g, x=None):
+        """
+        Pseudo-remainder of the polynomial ``self`` with respect to ``g``.
+
+        The pseudo-quotient ``q`` and pseudo-remainder ``r`` with respect to
+        ``z`` when dividing ``f`` by ``g`` satisfy ``m*f = g*q + r``,
+        where ``deg(r,z) < deg(g,z)`` and
+        ``m = LC(g,z)**(deg(f,z) - deg(g,z)+1)``.
+
+        See :meth:`pdiv` for explanation of pseudo-division.
+
+
+        Parameters
+        ==========
+
+        g : :py:class:`~.PolyElement`
+            The polynomial to divide ``self`` by.
+        x : generator or generator index, optional
+            The main variable of the polynomials and default is first generator.
+
+        Returns
+        =======
+
+        :py:class:`~.PolyElement`
+            The pseudo-remainder polynomial.
+
+        Raises
+        ======
+
+        ZeroDivisionError : If ``g`` is the zero polynomial.
+
+        Examples
+        ========
+
+        >>> from sympy.polys import ring, ZZ
+        >>> R, x, y = ring("x, y", ZZ)
+
+        >>> f = x**2 + x*y
+        >>> g = 2*x + 2
+        >>> f.prem(g) # first generator is chosen by default if it is not given
+        -4*y + 4
+        >>> f.rem(g) # shows the differnce between prem and rem
+        x**2 + x*y
+        >>> f.prem(g, y) # generator is given
+        0
+        >>> f.prem(g, 1) # generator index is given
+        0
+
+        See Also
+        ========
+
+        pdiv, pquo, pexquo, sympy.polys.domains.ring.Ring.rem
+
+        """
+        f = self
+        x = f.ring.index(x)
+        df = f.degree(x)
+        dg = g.degree(x)
+
+        if dg < 0:
+            raise ZeroDivisionError('polynomial division')
+
+        r, dr = f, df
+
+        if df < dg:
+            return r
+
+        N = df - dg + 1
+
+        lc_g = g.coeff_wrt(x, dg)
+
+        xp = f.ring.gens[x]
+
+        while True:
+
+            lc_r = r.coeff_wrt(x, dr)
+            j, N = dr - dg, N - 1
+
+            R = r * lc_g
+            G = g * lc_r * xp**j
+            r = R - G
+
+            dr = r.degree(x)
+
+            if dr < dg:
+                break
+
+        c = lc_g ** N
+
+        return r * c
+
+    def pdiv(self, g, x=None):
+        """
+        Computes the pseudo-division of the polynomial ``self`` with respect to ``g``.
+
+        The pseudo-division algorithm is used to find the pseudo-quotient ``q``
+        and pseudo-remainder ``r`` such that ``m*f = g*q + r``, where ``m``
+        represents the multiplier and ``f`` is the dividend polynomial.
+
+        The pseudo-quotient ``q`` and pseudo-remainder ``r`` are polynomials in
+        the variable ``x``, with the degree of ``r`` with respect to ``x``
+        being strictly less than the degree of ``g`` with respect to ``x``.
+
+        The multiplier ``m`` is defined as
+        ``LC(g, x) ^ (deg(f, x) - deg(g, x) + 1)``,
+        where ``LC(g, x)`` represents the leading coefficient of ``g``.
+
+        It is important to note that in the context of the ``prem`` method,
+        multivariate polynomials in a ring, such as ``R[x,y,z]``, are treated
+        as univariate polynomials with coefficients that are polynomials,
+        such as ``R[x,y][z]``. When dividing ``f`` by ``g`` with respect to the
+        variable ``z``, the pseudo-quotient ``q`` and pseudo-remainder ``r``
+        satisfy ``m*f = g*q + r``, where ``deg(r, z) < deg(g, z)``
+        and ``m = LC(g, z)^(deg(f, z) - deg(g, z) + 1)``.
+
+        In this function, the pseudo-remainder ``r`` can be obtained using the
+        ``prem`` method, the pseudo-quotient ``q`` can
+        be obtained using the ``pquo`` method, and
+        the function ``pdiv`` itself returns a tuple ``(q, r)``.
+
+
+        Parameters
+        ==========
+
+        g : :py:class:`~.PolyElement`
+            The polynomial to divide ``self`` by.
+        x : generator or generator index, optional
+            The main variable of the polynomials and default is first generator.
+
+        Returns
+        =======
+
+        :py:class:`~.PolyElement`
+            The pseudo-division polynomial (tuple of ``q`` and ``r``).
+
+        Raises
+        ======
+
+        ZeroDivisionError : If ``g`` is the zero polynomial.
+
+        Examples
+        ========
+
+        >>> from sympy.polys import ring, ZZ
+        >>> R, x, y = ring("x, y", ZZ)
+
+        >>> f = x**2 + x*y
+        >>> g = 2*x + 2
+        >>> f.pdiv(g) # first generator is chosen by default if it is not given
+        (2*x + 2*y - 2, -4*y + 4)
+        >>> f.div(g) # shows the difference between pdiv and div
+        (0, x**2 + x*y)
+        >>> f.pdiv(g, y) # generator is given
+        (2*x**3 + 2*x**2*y + 6*x**2 + 2*x*y + 8*x + 4, 0)
+        >>> f.pdiv(g, 1) # generator index is given
+        (2*x**3 + 2*x**2*y + 6*x**2 + 2*x*y + 8*x + 4, 0)
+
+        See Also
+        ========
+
+        prem
+            Computes only the pseudo-remainder more efficiently than
+            `f.pdiv(g)[1]`.
+        pquo
+            Returns only the pseudo-quotient.
+        pexquo
+            Returns only an exact pseudo-quotient having no remainder.
+        div
+            Returns quotient and remainder of f and g polynomials.
+
+        """
+        f = self
+        x = f.ring.index(x)
+
+        df = f.degree(x)
+        dg = g.degree(x)
+
+        if dg < 0:
+            raise ZeroDivisionError("polynomial division")
+
+        q, r, dr = x, f, df
+
+        if df < dg:
+            return q, r
+
+        N = df - dg + 1
+        lc_g = g.coeff_wrt(x, dg)
+
+        xp = f.ring.gens[x]
+
+        while True:
+
+            lc_r = r.coeff_wrt(x, dr)
+            j, N = dr - dg, N - 1
+
+            Q = q * lc_g
+
+            q = Q + (lc_r)*xp**j
+
+            R = r * lc_g
+
+            G = g * lc_r * xp**j
+
+            r = R - G
+
+            dr = r.degree(x)
+
+            if dr < dg:
+                break
+
+        c = lc_g**N
+
+        q = q * c
+        r = r * c
+
+        return q, r
+
+    def pquo(self, g, x=None):
+        """
+        Polynomial pseudo-quotient in multivariate polynomial ring.
+
+        Examples
+        ========
+        >>> from sympy.polys import ring, ZZ
+        >>> R, x,y = ring("x,y", ZZ)
+
+        >>> f = x**2 + x*y
+        >>> g = 2*x + 2*y
+        >>> h = 2*x + 2
+        >>> f.pquo(g)
+        2*x
+        >>> f.quo(g) # shows the difference between pquo and quo
+        0
+        >>> f.pquo(h)
+        2*x + 2*y - 2
+        >>> f.quo(h) # shows the difference between pquo and quo
+        0
+
+        See Also
+        ========
+
+        prem, pdiv, pexquo, sympy.polys.domains.ring.Ring.quo
+
+        """
+        f = self
+        return f.pdiv(g, x)[0]
+
+    def pexquo(self, g, x=None):
+        """
+        Polynomial exact pseudo-quotient in multivariate polynomial ring.
+
+        Examples
+        ========
+        >>> from sympy.polys import ring, ZZ
+        >>> R, x,y = ring("x,y", ZZ)
+
+        >>> f = x**2 + x*y
+        >>> g = 2*x + 2*y
+        >>> h = 2*x + 2
+        >>> f.pexquo(g)
+        2*x
+        >>> f.exquo(g) # shows the differnce between pexquo and exquo
+        Traceback (most recent call last):
+        ...
+        ExactQuotientFailed: 2*x + 2*y does not divide x**2 + x*y
+        >>> f.pexquo(h)
+        Traceback (most recent call last):
+        ...
+        ExactQuotientFailed: 2*x + 2 does not divide x**2 + x*y
+
+        See Also
+        ========
+
+        prem, pdiv, pquo, sympy.polys.domains.ring.Ring.exquo
+
+        """
+        f = self
+        q, r = f.pdiv(g, x)
+
+        if r.is_zero:
+            return q
+        else:
+            raise ExactQuotientFailed(f, g)
+
+    def subresultants(self, g, x=None):
+        """
+        Computes the subresultant PRS of two polynomials ``self`` and ``g``.
+
+        Parameters
+        ==========
+
+        g : :py:class:`~.PolyElement`
+            The second polynomial.
+        x : generator or generator index
+            The variable with respect to which the subresultant sequence is computed.
+
+        Returns
+        =======
+
+        R : list
+            Returns a list polynomials representing the subresultant PRS.
+
+        Examples
+        ========
+
+        >>> from sympy.polys import ring, ZZ
+        >>> R, x, y = ring("x, y", ZZ)
+
+        >>> f = x**2*y + x*y
+        >>> g = x + y
+        >>> f.subresultants(g) # first generator is chosen by default if not given
+        [x**2*y + x*y, x + y, y**3 - y**2]
+        >>> f.subresultants(g, 0) # generator index is given
+        [x**2*y + x*y, x + y, y**3 - y**2]
+        >>> f.subresultants(g, y) # generator is given
+        [x**2*y + x*y, x + y, x**3 + x**2]
+
+        """
+        f = self
+        x = f.ring.index(x)
+        n = f.degree(x)
+        m = g.degree(x)
+
+        if n < m:
+            f, g = g, f
+            n, m = m, n
+
+        if f == 0:
+            return [0, 0]
+
+        if g == 0:
+            return [f, 1]
+
+        R = [f, g]
+
+        d = n - m
+        b = (-1) ** (d + 1)
+
+        # Compute the pseudo-remainder for f and g
+        h = f.prem(g, x)
+        h = h * b
+
+        # Compute the coefficient of g with respect to x**m
+        lc = g.coeff_wrt(x, m)
+
+        c = lc ** d
+
+        S = [1, c]
+
+        c = -c
+
+        while h:
+            k = h.degree(x)
+
+            R.append(h)
+            f, g, m, d = g, h, k, m - k
+
+            b = -lc * c ** d
+            h = f.prem(g, x)
+            h = h.exquo(b)
+
+            lc = g.coeff_wrt(x, k)
+
+            if d > 1:
+                p = (-lc) ** d
+                q = c ** (d - 1)
+                c = p.exquo(q)
+            else:
+                c = -lc
+
+            S.append(-c)
+
+        return R
+
+    # TODO: following methods should point to polynomial
+    # representation independent algorithm implementations.
+
+    def half_gcdex(f, g):
+        return f.ring.dmp_half_gcdex(f, g)
+
+    def gcdex(f, g):
+        return f.ring.dmp_gcdex(f, g)
+
+    def resultant(f, g):
+        return f.ring.dmp_resultant(f, g)
+
+    def discriminant(f):
+        return f.ring.dmp_discriminant(f)
+
+    def decompose(f):
+        if f.ring.is_univariate:
+            return f.ring.dup_decompose(f)
+        else:
+            raise MultivariatePolynomialError("polynomial decomposition")
+
+    def shift(f, a):
+        if f.ring.is_univariate:
+            return f.ring.dup_shift(f, a)
+        else:
+            raise MultivariatePolynomialError("shift: use shift_list instead")
+
+    def shift_list(f, a):
+        return f.ring.dmp_shift(f, a)
+
+    def sturm(f):
+        if f.ring.is_univariate:
+            return f.ring.dup_sturm(f)
+        else:
+            raise MultivariatePolynomialError("sturm sequence")
+
+    def gff_list(f):
+        return f.ring.dmp_gff_list(f)
+
+    def norm(f):
+        return f.ring.dmp_norm(f)
+
+    def sqf_norm(f):
+        return f.ring.dmp_sqf_norm(f)
+
+    def sqf_part(f):
+        return f.ring.dmp_sqf_part(f)
+
+    def sqf_list(f, all=False):
+        return f.ring.dmp_sqf_list(f, all=all)
+
+    def factor_list(f):
+        return f.ring.dmp_factor_list(f)
diff --git a/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/subresultants_qq_zz.py b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/subresultants_qq_zz.py
new file mode 100644
index 0000000000000000000000000000000000000000..d681d44efeb06f5e3381f8d03840e7a925dd67d4
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/sympy/polys/subresultants_qq_zz.py
@@ -0,0 +1,2558 @@
+"""
+This module contains functions for the computation
+of Euclidean, (generalized) Sturmian, (modified) subresultant
+polynomial remainder sequences (prs's) of two polynomials;
+included are also three functions for the computation of the
+resultant of two polynomials.
+
+Except for the function res_z(), which computes the resultant
+of two polynomials, the pseudo-remainder function prem()
+of sympy is _not_ used by any of the functions in the module.
+
+Instead of prem() we use the function
+
+rem_z().
+
+Included is also the function quo_z().
+
+An explanation of why we avoid prem() can be found in the
+references stated in the docstring of rem_z().
+
+1. Theoretical background:
+==========================
+Consider the polynomials f, g in Z[x] of degrees deg(f) = n and
+deg(g) = m with n >= m.
+
+Definition 1:
+=============
+The sign sequence of a polynomial remainder sequence (prs) is the
+sequence of signs of the leading coefficients of its polynomials.
+
+Sign sequences can be computed with the function:
+
+sign_seq(poly_seq, x)
+
+Definition 2:
+=============
+A polynomial remainder sequence (prs) is called complete if the
+degree difference between any two consecutive polynomials is 1;
+otherwise, it called incomplete.
+
+It is understood that f, g belong to the sequences mentioned in
+the two definitions above.
+
+1A. Euclidean and subresultant prs's:
+=====================================
+The subresultant prs of f, g is a sequence of polynomials in Z[x]
+analogous to the Euclidean prs, the sequence obtained by applying
+on f, g Euclid's algorithm for polynomial greatest common divisors
+(gcd) in Q[x].
+
+The subresultant prs differs from the Euclidean prs in that the
+coefficients of each polynomial in the former sequence are determinants
+--- also referred to as subresultants --- of appropriately selected
+sub-matrices of sylvester1(f, g, x), Sylvester's matrix of 1840 of
+dimensions (n + m) * (n + m).
+
+Recall that the determinant of sylvester1(f, g, x) itself is
+called the resultant of f, g and serves as a criterion of whether
+the two polynomials have common roots or not.
+
+In SymPy the resultant is computed with the function
+resultant(f, g, x). This function does _not_ evaluate the
+determinant of sylvester(f, g, x, 1); instead, it returns
+the last member of the subresultant prs of f, g, multiplied
+(if needed) by an appropriate power of -1; see the caveat below.
+
+In this module we use three functions to compute the
+resultant of f, g:
+a) res(f, g, x) computes the resultant by evaluating
+the determinant of sylvester(f, g, x, 1);
+b) res_q(f, g, x) computes the resultant recursively, by
+performing polynomial divisions in Q[x] with the function rem();
+c) res_z(f, g, x) computes the resultant recursively, by
+performing polynomial divisions in Z[x] with the function prem().
+
+Caveat: If Df = degree(f, x) and Dg = degree(g, x), then:
+
+resultant(f, g, x) = (-1)**(Df*Dg) * resultant(g, f, x).
+
+For complete prs's the sign sequence of the Euclidean prs of f, g
+is identical to the sign sequence of the subresultant prs of f, g
+and the coefficients of one sequence  are easily computed from the
+coefficients of the  other.
+
+For incomplete prs's the polynomials in the subresultant prs, generally
+differ in sign from those of the Euclidean prs, and --- unlike the
+case of complete prs's --- it is not at all obvious how to compute
+the coefficients of one sequence from the coefficients of the  other.
+
+1B. Sturmian and modified subresultant prs's:
+=============================================
+For the same polynomials f, g in Z[x] mentioned above, their ``modified''
+subresultant prs is a sequence of polynomials similar to the Sturmian
+prs, the sequence obtained by applying in Q[x] Sturm's algorithm on f, g.
+
+The two sequences differ in that the coefficients of each polynomial
+in the modified subresultant prs are the determinants --- also referred
+to as modified subresultants --- of appropriately selected  sub-matrices
+of sylvester2(f, g, x), Sylvester's matrix of 1853 of dimensions 2n x 2n.
+
+The determinant of sylvester2 itself is called the modified resultant
+of f, g and it also can serve as a criterion of whether the two
+polynomials have common roots or not.
+
+For complete prs's the  sign sequence of the Sturmian prs of f, g is
+identical to the sign sequence of the modified subresultant prs of
+f, g and the coefficients of one sequence  are easily computed from
+the coefficients of the other.
+
+For incomplete prs's the polynomials in the modified subresultant prs,
+generally differ in sign from those of the Sturmian prs, and --- unlike
+the case of complete prs's --- it is not at all obvious how to compute
+the coefficients of one sequence from the coefficients of the  other.
+
+As Sylvester pointed out, the coefficients of the polynomial remainders
+obtained as (modified) subresultants are the smallest possible without
+introducing rationals and without computing (integer) greatest common
+divisors.
+
+1C. On terminology:
+===================
+Whence the terminology? Well generalized Sturmian prs's are
+``modifications'' of Euclidean prs's; the hint came from the title
+of the Pell-Gordon paper of 1917.
+
+In the literature one also encounters the name ``non signed'' and
+``signed'' prs for Euclidean and Sturmian prs respectively.
+
+Likewise ``non signed'' and ``signed'' subresultant prs for
+subresultant and modified subresultant prs respectively.
+
+2. Functions in the module:
+===========================
+No function utilizes SymPy's function prem().
+
+2A. Matrices:
+=============
+The functions sylvester(f, g, x, method=1) and
+sylvester(f, g, x, method=2) compute either Sylvester matrix.
+They can be used to compute (modified) subresultant prs's by
+direct determinant evaluation.
+
+The function bezout(f, g, x, method='prs') provides a matrix of
+smaller dimensions than either Sylvester matrix. It is the function
+of choice for computing (modified) subresultant prs's by direct
+determinant evaluation.
+
+sylvester(f, g, x, method=1)
+sylvester(f, g, x, method=2)
+bezout(f, g, x, method='prs')
+
+The following identity holds:
+
+bezout(f, g, x, method='prs') =
+backward_eye(deg(f))*bezout(f, g, x, method='bz')*backward_eye(deg(f))
+
+2B. Subresultant and modified subresultant prs's by
+===================================================
+determinant evaluations:
+=======================
+We use the Sylvester matrices of 1840 and 1853 to
+compute, respectively, subresultant and modified
+subresultant polynomial remainder sequences. However,
+for large matrices this approach takes a lot of time.
+
+Instead of utilizing the Sylvester matrices, we can
+employ the Bezout matrix which is of smaller dimensions.
+
+subresultants_sylv(f, g, x)
+modified_subresultants_sylv(f, g, x)
+subresultants_bezout(f, g, x)
+modified_subresultants_bezout(f, g, x)
+
+2C. Subresultant prs's by ONE determinant evaluation:
+=====================================================
+All three functions in this section evaluate one determinant
+per remainder polynomial; this is the determinant of an
+appropriately selected sub-matrix of sylvester1(f, g, x),
+Sylvester's matrix of 1840.
+
+To compute the remainder polynomials the function
+subresultants_rem(f, g, x) employs rem(f, g, x).
+By contrast, the other two functions implement Van Vleck's ideas
+of 1900 and compute the remainder polynomials by trinagularizing
+sylvester2(f, g, x), Sylvester's matrix of 1853.
+
+
+subresultants_rem(f, g, x)
+subresultants_vv(f, g, x)
+subresultants_vv_2(f, g, x).
+
+2E. Euclidean, Sturmian prs's in Q[x]:
+======================================
+euclid_q(f, g, x)
+sturm_q(f, g, x)
+
+2F. Euclidean, Sturmian and (modified) subresultant prs's P-G:
+==============================================================
+All functions in this section are based on the Pell-Gordon (P-G)
+theorem of 1917.
+Computations are done in Q[x], employing the function rem(f, g, x)
+for the computation of the remainder polynomials.
+
+euclid_pg(f, g, x)
+sturm pg(f, g, x)
+subresultants_pg(f, g, x)
+modified_subresultants_pg(f, g, x)
+
+2G. Euclidean, Sturmian and (modified) subresultant prs's A-M-V:
+================================================================
+All functions in this section are based on the Akritas-Malaschonok-
+Vigklas (A-M-V) theorem of 2015.
+Computations are done in Z[x], employing the function rem_z(f, g, x)
+for the computation of the remainder polynomials.
+
+euclid_amv(f, g, x)
+sturm_amv(f, g, x)
+subresultants_amv(f, g, x)
+modified_subresultants_amv(f, g, x)
+
+2Ga. Exception:
+===============
+subresultants_amv_q(f, g, x)
+
+This function employs rem(f, g, x) for the computation of
+the remainder polynomials, despite the fact that it implements
+the A-M-V Theorem.
+
+It is included in our module in order to show that theorems P-G
+and A-M-V can be implemented utilizing either the function
+rem(f, g, x) or the function rem_z(f, g, x).
+
+For clearly historical reasons --- since the Collins-Brown-Traub
+coefficients-reduction factor beta_i was not available in 1917 ---
+we have implemented the Pell-Gordon theorem with the function
+rem(f, g, x) and the A-M-V Theorem  with the function rem_z(f, g, x).
+
+2H. Resultants:
+===============
+res(f, g, x)
+res_q(f, g, x)
+res_z(f, g, x)
+"""
+
+
+from sympy.concrete.summations import summation
+from sympy.core.function import expand
+from sympy.core.numbers import nan
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy as var
+from sympy.functions.elementary.complexes import Abs, sign
+from sympy.functions.elementary.integers import floor
+from sympy.matrices.dense import eye, Matrix, zeros
+from sympy.printing.pretty.pretty import pretty_print as pprint
+from sympy.simplify.simplify import simplify
+from sympy.polys.domains import QQ
+from sympy.polys.polytools import degree, LC, Poly, pquo, quo, prem, rem
+from sympy.polys.polyerrors import PolynomialError
+
+
+def sylvester(f, g, x, method = 1):
+    '''
+      The input polynomials f, g are in Z[x] or in Q[x]. Let m = degree(f, x),
+      n = degree(g, x) and mx = max(m, n).
+
+      a. If method = 1 (default), computes sylvester1, Sylvester's matrix of 1840
+          of dimension (m + n) x (m + n). The determinants of properly chosen
+          submatrices of this matrix (a.k.a. subresultants) can be
+          used to compute the coefficients of the Euclidean PRS of f, g.
+
+      b. If method = 2, computes sylvester2, Sylvester's matrix of 1853
+          of dimension (2*mx) x (2*mx). The determinants of properly chosen
+          submatrices of this matrix (a.k.a. ``modified'' subresultants) can be
+          used to compute the coefficients of the Sturmian PRS of f, g.
+
+      Applications of these Matrices can be found in the references below.
+      Especially, for applications of sylvester2, see the first reference!!
+
+      References
+      ==========
+      1. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``On a Theorem
+      by Van Vleck Regarding Sturm Sequences. Serdica Journal of Computing,
+      Vol. 7, No 4, 101-134, 2013.
+
+      2. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``Sturm Sequences
+      and Modified Subresultant Polynomial Remainder Sequences.''
+      Serdica Journal of Computing, Vol. 8, No 1, 29-46, 2014.
+
+    '''
+    # obtain degrees of polys
+    m, n = degree( Poly(f, x), x), degree( Poly(g, x), x)
+
+    # Special cases:
+    # A:: case m = n < 0 (i.e. both polys are 0)
+    if m == n and n < 0:
+        return Matrix([])
+
+    # B:: case m = n = 0  (i.e. both polys are constants)
+    if m == n and n == 0:
+        return Matrix([])
+
+    # C:: m == 0 and n < 0 or m < 0 and n == 0
+    # (i.e. one poly is constant and the other is 0)
+    if m == 0 and n < 0:
+        return Matrix([])
+    elif m < 0 and n == 0:
+        return Matrix([])
+
+    # D:: m >= 1 and n < 0 or m < 0 and n >=1
+    # (i.e. one poly is of degree >=1 and the other is 0)
+    if m >= 1 and n < 0:
+        return Matrix([0])
+    elif m < 0 and n >= 1:
+        return Matrix([0])
+
+    fp = Poly(f, x).all_coeffs()
+    gp = Poly(g, x).all_coeffs()
+
+    # Sylvester's matrix of 1840 (default; a.k.a. sylvester1)
+    if method <= 1:
+        M = zeros(m + n)
+        k = 0
+        for i in range(n):
+            j = k
+            for coeff in fp:
+                M[i, j] = coeff
+                j = j + 1
+            k = k + 1
+        k = 0
+        for i in range(n, m + n):
+            j = k
+            for coeff in gp:
+                M[i, j] = coeff
+                j = j + 1
+            k = k + 1
+        return M
+
+    # Sylvester's matrix of 1853 (a.k.a sylvester2)
+    if method >= 2:
+        if len(fp) < len(gp):
+            h = []
+            for i in range(len(gp) - len(fp)):
+                h.append(0)
+            fp[ : 0] = h
+        else:
+            h = []
+            for i in range(len(fp) - len(gp)):
+                h.append(0)
+            gp[ : 0] = h
+        mx = max(m, n)
+        dim = 2*mx
+        M = zeros( dim )
+        k = 0
+        for i in range( mx ):
+            j = k
+            for coeff in fp:
+                M[2*i, j] = coeff
+                j = j + 1
+            j = k
+            for coeff in gp:
+                M[2*i + 1, j] = coeff
+                j = j + 1
+            k = k + 1
+        return M
+
+def process_matrix_output(poly_seq, x):
+    """
+    poly_seq is a polynomial remainder sequence computed either by
+    (modified_)subresultants_bezout or by (modified_)subresultants_sylv.
+
+    This function removes from poly_seq all zero polynomials as well
+    as all those whose degree is equal to the degree of a preceding
+    polynomial in poly_seq, as we scan it from left to right.
+
+    """
+    L = poly_seq[:]  # get a copy of the input sequence
+    d = degree(L[1], x)
+    i = 2
+    while i < len(L):
+        d_i = degree(L[i], x)
+        if d_i < 0:          # zero poly
+            L.remove(L[i])
+            i = i - 1
+        if d == d_i:         # poly degree equals degree of previous poly
+            L.remove(L[i])
+            i = i - 1
+        if d_i >= 0:
+            d = d_i
+        i = i + 1
+
+    return L
+
+def subresultants_sylv(f, g, x):
+    """
+    The input polynomials f, g are in Z[x] or in Q[x]. It is assumed
+    that deg(f) >= deg(g).
+
+    Computes the subresultant polynomial remainder sequence (prs)
+    of f, g by evaluating determinants of appropriately selected
+    submatrices of sylvester(f, g, x, 1). The dimensions of the
+    latter are (deg(f) + deg(g)) x (deg(f) + deg(g)).
+
+    Each coefficient is computed by evaluating the determinant of the
+    corresponding submatrix of sylvester(f, g, x, 1).
+
+    If the subresultant prs is complete, then the output coincides
+    with the Euclidean sequence of the polynomials f, g.
+
+    References:
+    ===========
+    1. G.M.Diaz-Toca,L.Gonzalez-Vega: Various New Expressions for Subresultants
+    and Their Applications. Appl. Algebra in Engin., Communic. and Comp.,
+    Vol. 15, 233-266, 2004.
+
+    """
+
+    # make sure neither f nor g is 0
+    if f == 0 or g == 0:
+        return [f, g]
+
+    n = degF = degree(f, x)
+    m = degG = degree(g, x)
+
+    # make sure proper degrees
+    if n == 0 and m == 0:
+        return [f, g]
+    if n < m:
+        n, m, degF, degG, f, g = m, n, degG, degF, g, f
+    if n > 0 and m == 0:
+        return [f, g]
+
+    SR_L = [f, g]      # subresultant list
+
+    # form matrix sylvester(f, g, x, 1)
+    S = sylvester(f, g, x, 1)
+
+    # pick appropriate submatrices of S
+    # and form subresultant polys
+    j = m - 1
+
+    while j > 0:
+        Sp = S[:, :]  # copy of S
+        # delete last j rows of coeffs of g
+        for ind in range(m + n - j, m + n):
+            Sp.row_del(m + n - j)
+        # delete last j rows of coeffs of f
+        for ind in range(m - j, m):
+            Sp.row_del(m - j)
+
+        # evaluate determinants and form coefficients list
+        coeff_L, k, l = [], Sp.rows, 0
+        while l <= j:
+            coeff_L.append(Sp[:, 0:k].det())
+            Sp.col_swap(k - 1, k + l)
+            l += 1
+
+        # form poly and append to SP_L
+        SR_L.append(Poly(coeff_L, x).as_expr())
+        j -= 1
+
+    # j = 0
+    SR_L.append(S.det())
+
+    return process_matrix_output(SR_L, x)
+
+def modified_subresultants_sylv(f, g, x):
+    """
+    The input polynomials f, g are in Z[x] or in Q[x]. It is assumed
+    that deg(f) >= deg(g).
+
+    Computes the modified subresultant polynomial remainder sequence (prs)
+    of f, g by evaluating determinants of appropriately selected
+    submatrices of sylvester(f, g, x, 2). The dimensions of the
+    latter are (2*deg(f)) x (2*deg(f)).
+
+    Each coefficient is computed by evaluating the determinant of the
+    corresponding submatrix of sylvester(f, g, x, 2).
+
+    If the modified subresultant prs is complete, then the output coincides
+    with the Sturmian sequence of the polynomials f, g.
+
+    References:
+    ===========
+    1. A. G. Akritas,G.I. Malaschonok and P.S. Vigklas:
+    Sturm Sequences and Modified Subresultant Polynomial Remainder
+    Sequences. Serdica Journal of Computing, Vol. 8, No 1, 29--46, 2014.
+
+    """
+
+    # make sure neither f nor g is 0
+    if f == 0 or g == 0:
+        return [f, g]
+
+    n = degF = degree(f, x)
+    m = degG = degree(g, x)
+
+    # make sure proper degrees
+    if n == 0 and m == 0:
+        return [f, g]
+    if n < m:
+        n, m, degF, degG, f, g = m, n, degG, degF, g, f
+    if n > 0 and m == 0:
+        return [f, g]
+
+    SR_L = [f, g]      # modified subresultant list
+
+    # form matrix sylvester(f, g, x, 2)
+    S = sylvester(f, g, x, 2)
+
+    # pick appropriate submatrices of S
+    # and form modified subresultant polys
+    j = m - 1
+
+    while j > 0:
+        # delete last 2*j rows of pairs of coeffs of f, g
+        Sp = S[0:2*n - 2*j, :]  # copy of first 2*n - 2*j rows of S
+
+        # evaluate determinants and form coefficients list
+        coeff_L, k, l = [], Sp.rows, 0
+        while l <= j:
+            coeff_L.append(Sp[:, 0:k].det())
+            Sp.col_swap(k - 1, k + l)
+            l += 1
+
+        # form poly and append to SP_L
+        SR_L.append(Poly(coeff_L, x).as_expr())
+        j -= 1
+
+    # j = 0
+    SR_L.append(S.det())
+
+    return process_matrix_output(SR_L, x)
+
+def res(f, g, x):
+    """
+    The input polynomials f, g are in Z[x] or in Q[x].
+
+    The output is the resultant of f, g computed by evaluating
+    the determinant of the matrix sylvester(f, g, x, 1).
+
+    References:
+    ===========
+    1. J. S. Cohen: Computer Algebra and Symbolic Computation
+     - Mathematical Methods. A. K. Peters, 2003.
+
+    """
+    if f == 0 or g == 0:
+         raise PolynomialError("The resultant of %s and %s is not defined" % (f, g))
+    else:
+        return sylvester(f, g, x, 1).det()
+
+def res_q(f, g, x):
+    """
+    The input polynomials f, g are in Z[x] or in Q[x].
+
+    The output is the resultant of f, g computed recursively
+    by polynomial divisions in Q[x], using the function rem.
+    See Cohen's book p. 281.
+
+    References:
+    ===========
+    1. J. S. Cohen: Computer Algebra and Symbolic Computation
+     - Mathematical Methods. A. K. Peters, 2003.
+    """
+    m = degree(f, x)
+    n = degree(g, x)
+    if m < n:
+        return (-1)**(m*n) * res_q(g, f, x)
+    elif n == 0:  # g is a constant
+        return g**m
+    else:
+        r = rem(f, g, x)
+        if r == 0:
+            return 0
+        else:
+            s = degree(r, x)
+            l = LC(g, x)
+            return (-1)**(m*n) * l**(m-s)*res_q(g, r, x)
+
+def res_z(f, g, x):
+    """
+    The input polynomials f, g are in Z[x] or in Q[x].
+
+    The output is the resultant of f, g computed recursively
+    by polynomial divisions in Z[x], using the function prem().
+    See Cohen's book p. 283.
+
+    References:
+    ===========
+    1. J. S. Cohen: Computer Algebra and Symbolic Computation
+     - Mathematical Methods. A. K. Peters, 2003.
+    """
+    m = degree(f, x)
+    n = degree(g, x)
+    if m < n:
+        return (-1)**(m*n) * res_z(g, f, x)
+    elif n == 0:  # g is a constant
+        return g**m
+    else:
+        r = prem(f, g, x)
+        if r == 0:
+            return 0
+        else:
+            delta = m - n + 1
+            w = (-1)**(m*n) * res_z(g, r, x)
+            s = degree(r, x)
+            l = LC(g, x)
+            k = delta * n - m + s
+            return quo(w, l**k, x)
+
+def sign_seq(poly_seq, x):
+    """
+    Given a sequence of polynomials poly_seq, it returns
+    the sequence of signs of the leading coefficients of
+    the polynomials in poly_seq.
+
+    """
+    return [sign(LC(poly_seq[i], x)) for i in range(len(poly_seq))]
+
+def bezout(p, q, x, method='bz'):
+    """
+    The input polynomials p, q are in Z[x] or in Q[x]. Let
+    mx = max(degree(p, x), degree(q, x)).
+
+    The default option bezout(p, q, x, method='bz') returns Bezout's
+    symmetric matrix of p and q, of dimensions (mx) x (mx). The
+    determinant of this matrix is equal to the determinant of sylvester2,
+    Sylvester's matrix of 1853, whose dimensions are (2*mx) x (2*mx);
+    however the subresultants of these two matrices may differ.
+
+    The other option, bezout(p, q, x, 'prs'), is of interest to us
+    in this module because it returns a matrix equivalent to sylvester2.
+    In this case all subresultants of the two matrices are identical.
+
+    Both the subresultant polynomial remainder sequence (prs) and
+    the modified subresultant prs of p and q can be computed by
+    evaluating determinants of appropriately selected submatrices of
+    bezout(p, q, x, 'prs') --- one determinant per coefficient of the
+    remainder polynomials.
+
+    The matrices bezout(p, q, x, 'bz') and bezout(p, q, x, 'prs')
+    are related by the formula
+
+    bezout(p, q, x, 'prs') =
+    backward_eye(deg(p)) * bezout(p, q, x, 'bz') * backward_eye(deg(p)),
+
+    where backward_eye() is the backward identity function.
+
+    References
+    ==========
+    1. G.M.Diaz-Toca,L.Gonzalez-Vega: Various New Expressions for Subresultants
+    and Their Applications. Appl. Algebra in Engin., Communic. and Comp.,
+    Vol. 15, 233-266, 2004.
+
+    """
+    # obtain degrees of polys
+    m, n = degree( Poly(p, x), x), degree( Poly(q, x), x)
+
+    # Special cases:
+    # A:: case m = n < 0 (i.e. both polys are 0)
+    if m == n and n < 0:
+        return Matrix([])
+
+    # B:: case m = n = 0  (i.e. both polys are constants)
+    if m == n and n == 0:
+        return Matrix([])
+
+    # C:: m == 0 and n < 0 or m < 0 and n == 0
+    # (i.e. one poly is constant and the other is 0)
+    if m == 0 and n < 0:
+        return Matrix([])
+    elif m < 0 and n == 0:
+        return Matrix([])
+
+    # D:: m >= 1 and n < 0 or m < 0 and n >=1
+    # (i.e. one poly is of degree >=1 and the other is 0)
+    if m >= 1 and n < 0:
+        return Matrix([0])
+    elif m < 0 and n >= 1:
+        return Matrix([0])
+
+    y = var('y')
+
+    # expr is 0 when x = y
+    expr = p * q.subs({x:y}) - p.subs({x:y}) * q
+
+    # hence expr is exactly divisible by x - y
+    poly = Poly( quo(expr, x-y), x, y)
+
+    # form Bezout matrix and store them in B as indicated to get
+    # the LC coefficient of each poly either in the first position
+    # of each row (method='prs') or in the last (method='bz').
+    mx = max(m, n)
+    B = zeros(mx)
+    for i in range(mx):
+        for j in range(mx):
+            if method == 'prs':
+                B[mx - 1 - i, mx - 1 - j] = poly.nth(i, j)
+            else:
+                B[i, j] = poly.nth(i, j)
+    return B
+
+def backward_eye(n):
+    '''
+    Returns the backward identity matrix of dimensions n x n.
+
+    Needed to "turn" the Bezout matrices
+    so that the leading coefficients are first.
+    See docstring of the function bezout(p, q, x, method='bz').
+    '''
+    M = eye(n)  # identity matrix of order n
+
+    for i in range(int(M.rows / 2)):
+        M.row_swap(0 + i, M.rows - 1 - i)
+
+    return M
+
+def subresultants_bezout(p, q, x):
+    """
+    The input polynomials p, q are in Z[x] or in Q[x]. It is assumed
+    that degree(p, x) >= degree(q, x).
+
+    Computes the subresultant polynomial remainder sequence
+    of p, q by evaluating determinants of appropriately selected
+    submatrices of bezout(p, q, x, 'prs'). The dimensions of the
+    latter are deg(p) x deg(p).
+
+    Each coefficient is computed by evaluating the determinant of the
+    corresponding submatrix of bezout(p, q, x, 'prs').
+
+    bezout(p, q, x, 'prs) is used instead of sylvester(p, q, x, 1),
+    Sylvester's matrix of 1840, because the dimensions of the latter
+    are (deg(p) + deg(q)) x (deg(p) + deg(q)).
+
+    If the subresultant prs is complete, then the output coincides
+    with the Euclidean sequence of the polynomials p, q.
+
+    References
+    ==========
+    1. G.M.Diaz-Toca,L.Gonzalez-Vega: Various New Expressions for Subresultants
+    and Their Applications. Appl. Algebra in Engin., Communic. and Comp.,
+    Vol. 15, 233-266, 2004.
+
+    """
+    # make sure neither p nor q is 0
+    if p == 0 or q == 0:
+        return [p, q]
+
+    f, g = p, q
+    n = degF = degree(f, x)
+    m = degG = degree(g, x)
+
+    # make sure proper degrees
+    if n == 0 and m == 0:
+        return [f, g]
+    if n < m:
+        n, m, degF, degG, f, g = m, n, degG, degF, g, f
+    if n > 0 and m == 0:
+        return [f, g]
+
+    SR_L = [f, g]      # subresultant list
+    F = LC(f, x)**(degF - degG)
+
+    # form the bezout matrix
+    B = bezout(f, g, x, 'prs')
+
+    # pick appropriate submatrices of B
+    # and form subresultant polys
+    if degF > degG:
+        j = 2
+    if degF == degG:
+        j = 1
+    while j <= degF:
+        M = B[0:j, :]
+        k, coeff_L = j - 1, []
+        while k <= degF - 1:
+            coeff_L.append(M[:, 0:j].det())
+            if k < degF - 1:
+                M.col_swap(j - 1, k + 1)
+            k = k + 1
+
+        # apply Theorem 2.1 in the paper by Toca & Vega 2004
+        # to get correct signs
+        SR_L.append(int((-1)**(j*(j-1)/2)) * (Poly(coeff_L, x) / F).as_expr())
+        j = j + 1
+
+    return process_matrix_output(SR_L, x)
+
+def modified_subresultants_bezout(p, q, x):
+    """
+    The input polynomials p, q are in Z[x] or in Q[x]. It is assumed
+    that degree(p, x) >= degree(q, x).
+
+    Computes the modified subresultant polynomial remainder sequence
+    of p, q by evaluating determinants of appropriately selected
+    submatrices of bezout(p, q, x, 'prs'). The dimensions of the
+    latter are deg(p) x deg(p).
+
+    Each coefficient is computed by evaluating the determinant of the
+    corresponding submatrix of bezout(p, q, x, 'prs').
+
+    bezout(p, q, x, 'prs') is used instead of sylvester(p, q, x, 2),
+    Sylvester's matrix of 1853, because the dimensions of the latter
+    are 2*deg(p) x 2*deg(p).
+
+    If the modified subresultant prs is complete, and LC( p ) > 0, the output
+    coincides with the (generalized) Sturm's sequence of the polynomials p, q.
+
+    References
+    ==========
+    1. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``Sturm Sequences
+    and Modified Subresultant Polynomial Remainder Sequences.''
+    Serdica Journal of Computing, Vol. 8, No 1, 29-46, 2014.
+
+    2. G.M.Diaz-Toca,L.Gonzalez-Vega: Various New Expressions for Subresultants
+    and Their Applications. Appl. Algebra in Engin., Communic. and Comp.,
+    Vol. 15, 233-266, 2004.
+
+
+    """
+    # make sure neither p nor q is 0
+    if p == 0 or q == 0:
+        return [p, q]
+
+    f, g = p, q
+    n = degF = degree(f, x)
+    m = degG = degree(g, x)
+
+    # make sure proper degrees
+    if n == 0 and m == 0:
+        return [f, g]
+    if n < m:
+        n, m, degF, degG, f, g = m, n, degG, degF, g, f
+    if n > 0 and m == 0:
+        return [f, g]
+
+    SR_L = [f, g]      # subresultant list
+
+    # form the bezout matrix
+    B = bezout(f, g, x, 'prs')
+
+    # pick appropriate submatrices of B
+    # and form subresultant polys
+    if degF > degG:
+        j = 2
+    if degF == degG:
+        j = 1
+    while j <= degF:
+        M = B[0:j, :]
+        k, coeff_L = j - 1, []
+        while k <= degF - 1:
+            coeff_L.append(M[:, 0:j].det())
+            if k < degF - 1:
+                M.col_swap(j - 1, k + 1)
+            k = k + 1
+
+        ## Theorem 2.1 in the paper by Toca & Vega 2004 is _not needed_
+        ## in this case since
+        ## the bezout matrix is equivalent to sylvester2
+        SR_L.append(( Poly(coeff_L, x)).as_expr())
+        j = j + 1
+
+    return process_matrix_output(SR_L, x)
+
+def sturm_pg(p, q, x, method=0):
+    """
+    p, q are polynomials in Z[x] or Q[x]. It is assumed
+    that degree(p, x) >= degree(q, x).
+
+    Computes the (generalized) Sturm sequence of p and q in Z[x] or Q[x].
+    If q = diff(p, x, 1) it is the usual Sturm sequence.
+
+    A. If method == 0, default, the remainder coefficients of the sequence
+       are (in absolute value) ``modified'' subresultants, which for non-monic
+       polynomials are greater than the coefficients of the corresponding
+       subresultants by the factor Abs(LC(p)**( deg(p)- deg(q))).
+
+    B. If method == 1, the remainder coefficients of the sequence are (in
+       absolute value) subresultants, which for non-monic polynomials are
+       smaller than the coefficients of the corresponding ``modified''
+       subresultants by the factor Abs(LC(p)**( deg(p)- deg(q))).
+
+    If the Sturm sequence is complete, method=0 and LC( p ) > 0, the coefficients
+    of the polynomials in the sequence are ``modified'' subresultants.
+    That is, they are  determinants of appropriately selected submatrices of
+    sylvester2, Sylvester's matrix of 1853. In this case the Sturm sequence
+    coincides with the ``modified'' subresultant prs, of the polynomials
+    p, q.
+
+    If the Sturm sequence is incomplete and method=0 then the signs of the
+    coefficients of the polynomials in the sequence may differ from the signs
+    of the coefficients of the corresponding polynomials in the ``modified''
+    subresultant prs; however, the absolute values are the same.
+
+    To compute the coefficients, no determinant evaluation takes place. Instead,
+    polynomial divisions in Q[x] are performed, using the function rem(p, q, x);
+    the coefficients of the remainders computed this way become (``modified'')
+    subresultants with the help of the Pell-Gordon Theorem of 1917.
+    See also the function euclid_pg(p, q, x).
+
+    References
+    ==========
+    1. Pell A. J., R. L. Gordon. The Modified Remainders Obtained in Finding
+    the Highest Common Factor of Two Polynomials. Annals of MatheMatics,
+    Second Series, 18 (1917), No. 4, 188-193.
+
+    2. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``Sturm Sequences
+    and Modified Subresultant Polynomial Remainder Sequences.''
+    Serdica Journal of Computing, Vol. 8, No 1, 29-46, 2014.
+
+    """
+    # make sure neither p nor q is 0
+    if p == 0 or q == 0:
+        return [p, q]
+
+    # make sure proper degrees
+    d0 =  degree(p, x)
+    d1 =  degree(q, x)
+    if d0 == 0 and d1 == 0:
+        return [p, q]
+    if d1 > d0:
+        d0, d1 = d1, d0
+        p, q = q, p
+    if d0 > 0 and d1 == 0:
+        return [p,q]
+
+    # make sure LC(p) > 0
+    flag = 0
+    if  LC(p,x) < 0:
+        flag = 1
+        p = -p
+        q = -q
+
+    # initialize
+    lcf = LC(p, x)**(d0 - d1)               # lcf * subr = modified subr
+    a0, a1 = p, q                           # the input polys
+    sturm_seq = [a0, a1]                    # the output list
+    del0 = d0 - d1                          # degree difference
+    rho1 =  LC(a1, x)                       # leading coeff of a1
+    exp_deg = d1 - 1                        # expected degree of a2
+    a2 = - rem(a0, a1, domain=QQ)           # first remainder
+    rho2 =  LC(a2,x)                        # leading coeff of a2
+    d2 =  degree(a2, x)                     # actual degree of a2
+    deg_diff_new = exp_deg - d2             # expected - actual degree
+    del1 = d1 - d2                          # degree difference
+
+    # mul_fac is the factor by which a2 is multiplied to
+    # get integer coefficients
+    mul_fac_old = rho1**(del0 + del1 - deg_diff_new)
+
+    # append accordingly
+    if method == 0:
+        sturm_seq.append( simplify(lcf * a2 *  Abs(mul_fac_old)))
+    else:
+        sturm_seq.append( simplify( a2 *  Abs(mul_fac_old)))
+
+    # main loop
+    deg_diff_old = deg_diff_new
+    while d2 > 0:
+        a0, a1, d0, d1 = a1, a2, d1, d2      # update polys and degrees
+        del0 = del1                          # update degree difference
+        exp_deg = d1 - 1                     # new expected degree
+        a2 = - rem(a0, a1, domain=QQ)        # new remainder
+        rho3 =  LC(a2, x)                    # leading coeff of a2
+        d2 =  degree(a2, x)                  # actual degree of a2
+        deg_diff_new = exp_deg - d2          # expected - actual degree
+        del1 = d1 - d2                       # degree difference
+
+        # take into consideration the power
+        # rho1**deg_diff_old that was "left out"
+        expo_old = deg_diff_old               # rho1 raised to this power
+        expo_new = del0 + del1 - deg_diff_new # rho2 raised to this power
+
+        # update variables and append
+        mul_fac_new = rho2**(expo_new) * rho1**(expo_old) * mul_fac_old
+        deg_diff_old, mul_fac_old = deg_diff_new, mul_fac_new
+        rho1, rho2 = rho2, rho3
+        if method == 0:
+            sturm_seq.append( simplify(lcf * a2 *  Abs(mul_fac_old)))
+        else:
+            sturm_seq.append( simplify( a2 *  Abs(mul_fac_old)))
+
+    if flag:          # change the sign of the sequence
+        sturm_seq = [-i for i in sturm_seq]
+
+    # gcd is of degree > 0 ?
+    m = len(sturm_seq)
+    if sturm_seq[m - 1] == nan or sturm_seq[m - 1] == 0:
+        sturm_seq.pop(m - 1)
+
+    return sturm_seq
+
+def sturm_q(p, q, x):
+    """
+    p, q are polynomials in Z[x] or Q[x]. It is assumed
+    that degree(p, x) >= degree(q, x).
+
+    Computes the (generalized) Sturm sequence of p and q in Q[x].
+    Polynomial divisions in Q[x] are performed, using the function rem(p, q, x).
+
+    The coefficients of the polynomials in the Sturm sequence can be uniquely
+    determined from the corresponding coefficients of the polynomials found
+    either in:
+
+        (a) the ``modified'' subresultant prs, (references 1, 2)
+
+    or in
+
+        (b) the subresultant prs (reference 3).
+
+    References
+    ==========
+    1. Pell A. J., R. L. Gordon. The Modified Remainders Obtained in Finding
+    the Highest Common Factor of Two Polynomials. Annals of MatheMatics,
+    Second Series, 18 (1917), No. 4, 188-193.
+
+    2 Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``Sturm Sequences
+    and Modified Subresultant Polynomial Remainder Sequences.''
+    Serdica Journal of Computing, Vol. 8, No 1, 29-46, 2014.
+
+    3. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``A Basic Result
+    on the Theory of Subresultants.'' Serdica Journal of Computing 10 (2016), No.1, 31-48.
+
+    """
+    # make sure neither p nor q is 0
+    if p == 0 or q == 0:
+        return [p, q]
+
+    # make sure proper degrees
+    d0 =  degree(p, x)
+    d1 =  degree(q, x)
+    if d0 == 0 and d1 == 0:
+        return [p, q]
+    if d1 > d0:
+        d0, d1 = d1, d0
+        p, q = q, p
+    if d0 > 0 and d1 == 0:
+        return [p,q]
+
+    # make sure LC(p) > 0
+    flag = 0
+    if  LC(p,x) < 0:
+        flag = 1
+        p = -p
+        q = -q
+
+    # initialize
+    a0, a1 = p, q                           # the input polys
+    sturm_seq = [a0, a1]                    # the output list
+    a2 = -rem(a0, a1, domain=QQ)            # first remainder
+    d2 =  degree(a2, x)                     # degree of a2
+    sturm_seq.append( a2 )
+
+    # main loop
+    while d2 > 0:
+        a0, a1, d0, d1 = a1, a2, d1, d2      # update polys and degrees
+        a2 = -rem(a0, a1, domain=QQ)         # new remainder
+        d2 =  degree(a2, x)                  # actual degree of a2
+        sturm_seq.append( a2 )
+
+    if flag:          # change the sign of the sequence
+        sturm_seq = [-i for i in sturm_seq]
+
+    # gcd is of degree > 0 ?
+    m = len(sturm_seq)
+    if sturm_seq[m - 1] == nan or sturm_seq[m - 1] == 0:
+        sturm_seq.pop(m - 1)
+
+    return sturm_seq
+
+def sturm_amv(p, q, x, method=0):
+    """
+    p, q are polynomials in Z[x] or Q[x]. It is assumed
+    that degree(p, x) >= degree(q, x).
+
+    Computes the (generalized) Sturm sequence of p and q in Z[x] or Q[x].
+    If q = diff(p, x, 1) it is the usual Sturm sequence.
+
+    A. If method == 0, default, the remainder coefficients of the
+       sequence are (in absolute value) ``modified'' subresultants, which
+       for non-monic polynomials are greater than the coefficients of the
+       corresponding subresultants by the factor Abs(LC(p)**( deg(p)- deg(q))).
+
+    B. If method == 1, the remainder coefficients of the sequence are (in
+       absolute value) subresultants, which for non-monic polynomials are
+       smaller than the coefficients of the corresponding ``modified''
+       subresultants by the factor Abs( LC(p)**( deg(p)- deg(q)) ).
+
+    If the Sturm sequence is complete, method=0 and LC( p ) > 0, then the
+    coefficients of the polynomials in the sequence are ``modified'' subresultants.
+    That is, they are  determinants of appropriately selected submatrices of
+    sylvester2, Sylvester's matrix of 1853. In this case the Sturm sequence
+    coincides with the ``modified'' subresultant prs, of the polynomials
+    p, q.
+
+    If the Sturm sequence is incomplete and method=0 then the signs of the
+    coefficients of the polynomials in the sequence may differ from the signs
+    of the coefficients of the corresponding polynomials in the ``modified''
+    subresultant prs; however, the absolute values are the same.
+
+    To compute the coefficients, no determinant evaluation takes place.
+    Instead, we first compute the euclidean sequence  of p and q using
+    euclid_amv(p, q, x) and then: (a) change the signs of the remainders in the
+    Euclidean sequence according to the pattern "-, -, +, +, -, -, +, +,..."
+    (see Lemma 1 in the 1st reference or Theorem 3 in the 2nd reference)
+    and (b) if method=0, assuming deg(p) > deg(q), we multiply the remainder
+    coefficients of the Euclidean sequence times the factor
+    Abs( LC(p)**( deg(p)- deg(q)) ) to make them modified subresultants.
+    See also the function sturm_pg(p, q, x).
+
+    References
+    ==========
+    1. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``A Basic Result
+    on the Theory of Subresultants.'' Serdica Journal of Computing 10 (2016), No.1, 31-48.
+
+    2. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``On the Remainders
+    Obtained in Finding the Greatest Common Divisor of Two Polynomials.'' Serdica
+    Journal of Computing 9(2) (2015), 123-138.
+
+    3. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``Subresultant Polynomial
+    Remainder Sequences Obtained by Polynomial Divisions in Q[x] or in Z[x].''
+    Serdica Journal of Computing 10 (2016), No.3-4, 197-217.
+
+    """
+    # compute the euclidean sequence
+    prs = euclid_amv(p, q, x)
+
+    # defensive
+    if prs == [] or len(prs) == 2:
+        return prs
+
+    # the coefficients in prs are subresultants and hence are smaller
+    # than the corresponding subresultants by the factor
+    # Abs( LC(prs[0])**( deg(prs[0]) - deg(prs[1])) ); Theorem 2, 2nd reference.
+    lcf = Abs( LC(prs[0])**( degree(prs[0], x) - degree(prs[1], x) ) )
+
+    # the signs of the first two polys in the sequence stay the same
+    sturm_seq = [prs[0], prs[1]]
+
+    # change the signs according to "-, -, +, +, -, -, +, +,..."
+    # and multiply times lcf if needed
+    flag = 0
+    m = len(prs)
+    i = 2
+    while i <= m-1:
+        if  flag == 0:
+            sturm_seq.append( - prs[i] )
+            i = i + 1
+            if i == m:
+                break
+            sturm_seq.append( - prs[i] )
+            i = i + 1
+            flag = 1
+        elif flag == 1:
+            sturm_seq.append( prs[i] )
+            i = i + 1
+            if i == m:
+                break
+            sturm_seq.append( prs[i] )
+            i = i + 1
+            flag = 0
+
+    # subresultants or modified subresultants?
+    if method == 0 and lcf > 1:
+        aux_seq = [sturm_seq[0], sturm_seq[1]]
+        for i in range(2, m):
+            aux_seq.append(simplify(sturm_seq[i] * lcf ))
+        sturm_seq = aux_seq
+
+    return sturm_seq
+
+def euclid_pg(p, q, x):
+    """
+    p, q are polynomials in Z[x] or Q[x]. It is assumed
+    that degree(p, x) >= degree(q, x).
+
+    Computes the Euclidean sequence of p and q in Z[x] or Q[x].
+
+    If the Euclidean sequence is complete the coefficients of the polynomials
+    in the sequence are subresultants. That is, they are  determinants of
+    appropriately selected submatrices of sylvester1, Sylvester's matrix of 1840.
+    In this case the Euclidean sequence coincides with the subresultant prs
+    of the polynomials p, q.
+
+    If the Euclidean sequence is incomplete the signs of the coefficients of the
+    polynomials in the sequence may differ from the signs of the coefficients of
+    the corresponding polynomials in the subresultant prs; however, the absolute
+    values are the same.
+
+    To compute the Euclidean sequence, no determinant evaluation takes place.
+    We first compute the (generalized) Sturm sequence  of p and q using
+    sturm_pg(p, q, x, 1), in which case the coefficients are (in absolute value)
+    equal to subresultants. Then we change the signs of the remainders in the
+    Sturm sequence according to the pattern "-, -, +, +, -, -, +, +,..." ;
+    see Lemma 1 in the 1st reference or Theorem 3 in the 2nd reference as well as
+    the function sturm_pg(p, q, x).
+
+    References
+    ==========
+    1. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``A Basic Result
+    on the Theory of Subresultants.'' Serdica Journal of Computing 10 (2016), No.1, 31-48.
+
+    2. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``On the Remainders
+    Obtained in Finding the Greatest Common Divisor of Two Polynomials.'' Serdica
+    Journal of Computing 9(2) (2015), 123-138.
+
+    3. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``Subresultant Polynomial
+    Remainder Sequences Obtained by Polynomial Divisions in Q[x] or in Z[x].''
+    Serdica Journal of Computing 10 (2016), No.3-4, 197-217.
+    """
+    # compute the sturmian sequence using the Pell-Gordon (or AMV) theorem
+    # with the coefficients in the prs being (in absolute value) subresultants
+    prs = sturm_pg(p, q, x, 1)  ## any other method would do
+
+    # defensive
+    if prs == [] or len(prs) == 2:
+        return prs
+
+    # the signs of the first two polys in the sequence stay the same
+    euclid_seq = [prs[0], prs[1]]
+
+    # change the signs according to "-, -, +, +, -, -, +, +,..."
+    flag = 0
+    m = len(prs)
+    i = 2
+    while i <= m-1:
+        if  flag == 0:
+            euclid_seq.append(- prs[i] )
+            i = i + 1
+            if i == m:
+                break
+            euclid_seq.append(- prs[i] )
+            i = i + 1
+            flag = 1
+        elif flag == 1:
+            euclid_seq.append(prs[i] )
+            i = i + 1
+            if i == m:
+                break
+            euclid_seq.append(prs[i] )
+            i = i + 1
+            flag = 0
+
+    return euclid_seq
+
+def euclid_q(p, q, x):
+    """
+    p, q are polynomials in Z[x] or Q[x]. It is assumed
+    that degree(p, x) >= degree(q, x).
+
+    Computes the Euclidean sequence of p and q in Q[x].
+    Polynomial divisions in Q[x] are performed, using the function rem(p, q, x).
+
+    The coefficients of the polynomials in the Euclidean sequence can be uniquely
+    determined from the corresponding coefficients of the polynomials found
+    either in:
+
+        (a) the ``modified'' subresultant polynomial remainder sequence,
+    (references 1, 2)
+
+    or in
+
+        (b) the subresultant polynomial remainder sequence (references 3).
+
+    References
+    ==========
+    1. Pell A. J., R. L. Gordon. The Modified Remainders Obtained in Finding
+    the Highest Common Factor of Two Polynomials. Annals of MatheMatics,
+    Second Series, 18 (1917), No. 4, 188-193.
+
+    2. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``Sturm Sequences
+    and Modified Subresultant Polynomial Remainder Sequences.''
+    Serdica Journal of Computing, Vol. 8, No 1, 29-46, 2014.
+
+    3. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``A Basic Result
+    on the Theory of Subresultants.'' Serdica Journal of Computing 10 (2016), No.1, 31-48.
+
+    """
+    # make sure neither p nor q is 0
+    if p == 0 or q == 0:
+        return [p, q]
+
+    # make sure proper degrees
+    d0 =  degree(p, x)
+    d1 =  degree(q, x)
+    if d0 == 0 and d1 == 0:
+        return [p, q]
+    if d1 > d0:
+        d0, d1 = d1, d0
+        p, q = q, p
+    if d0 > 0 and d1 == 0:
+        return [p,q]
+
+    # make sure LC(p) > 0
+    flag = 0
+    if  LC(p,x) < 0:
+        flag = 1
+        p = -p
+        q = -q
+
+    # initialize
+    a0, a1 = p, q                           # the input polys
+    euclid_seq = [a0, a1]                   # the output list
+    a2 = rem(a0, a1, domain=QQ)             # first remainder
+    d2 =  degree(a2, x)                     # degree of a2
+    euclid_seq.append( a2 )
+
+    # main loop
+    while d2 > 0:
+        a0, a1, d0, d1 = a1, a2, d1, d2      # update polys and degrees
+        a2 = rem(a0, a1, domain=QQ)          # new remainder
+        d2 =  degree(a2, x)                  # actual degree of a2
+        euclid_seq.append( a2 )
+
+    if flag:          # change the sign of the sequence
+        euclid_seq = [-i for i in euclid_seq]
+
+    # gcd is of degree > 0 ?
+    m = len(euclid_seq)
+    if euclid_seq[m - 1] == nan or euclid_seq[m - 1] == 0:
+        euclid_seq.pop(m - 1)
+
+    return euclid_seq
+
+def euclid_amv(f, g, x):
+    """
+    f, g are polynomials in Z[x] or Q[x]. It is assumed
+    that degree(f, x) >= degree(g, x).
+
+    Computes the Euclidean sequence of p and q in Z[x] or Q[x].
+
+    If the Euclidean sequence is complete the coefficients of the polynomials
+    in the sequence are subresultants. That is, they are  determinants of
+    appropriately selected submatrices of sylvester1, Sylvester's matrix of 1840.
+    In this case the Euclidean sequence coincides with the subresultant prs,
+    of the polynomials p, q.
+
+    If the Euclidean sequence is incomplete the signs of the coefficients of the
+    polynomials in the sequence may differ from the signs of the coefficients of
+    the corresponding polynomials in the subresultant prs; however, the absolute
+    values are the same.
+
+    To compute the coefficients, no determinant evaluation takes place.
+    Instead, polynomial divisions in Z[x] or Q[x] are performed, using
+    the function rem_z(f, g, x);  the coefficients of the remainders
+    computed this way become subresultants with the help of the
+    Collins-Brown-Traub formula for coefficient reduction.
+
+    References
+    ==========
+    1. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``A Basic Result
+    on the Theory of Subresultants.'' Serdica Journal of Computing 10 (2016), No.1, 31-48.
+
+    2. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``Subresultant Polynomial
+    remainder Sequences Obtained by Polynomial Divisions in Q[x] or in Z[x].''
+    Serdica Journal of Computing 10 (2016), No.3-4, 197-217.
+
+    """
+    # make sure neither f nor g is 0
+    if f == 0 or g == 0:
+        return [f, g]
+
+    # make sure proper degrees
+    d0 =  degree(f, x)
+    d1 =  degree(g, x)
+    if d0 == 0 and d1 == 0:
+        return [f, g]
+    if d1 > d0:
+        d0, d1 = d1, d0
+        f, g = g, f
+    if d0 > 0 and d1 == 0:
+        return [f, g]
+
+    # initialize
+    a0 = f
+    a1 = g
+    euclid_seq = [a0, a1]
+    deg_dif_p1, c = degree(a0, x) - degree(a1, x) + 1, -1
+
+    # compute the first polynomial of the prs
+    i = 1
+    a2 = rem_z(a0, a1, x) / Abs( (-1)**deg_dif_p1 )     # first remainder
+    euclid_seq.append( a2 )
+    d2 =  degree(a2, x)                              # actual degree of a2
+
+    # main loop
+    while d2 >= 1:
+        a0, a1, d0, d1 = a1, a2, d1, d2       # update polys and degrees
+        i += 1
+        sigma0 = -LC(a0)
+        c = (sigma0**(deg_dif_p1 - 1)) / (c**(deg_dif_p1 - 2))
+        deg_dif_p1 = degree(a0, x) - d2 + 1
+        a2 = rem_z(a0, a1, x) / Abs( (c**(deg_dif_p1 - 1)) * sigma0 )
+        euclid_seq.append( a2 )
+        d2 =  degree(a2, x)                   # actual degree of a2
+
+    # gcd is of degree > 0 ?
+    m = len(euclid_seq)
+    if euclid_seq[m - 1] == nan or euclid_seq[m - 1] == 0:
+        euclid_seq.pop(m - 1)
+
+    return euclid_seq
+
+def modified_subresultants_pg(p, q, x):
+    """
+    p, q are polynomials in Z[x] or Q[x]. It is assumed
+    that degree(p, x) >= degree(q, x).
+
+    Computes the ``modified'' subresultant prs of p and q in Z[x] or Q[x];
+    the coefficients of the polynomials in the sequence are
+    ``modified'' subresultants. That is, they are  determinants of appropriately
+    selected submatrices of sylvester2, Sylvester's matrix of 1853.
+
+    To compute the coefficients, no determinant evaluation takes place. Instead,
+    polynomial divisions in Q[x] are performed, using the function rem(p, q, x);
+    the coefficients of the remainders computed this way become ``modified''
+    subresultants with the help of the Pell-Gordon Theorem of 1917.
+
+    If the ``modified'' subresultant prs is complete, and LC( p ) > 0, it coincides
+    with the (generalized) Sturm sequence of the polynomials p, q.
+
+    References
+    ==========
+    1. Pell A. J., R. L. Gordon. The Modified Remainders Obtained in Finding
+    the Highest Common Factor of Two Polynomials. Annals of MatheMatics,
+    Second Series, 18 (1917), No. 4, 188-193.
+
+    2. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``Sturm Sequences
+    and Modified Subresultant Polynomial Remainder Sequences.''
+    Serdica Journal of Computing, Vol. 8, No 1, 29-46, 2014.
+
+    """
+    # make sure neither p nor q is 0
+    if p == 0 or q == 0:
+        return [p, q]
+
+    # make sure proper degrees
+    d0 =  degree(p,x)
+    d1 =  degree(q,x)
+    if d0 == 0 and d1 == 0:
+        return [p, q]
+    if d1 > d0:
+        d0, d1 = d1, d0
+        p, q = q, p
+    if d0 > 0 and d1 == 0:
+        return [p,q]
+
+    # initialize
+    k =  var('k')                               # index in summation formula
+    u_list = []                                 # of elements (-1)**u_i
+    subres_l = [p, q]                           # mod. subr. prs output list
+    a0, a1 = p, q                               # the input polys
+    del0 = d0 - d1                              # degree difference
+    degdif = del0                               # save it
+    rho_1 = LC(a0)                              # lead. coeff (a0)
+
+    # Initialize Pell-Gordon variables
+    rho_list_minus_1 =  sign( LC(a0, x))      # sign of LC(a0)
+    rho1 =  LC(a1, x)                         # leading coeff of a1
+    rho_list = [ sign(rho1)]                  # of signs
+    p_list = [del0]                           # of degree differences
+    u =  summation(k, (k, 1, p_list[0]))      # value of u
+    u_list.append(u)                          # of u values
+    v = sum(p_list)                           # v value
+
+    # first remainder
+    exp_deg = d1 - 1                          # expected degree of a2
+    a2 = - rem(a0, a1, domain=QQ)             # first remainder
+    rho2 =  LC(a2, x)                         # leading coeff of a2
+    d2 =  degree(a2, x)                       # actual degree of a2
+    deg_diff_new = exp_deg - d2               # expected - actual degree
+    del1 = d1 - d2                            # degree difference
+
+    # mul_fac is the factor by which a2 is multiplied to
+    # get integer coefficients
+    mul_fac_old = rho1**(del0 + del1 - deg_diff_new)
+
+    # update Pell-Gordon variables
+    p_list.append(1 + deg_diff_new)              # deg_diff_new is 0 for complete seq
+
+    # apply Pell-Gordon formula (7) in second reference
+    num = 1                                     # numerator of fraction
+    for u in u_list:
+        num *= (-1)**u
+    num = num * (-1)**v
+
+    # denominator depends on complete / incomplete seq
+    if deg_diff_new == 0:                        # complete seq
+        den = 1
+        for k in range(len(rho_list)):
+            den *= rho_list[k]**(p_list[k] + p_list[k + 1])
+        den = den * rho_list_minus_1
+    else:                                       # incomplete seq
+        den = 1
+        for k in range(len(rho_list)-1):
+            den *= rho_list[k]**(p_list[k] + p_list[k + 1])
+        den = den * rho_list_minus_1
+        expo = (p_list[len(rho_list) - 1] + p_list[len(rho_list)] - deg_diff_new)
+        den = den * rho_list[len(rho_list) - 1]**expo
+
+    # the sign of the determinant depends on sg(num / den)
+    if  sign(num / den) > 0:
+        subres_l.append( simplify(rho_1**degdif*a2* Abs(mul_fac_old) ) )
+    else:
+        subres_l.append(- simplify(rho_1**degdif*a2* Abs(mul_fac_old) ) )
+
+    # update Pell-Gordon variables
+    k = var('k')
+    rho_list.append( sign(rho2))
+    u =  summation(k, (k, 1, p_list[len(p_list) - 1]))
+    u_list.append(u)
+    v = sum(p_list)
+    deg_diff_old=deg_diff_new
+
+    # main loop
+    while d2 > 0:
+        a0, a1, d0, d1 = a1, a2, d1, d2      # update polys and degrees
+        del0 = del1                          # update degree difference
+        exp_deg = d1 - 1                     # new expected degree
+        a2 = - rem(a0, a1, domain=QQ)        # new remainder
+        rho3 =  LC(a2, x)                    # leading coeff of a2
+        d2 =  degree(a2, x)                  # actual degree of a2
+        deg_diff_new = exp_deg - d2          # expected - actual degree
+        del1 = d1 - d2                       # degree difference
+
+        # take into consideration the power
+        # rho1**deg_diff_old that was "left out"
+        expo_old = deg_diff_old               # rho1 raised to this power
+        expo_new = del0 + del1 - deg_diff_new # rho2 raised to this power
+
+        mul_fac_new = rho2**(expo_new) * rho1**(expo_old) * mul_fac_old
+
+        # update variables
+        deg_diff_old, mul_fac_old = deg_diff_new, mul_fac_new
+        rho1, rho2 = rho2, rho3
+
+        # update Pell-Gordon variables
+        p_list.append(1 + deg_diff_new)       # deg_diff_new is 0 for complete seq
+
+        # apply Pell-Gordon formula (7) in second reference
+        num = 1                              # numerator
+        for u in u_list:
+            num *= (-1)**u
+        num = num * (-1)**v
+
+        # denominator depends on complete / incomplete seq
+        if deg_diff_new == 0:                 # complete seq
+            den = 1
+            for k in range(len(rho_list)):
+                den *= rho_list[k]**(p_list[k] + p_list[k + 1])
+            den = den * rho_list_minus_1
+        else:                                # incomplete seq
+            den = 1
+            for k in range(len(rho_list)-1):
+                den *= rho_list[k]**(p_list[k] + p_list[k + 1])
+            den = den * rho_list_minus_1
+            expo = (p_list[len(rho_list) - 1] + p_list[len(rho_list)] - deg_diff_new)
+            den = den * rho_list[len(rho_list) - 1]**expo
+
+        # the sign of the determinant depends on sg(num / den)
+        if  sign(num / den) > 0:
+            subres_l.append( simplify(rho_1**degdif*a2* Abs(mul_fac_old) ) )
+        else:
+            subres_l.append(- simplify(rho_1**degdif*a2* Abs(mul_fac_old) ) )
+
+        # update Pell-Gordon variables
+        k = var('k')
+        rho_list.append( sign(rho2))
+        u =  summation(k, (k, 1, p_list[len(p_list) - 1]))
+        u_list.append(u)
+        v = sum(p_list)
+
+    # gcd is of degree > 0 ?
+    m = len(subres_l)
+    if subres_l[m - 1] == nan or subres_l[m - 1] == 0:
+        subres_l.pop(m - 1)
+
+    # LC( p ) < 0
+    m = len(subres_l)   # list may be shorter now due to deg(gcd ) > 0
+    if LC( p ) < 0:
+        aux_seq = [subres_l[0], subres_l[1]]
+        for i in range(2, m):
+            aux_seq.append(simplify(subres_l[i] * (-1) ))
+        subres_l = aux_seq
+
+    return  subres_l
+
+def subresultants_pg(p, q, x):
+    """
+    p, q are polynomials in Z[x] or Q[x]. It is assumed
+    that degree(p, x) >= degree(q, x).
+
+    Computes the subresultant prs of p and q in Z[x] or Q[x], from
+    the modified subresultant prs of p and q.
+
+    The coefficients of the polynomials in these two sequences differ only
+    in sign and the factor LC(p)**( deg(p)- deg(q)) as stated in
+    Theorem 2 of the reference.
+
+    The coefficients of the polynomials in the output sequence are
+    subresultants. That is, they are  determinants of appropriately
+    selected submatrices of sylvester1, Sylvester's matrix of 1840.
+
+    If the subresultant prs is complete, then it coincides with the
+    Euclidean sequence of the polynomials p, q.
+
+    References
+    ==========
+    1. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: "On the Remainders
+    Obtained in Finding the Greatest Common Divisor of Two Polynomials."
+    Serdica Journal of Computing 9(2) (2015), 123-138.
+
+    """
+    # compute the modified subresultant prs
+    lst = modified_subresultants_pg(p,q,x)  ## any other method would do
+
+    # defensive
+    if lst == [] or len(lst) == 2:
+        return lst
+
+    # the coefficients in lst are modified subresultants and, hence, are
+    # greater than those of the corresponding subresultants by the factor
+    # LC(lst[0])**( deg(lst[0]) - deg(lst[1])); see Theorem 2 in reference.
+    lcf = LC(lst[0])**( degree(lst[0], x) - degree(lst[1], x) )
+
+    # Initialize the subresultant prs list
+    subr_seq = [lst[0], lst[1]]
+
+    # compute the degree sequences m_i and j_i of Theorem 2 in reference.
+    deg_seq = [degree(Poly(poly, x), x) for poly in lst]
+    deg = deg_seq[0]
+    deg_seq_s = deg_seq[1:-1]
+    m_seq = [m-1 for m in deg_seq_s]
+    j_seq = [deg - m for m in m_seq]
+
+    # compute the AMV factors of Theorem 2 in reference.
+    fact = [(-1)**( j*(j-1)/S(2) ) for j in j_seq]
+
+    # shortened list without the first two polys
+    lst_s = lst[2:]
+
+    # poly lst_s[k] is multiplied times fact[k], divided by lcf
+    # and appended to the subresultant prs list
+    m = len(fact)
+    for k in range(m):
+        if sign(fact[k]) == -1:
+            subr_seq.append(-lst_s[k] / lcf)
+        else:
+            subr_seq.append(lst_s[k] / lcf)
+
+    return subr_seq
+
+def subresultants_amv_q(p, q, x):
+    """
+    p, q are polynomials in Z[x] or Q[x]. It is assumed
+    that degree(p, x) >= degree(q, x).
+
+    Computes the subresultant prs of p and q in Q[x];
+    the coefficients of the polynomials in the sequence are
+    subresultants. That is, they are  determinants of appropriately
+    selected submatrices of sylvester1, Sylvester's matrix of 1840.
+
+    To compute the coefficients, no determinant evaluation takes place.
+    Instead, polynomial divisions in Q[x] are performed, using the
+    function rem(p, q, x);  the coefficients of the remainders
+    computed this way become subresultants with the help of the
+    Akritas-Malaschonok-Vigklas Theorem of 2015.
+
+    If the subresultant prs is complete, then it coincides with the
+    Euclidean sequence of the polynomials p, q.
+
+    References
+    ==========
+    1. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``A Basic Result
+    on the Theory of Subresultants.'' Serdica Journal of Computing 10 (2016), No.1, 31-48.
+
+    2. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``Subresultant Polynomial
+    remainder Sequences Obtained by Polynomial Divisions in Q[x] or in Z[x].''
+    Serdica Journal of Computing 10 (2016), No.3-4, 197-217.
+
+    """
+    # make sure neither p nor q is 0
+    if p == 0 or q == 0:
+        return [p, q]
+
+    # make sure proper degrees
+    d0 =  degree(p, x)
+    d1 =  degree(q, x)
+    if d0 == 0 and d1 == 0:
+        return [p, q]
+    if d1 > d0:
+        d0, d1 = d1, d0
+        p, q = q, p
+    if d0 > 0 and d1 == 0:
+        return [p, q]
+
+    # initialize
+    i, s = 0, 0                              # counters for remainders & odd elements
+    p_odd_index_sum = 0                      # contains the sum of p_1, p_3, etc
+    subres_l = [p, q]                        # subresultant prs output list
+    a0, a1 = p, q                            # the input polys
+    sigma1 =  LC(a1, x)                      # leading coeff of a1
+    p0 = d0 - d1                             # degree difference
+    if p0 % 2 == 1:
+        s += 1
+    phi = floor( (s + 1) / 2 )
+    mul_fac = 1
+    d2 = d1
+
+    # main loop
+    while d2 > 0:
+        i += 1
+        a2 = rem(a0, a1, domain= QQ)          # new remainder
+        if i == 1:
+            sigma2 =  LC(a2, x)
+        else:
+            sigma3 =  LC(a2, x)
+            sigma1, sigma2 = sigma2, sigma3
+        d2 =  degree(a2, x)
+        p1 = d1 - d2
+        psi = i + phi + p_odd_index_sum
+
+        # new mul_fac
+        mul_fac = sigma1**(p0 + 1) * mul_fac
+
+        ## compute the sign of the first fraction in formula (9) of the paper
+        # numerator
+        num = (-1)**psi
+        # denominator
+        den = sign(mul_fac)
+
+        # the sign of the determinant depends on sign( num / den ) != 0
+        if  sign(num / den) > 0:
+            subres_l.append( simplify(expand(a2* Abs(mul_fac))))
+        else:
+            subres_l.append(- simplify(expand(a2* Abs(mul_fac))))
+
+        ## bring into mul_fac the missing power of sigma if there was a degree gap
+        if p1 - 1 > 0:
+            mul_fac = mul_fac * sigma1**(p1 - 1)
+
+       # update AMV variables
+        a0, a1, d0, d1 = a1, a2, d1, d2
+        p0 = p1
+        if p0 % 2 ==1:
+            s += 1
+        phi = floor( (s + 1) / 2 )
+        if i%2 == 1:
+            p_odd_index_sum += p0             # p_i has odd index
+
+    # gcd is of degree > 0 ?
+    m = len(subres_l)
+    if subres_l[m - 1] == nan or subres_l[m - 1] == 0:
+        subres_l.pop(m - 1)
+
+    return  subres_l
+
+def compute_sign(base, expo):
+    '''
+    base != 0 and expo >= 0 are integers;
+
+    returns the sign of base**expo without
+    evaluating the power itself!
+    '''
+    sb = sign(base)
+    if sb == 1:
+        return 1
+    pe = expo % 2
+    if pe == 0:
+        return -sb
+    else:
+        return sb
+
+def rem_z(p, q, x):
+    '''
+    Intended mainly for p, q polynomials in Z[x] so that,
+    on dividing p by q, the remainder will also be in Z[x]. (However,
+    it also works fine for polynomials in Q[x].) It is assumed
+    that degree(p, x) >= degree(q, x).
+
+    It premultiplies p by the _absolute_ value of the leading coefficient
+    of q, raised to the power deg(p) - deg(q) + 1 and then performs
+    polynomial division in Q[x], using the function rem(p, q, x).
+
+    By contrast the function prem(p, q, x) does _not_ use the absolute
+    value of the leading coefficient of q.
+    This results not only in ``messing up the signs'' of the Euclidean and
+    Sturmian prs's as mentioned in the second reference,
+    but also in violation of the main results of the first and third
+    references --- Theorem 4 and Theorem 1 respectively. Theorems 4 and 1
+    establish a one-to-one correspondence between the Euclidean and the
+    Sturmian prs of p, q, on one hand, and the subresultant prs of p, q,
+    on the other.
+
+    References
+    ==========
+    1. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``On the Remainders
+    Obtained in Finding the Greatest Common Divisor of Two Polynomials.''
+    Serdica Journal of Computing, 9(2) (2015), 123-138.
+
+    2. https://planetMath.org/sturmstheorem
+
+    3. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``A Basic Result on
+    the Theory of Subresultants.'' Serdica Journal of Computing 10 (2016), No.1, 31-48.
+
+    '''
+    if (p.as_poly().is_univariate and q.as_poly().is_univariate and
+            p.as_poly().gens == q.as_poly().gens):
+        delta = (degree(p, x) - degree(q, x) + 1)
+        return rem(Abs(LC(q, x))**delta  *  p, q, x)
+    else:
+        return prem(p, q, x)
+
+def quo_z(p, q, x):
+    """
+    Intended mainly for p, q polynomials in Z[x] so that,
+    on dividing p by q, the quotient will also be in Z[x]. (However,
+    it also works fine for polynomials in Q[x].) It is assumed
+    that degree(p, x) >= degree(q, x).
+
+    It premultiplies p by the _absolute_ value of the leading coefficient
+    of q, raised to the power deg(p) - deg(q) + 1 and then performs
+    polynomial division in Q[x], using the function quo(p, q, x).
+
+    By contrast the function pquo(p, q, x) does _not_ use the absolute
+    value of the leading coefficient of q.
+
+    See also function rem_z(p, q, x) for additional comments and references.
+
+    """
+    if (p.as_poly().is_univariate and q.as_poly().is_univariate and
+            p.as_poly().gens == q.as_poly().gens):
+        delta = (degree(p, x) - degree(q, x) + 1)
+        return quo(Abs(LC(q, x))**delta  *  p, q, x)
+    else:
+        return pquo(p, q, x)
+
+def subresultants_amv(f, g, x):
+    """
+    p, q are polynomials in Z[x] or Q[x]. It is assumed
+    that degree(f, x) >= degree(g, x).
+
+    Computes the subresultant prs of p and q in Z[x] or Q[x];
+    the coefficients of the polynomials in the sequence are
+    subresultants. That is, they are  determinants of appropriately
+    selected submatrices of sylvester1, Sylvester's matrix of 1840.
+
+    To compute the coefficients, no determinant evaluation takes place.
+    Instead, polynomial divisions in Z[x] or Q[x] are performed, using
+    the function rem_z(p, q, x);  the coefficients of the remainders
+    computed this way become subresultants with the help of the
+    Akritas-Malaschonok-Vigklas Theorem of 2015 and the Collins-Brown-
+    Traub formula for coefficient reduction.
+
+    If the subresultant prs is complete, then it coincides with the
+    Euclidean sequence of the polynomials p, q.
+
+    References
+    ==========
+    1. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``A Basic Result
+    on the Theory of Subresultants.'' Serdica Journal of Computing 10 (2016), No.1, 31-48.
+
+    2. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``Subresultant Polynomial
+    remainder Sequences Obtained by Polynomial Divisions in Q[x] or in Z[x].''
+    Serdica Journal of Computing 10 (2016), No.3-4, 197-217.
+
+    """
+    # make sure neither f nor g is 0
+    if f == 0 or g == 0:
+        return [f, g]
+
+    # make sure proper degrees
+    d0 =  degree(f, x)
+    d1 =  degree(g, x)
+    if d0 == 0 and d1 == 0:
+        return [f, g]
+    if d1 > d0:
+        d0, d1 = d1, d0
+        f, g = g, f
+    if d0 > 0 and d1 == 0:
+        return [f, g]
+
+    # initialize
+    a0 = f
+    a1 = g
+    subres_l = [a0, a1]
+    deg_dif_p1, c = degree(a0, x) - degree(a1, x) + 1, -1
+
+    # initialize AMV variables
+    sigma1 =  LC(a1, x)                      # leading coeff of a1
+    i, s = 0, 0                              # counters for remainders & odd elements
+    p_odd_index_sum = 0                      # contains the sum of p_1, p_3, etc
+    p0 = deg_dif_p1 - 1
+    if p0 % 2 == 1:
+        s += 1
+    phi = floor( (s + 1) / 2 )
+
+    # compute the first polynomial of the prs
+    i += 1
+    a2 = rem_z(a0, a1, x) / Abs( (-1)**deg_dif_p1 )     # first remainder
+    sigma2 =  LC(a2, x)                       # leading coeff of a2
+    d2 =  degree(a2, x)                       # actual degree of a2
+    p1 = d1 - d2                              # degree difference
+
+    # sgn_den is the factor, the denominator 1st fraction of (9),
+    # by which a2 is multiplied to get integer coefficients
+    sgn_den = compute_sign( sigma1, p0 + 1 )
+
+    ## compute sign of the 1st fraction in formula (9) of the paper
+    # numerator
+    psi = i + phi + p_odd_index_sum
+    num = (-1)**psi
+    # denominator
+    den = sgn_den
+
+    # the sign of the determinant depends on sign(num / den) != 0
+    if  sign(num / den) > 0:
+        subres_l.append( a2 )
+    else:
+        subres_l.append( -a2 )
+
+    # update AMV variable
+    if p1 % 2 == 1:
+        s += 1
+
+    # bring in the missing power of sigma if there was gap
+    if p1 - 1 > 0:
+        sgn_den = sgn_den * compute_sign( sigma1, p1 - 1 )
+
+    # main loop
+    while d2 >= 1:
+        phi = floor( (s + 1) / 2 )
+        if i%2 == 1:
+            p_odd_index_sum += p1             # p_i has odd index
+        a0, a1, d0, d1 = a1, a2, d1, d2       # update polys and degrees
+        p0 = p1                               # update degree difference
+        i += 1
+        sigma0 = -LC(a0)
+        c = (sigma0**(deg_dif_p1 - 1)) / (c**(deg_dif_p1 - 2))
+        deg_dif_p1 = degree(a0, x) - d2 + 1
+        a2 = rem_z(a0, a1, x) / Abs( (c**(deg_dif_p1 - 1)) * sigma0 )
+        sigma3 =  LC(a2, x)                   # leading coeff of a2
+        d2 =  degree(a2, x)                   # actual degree of a2
+        p1 = d1 - d2                          # degree difference
+        psi = i + phi + p_odd_index_sum
+
+        # update variables
+        sigma1, sigma2 = sigma2, sigma3
+
+        # new sgn_den
+        sgn_den = compute_sign( sigma1, p0 + 1 ) * sgn_den
+
+        # compute the sign of the first fraction in formula (9) of the paper
+        # numerator
+        num = (-1)**psi
+        # denominator
+        den = sgn_den
+
+        # the sign of the determinant depends on sign( num / den ) != 0
+        if  sign(num / den) > 0:
+            subres_l.append( a2 )
+        else:
+            subres_l.append( -a2 )
+
+        # update AMV variable
+        if p1 % 2 ==1:
+            s += 1
+
+        # bring in the missing power of sigma if there was gap
+        if p1 - 1 > 0:
+            sgn_den = sgn_den * compute_sign( sigma1, p1 - 1 )
+
+    # gcd is of degree > 0 ?
+    m = len(subres_l)
+    if subres_l[m - 1] == nan or subres_l[m - 1] == 0:
+        subres_l.pop(m - 1)
+
+    return subres_l
+
+def modified_subresultants_amv(p, q, x):
+    """
+    p, q are polynomials in Z[x] or Q[x]. It is assumed
+    that degree(p, x) >= degree(q, x).
+
+    Computes the modified subresultant prs of p and q in Z[x] or Q[x],
+    from the subresultant prs of p and q.
+    The coefficients of the polynomials in the two sequences differ only
+    in sign and the factor LC(p)**( deg(p)- deg(q)) as stated in
+    Theorem 2 of the reference.
+
+    The coefficients of the polynomials in the output sequence are
+    modified subresultants. That is, they are  determinants of appropriately
+    selected submatrices of sylvester2, Sylvester's matrix of 1853.
+
+    If the modified subresultant prs is complete, and LC( p ) > 0, it coincides
+    with the (generalized) Sturm's sequence of the polynomials p, q.
+
+    References
+    ==========
+    1. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: "On the Remainders
+    Obtained in Finding the Greatest Common Divisor of Two Polynomials."
+    Serdica Journal of Computing, Serdica Journal of Computing, 9(2) (2015), 123-138.
+
+    """
+    # compute the subresultant prs
+    lst = subresultants_amv(p,q,x)     ## any other method would do
+
+    # defensive
+    if lst == [] or len(lst) == 2:
+        return lst
+
+    # the coefficients in lst are subresultants and, hence, smaller than those
+    # of the corresponding modified subresultants by the factor
+    # LC(lst[0])**( deg(lst[0]) - deg(lst[1])); see Theorem 2.
+    lcf = LC(lst[0])**( degree(lst[0], x) - degree(lst[1], x) )
+
+    # Initialize the modified subresultant prs list
+    subr_seq = [lst[0], lst[1]]
+
+    # compute the degree sequences m_i and j_i of Theorem 2
+    deg_seq = [degree(Poly(poly, x), x) for poly in lst]
+    deg = deg_seq[0]
+    deg_seq_s = deg_seq[1:-1]
+    m_seq = [m-1 for m in deg_seq_s]
+    j_seq = [deg - m for m in m_seq]
+
+    # compute the AMV factors of Theorem 2
+    fact = [(-1)**( j*(j-1)/S(2) ) for j in j_seq]
+
+    # shortened list without the first two polys
+    lst_s = lst[2:]
+
+    # poly lst_s[k] is multiplied times fact[k] and times lcf
+    # and appended to the subresultant prs list
+    m = len(fact)
+    for k in range(m):
+        if sign(fact[k]) == -1:
+            subr_seq.append( simplify(-lst_s[k] * lcf) )
+        else:
+            subr_seq.append( simplify(lst_s[k] * lcf) )
+
+    return subr_seq
+
+def correct_sign(deg_f, deg_g, s1, rdel, cdel):
+    """
+    Used in various subresultant prs algorithms.
+
+    Evaluates the determinant, (a.k.a. subresultant) of a properly selected
+    submatrix of s1, Sylvester's matrix of 1840, to get the correct sign
+    and value of the leading coefficient of a given polynomial remainder.
+
+    deg_f, deg_g are the degrees of the original polynomials p, q for which the
+    matrix s1 = sylvester(p, q, x, 1) was constructed.
+
+    rdel denotes the expected degree of the remainder; it is the number of
+    rows to be deleted from each group of rows in s1 as described in the
+    reference below.
+
+    cdel denotes the expected degree minus the actual degree of the remainder;
+    it is the number of columns to be deleted --- starting with the last column
+    forming the square matrix --- from the matrix resulting after the row deletions.
+
+    References
+    ==========
+    Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``Sturm Sequences
+    and Modified Subresultant Polynomial Remainder Sequences.''
+    Serdica Journal of Computing, Vol. 8, No 1, 29-46, 2014.
+
+    """
+    M = s1[:, :]   # copy of matrix s1
+
+    # eliminate rdel rows from the first deg_g rows
+    for i in range(M.rows - deg_f - 1, M.rows - deg_f - rdel - 1, -1):
+        M.row_del(i)
+
+    # eliminate rdel rows from the last deg_f rows
+    for i in range(M.rows - 1, M.rows - rdel - 1, -1):
+        M.row_del(i)
+
+    # eliminate cdel columns
+    for i in range(cdel):
+        M.col_del(M.rows - 1)
+
+    # define submatrix
+    Md = M[:, 0: M.rows]
+
+    return Md.det()
+
+def subresultants_rem(p, q, x):
+    """
+    p, q are polynomials in Z[x] or Q[x]. It is assumed
+    that degree(p, x) >= degree(q, x).
+
+    Computes the subresultant prs of p and q in Z[x] or Q[x];
+    the coefficients of the polynomials in the sequence are
+    subresultants. That is, they are  determinants of appropriately
+    selected submatrices of sylvester1, Sylvester's matrix of 1840.
+
+    To compute the coefficients polynomial divisions in Q[x] are
+    performed, using the function rem(p, q, x). The coefficients
+    of the remainders computed this way become subresultants by evaluating
+    one subresultant per remainder --- that of the leading coefficient.
+    This way we obtain the correct sign and value of the leading coefficient
+    of the remainder and we easily ``force'' the rest of the coefficients
+    to become subresultants.
+
+    If the subresultant prs is complete, then it coincides with the
+    Euclidean sequence of the polynomials p, q.
+
+    References
+    ==========
+    1. Akritas, A. G.:``Three New Methods for Computing Subresultant
+    Polynomial Remainder Sequences (PRS's).'' Serdica Journal of Computing 9(1) (2015), 1-26.
+
+    """
+    # make sure neither p nor q is 0
+    if p == 0 or q == 0:
+        return [p, q]
+
+    # make sure proper degrees
+    f, g = p, q
+    n = deg_f = degree(f, x)
+    m = deg_g = degree(g, x)
+    if n == 0 and m == 0:
+        return [f, g]
+    if n < m:
+        n, m, deg_f, deg_g, f, g = m, n, deg_g, deg_f, g, f
+    if n > 0 and m == 0:
+        return [f, g]
+
+    # initialize
+    s1 = sylvester(f, g, x, 1)
+    sr_list = [f, g]      # subresultant list
+
+    # main loop
+    while deg_g > 0:
+        r = rem(p, q, x)
+        d = degree(r, x)
+        if d < 0:
+            return sr_list
+
+        # make coefficients subresultants evaluating ONE determinant
+        exp_deg = deg_g - 1          # expected degree
+        sign_value = correct_sign(n, m, s1, exp_deg, exp_deg - d)
+        r = simplify((r / LC(r, x)) * sign_value)
+
+        # append poly with subresultant coeffs
+        sr_list.append(r)
+
+        # update degrees and polys
+        deg_f, deg_g = deg_g, d
+        p, q = q, r
+
+    # gcd is of degree > 0 ?
+    m = len(sr_list)
+    if sr_list[m - 1] == nan or sr_list[m - 1] == 0:
+        sr_list.pop(m - 1)
+
+    return sr_list
+
+def pivot(M, i, j):
+    '''
+    M is a matrix, and M[i, j] specifies the pivot element.
+
+    All elements below M[i, j], in the j-th column, will
+    be zeroed, if they are not already 0, according to
+    Dodgson-Bareiss' integer preserving transformations.
+
+    References
+    ==========
+    1. Akritas, A. G.: ``A new method for computing polynomial greatest
+    common divisors and polynomial remainder sequences.''
+    Numerische MatheMatik 52, 119-127, 1988.
+
+    2. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``On a Theorem
+    by Van Vleck Regarding Sturm Sequences.''
+    Serdica Journal of Computing, 7, No 4, 101-134, 2013.
+
+    '''
+    ma = M[:, :] # copy of matrix M
+    rs = ma.rows # No. of rows
+    cs = ma.cols # No. of cols
+    for r in range(i+1, rs):
+        if ma[r, j] != 0:
+            for c in range(j + 1, cs):
+                ma[r, c] = ma[i, j] * ma[r, c] - ma[i, c] * ma[r, j]
+            ma[r, j] = 0
+    return ma
+
+def rotate_r(L, k):
+    '''
+    Rotates right by k. L is a row of a matrix or a list.
+
+    '''
+    ll = list(L)
+    if ll == []:
+        return []
+    for i in range(k):
+        el = ll.pop(len(ll) - 1)
+        ll.insert(0, el)
+    return ll if isinstance(L, list) else Matrix([ll])
+
+def rotate_l(L, k):
+    '''
+    Rotates left by k. L is a row of a matrix or a list.
+
+    '''
+    ll = list(L)
+    if ll == []:
+        return []
+    for i in range(k):
+        el = ll.pop(0)
+        ll.insert(len(ll) - 1, el)
+    return ll if isinstance(L, list) else Matrix([ll])
+
+def row2poly(row, deg, x):
+    '''
+    Converts the row of a matrix to a poly of degree deg and variable x.
+    Some entries at the beginning and/or at the end of the row may be zero.
+
+    '''
+    k = 0
+    poly = []
+    leng = len(row)
+
+    # find the beginning of the poly ; i.e. the first
+    # non-zero element of the row
+    while row[k] == 0:
+        k = k + 1
+
+    # append the next deg + 1 elements to poly
+    for j in range( deg + 1):
+        if k + j <= leng:
+            poly.append(row[k + j])
+
+    return Poly(poly, x)
+
+def create_ma(deg_f, deg_g, row1, row2, col_num):
+    '''
+    Creates a ``small'' matrix M to be triangularized.
+
+    deg_f, deg_g are the degrees of the divident and of the
+    divisor polynomials respectively, deg_g > deg_f.
+
+    The coefficients of the divident poly are the elements
+    in row2 and those of the divisor poly are the elements
+    in row1.
+
+    col_num defines the number of columns of the matrix M.
+
+    '''
+    if deg_g - deg_f >= 1:
+        print('Reverse degrees')
+        return
+
+    m = zeros(deg_f - deg_g + 2, col_num)
+
+    for i in range(deg_f - deg_g + 1):
+        m[i, :] = rotate_r(row1, i)
+    m[deg_f - deg_g + 1, :] = row2
+
+    return m
+
+def find_degree(M, deg_f):
+    '''
+    Finds the degree of the poly corresponding (after triangularization)
+    to the _last_ row of the ``small'' matrix M, created by create_ma().
+
+    deg_f is the degree of the divident poly.
+    If _last_ row is all 0's returns None.
+
+    '''
+    j = deg_f
+    for i in range(0, M.cols):
+        if M[M.rows - 1, i] == 0:
+            j = j - 1
+        else:
+            return j if j >= 0 else 0
+
+def final_touches(s2, r, deg_g):
+    """
+    s2 is sylvester2, r is the row pointer in s2,
+    deg_g is the degree of the poly last inserted in s2.
+
+    After a gcd of degree > 0 has been found with Van Vleck's
+    method, and was inserted into s2, if its last term is not
+    in the last column of s2, then it is inserted as many
+    times as needed, rotated right by one each time, until
+    the condition is met.
+
+    """
+    R = s2.row(r-1)
+
+    # find the first non zero term
+    for i in range(s2.cols):
+        if R[0,i] == 0:
+            continue
+        else:
+            break
+
+    # missing rows until last term is in last column
+    mr = s2.cols - (i + deg_g + 1)
+
+    # insert them by replacing the existing entries in the row
+    i = 0
+    while mr != 0 and r + i < s2.rows :
+        s2[r + i, : ] = rotate_r(R, i + 1)
+        i += 1
+        mr -= 1
+
+    return s2
+
+def subresultants_vv(p, q, x, method = 0):
+    """
+    p, q are polynomials in Z[x] (intended) or Q[x]. It is assumed
+    that degree(p, x) >= degree(q, x).
+
+    Computes the subresultant prs of p, q by triangularizing,
+    in Z[x] or in Q[x], all the smaller matrices encountered in the
+    process of triangularizing sylvester2, Sylvester's matrix of 1853;
+    see references 1 and 2 for Van Vleck's method. With each remainder,
+    sylvester2 gets updated and is prepared to be printed if requested.
+
+    If sylvester2 has small dimensions and you want to see the final,
+    triangularized matrix use this version with method=1; otherwise,
+    use either this version with method=0 (default) or the faster version,
+    subresultants_vv_2(p, q, x), where sylvester2 is used implicitly.
+
+    Sylvester's matrix sylvester1  is also used to compute one
+    subresultant per remainder; namely, that of the leading
+    coefficient, in order to obtain the correct sign and to
+    force the remainder coefficients to become subresultants.
+
+    If the subresultant prs is complete, then it coincides with the
+    Euclidean sequence of the polynomials p, q.
+
+    If the final, triangularized matrix s2 is printed, then:
+        (a) if deg(p) - deg(q) > 1 or deg( gcd(p, q) ) > 0, several
+            of the last rows in s2 will remain unprocessed;
+        (b) if deg(p) - deg(q) == 0, p will not appear in the final matrix.
+
+    References
+    ==========
+    1. Akritas, A. G.: ``A new method for computing polynomial greatest
+    common divisors and polynomial remainder sequences.''
+    Numerische MatheMatik 52, 119-127, 1988.
+
+    2. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``On a Theorem
+    by Van Vleck Regarding Sturm Sequences.''
+    Serdica Journal of Computing, 7, No 4, 101-134, 2013.
+
+    3. Akritas, A. G.:``Three New Methods for Computing Subresultant
+    Polynomial Remainder Sequences (PRS's).'' Serdica Journal of Computing 9(1) (2015), 1-26.
+
+    """
+    # make sure neither p nor q is 0
+    if p == 0 or q == 0:
+        return [p, q]
+
+    # make sure proper degrees
+    f, g = p, q
+    n = deg_f = degree(f, x)
+    m = deg_g = degree(g, x)
+    if n == 0 and m == 0:
+        return [f, g]
+    if n < m:
+        n, m, deg_f, deg_g, f, g = m, n, deg_g, deg_f, g, f
+    if n > 0 and m == 0:
+        return [f, g]
+
+    # initialize
+    s1 = sylvester(f, g, x, 1)
+    s2 = sylvester(f, g, x, 2)
+    sr_list = [f, g]
+    col_num = 2 * n         # columns in s2
+
+    # make two rows (row0, row1) of poly coefficients
+    row0 = Poly(f, x, domain = QQ).all_coeffs()
+    leng0 = len(row0)
+    for i in range(col_num - leng0):
+        row0.append(0)
+    row0 = Matrix([row0])
+    row1 = Poly(g,x, domain = QQ).all_coeffs()
+    leng1 = len(row1)
+    for i in range(col_num - leng1):
+        row1.append(0)
+    row1 = Matrix([row1])
+
+    # row pointer for deg_f - deg_g == 1; may be reset below
+    r = 2
+
+    # modify first rows of s2 matrix depending on poly degrees
+    if deg_f - deg_g > 1:
+        r = 1
+        # replacing the existing entries in the rows of s2,
+        # insert row0 (deg_f - deg_g - 1) times, rotated each time
+        for i in range(deg_f - deg_g - 1):
+            s2[r + i, : ] = rotate_r(row0, i + 1)
+        r = r + deg_f - deg_g - 1
+        # insert row1 (deg_f - deg_g) times, rotated each time
+        for i in range(deg_f - deg_g):
+            s2[r + i, : ] = rotate_r(row1, r + i)
+        r = r + deg_f - deg_g
+
+    if deg_f - deg_g == 0:
+        r = 0
+
+    # main loop
+    while deg_g > 0:
+        # create a small matrix M, and triangularize it;
+        M = create_ma(deg_f, deg_g, row1, row0, col_num)
+        # will need only the first and last rows of M
+        for i in range(deg_f - deg_g + 1):
+            M1 = pivot(M, i, i)
+            M = M1[:, :]
+
+        # treat last row of M as poly; find its degree
+        d = find_degree(M, deg_f)
+        if d is None:
+            break
+        exp_deg = deg_g - 1
+
+        # evaluate one determinant & make coefficients subresultants
+        sign_value = correct_sign(n, m, s1, exp_deg, exp_deg - d)
+        poly = row2poly(M[M.rows - 1, :], d, x)
+        temp2 = LC(poly, x)
+        poly = simplify((poly / temp2) * sign_value)
+
+        # update s2 by inserting first row of M as needed
+        row0 = M[0, :]
+        for i in range(deg_g - d):
+            s2[r + i, :] = rotate_r(row0, r + i)
+        r = r + deg_g - d
+
+        # update s2 by inserting last row of M as needed
+        row1 = rotate_l(M[M.rows - 1, :], deg_f - d)
+        row1 = (row1 / temp2) * sign_value
+        for i in range(deg_g - d):
+            s2[r + i, :] = rotate_r(row1, r + i)
+        r = r + deg_g - d
+
+        # update degrees
+        deg_f, deg_g = deg_g, d
+
+        # append poly with subresultant coeffs
+        sr_list.append(poly)
+
+    # final touches to print the s2 matrix
+    if method != 0 and s2.rows > 2:
+        s2 = final_touches(s2, r, deg_g)
+        pprint(s2)
+    elif method != 0 and s2.rows == 2:
+        s2[1, :] = rotate_r(s2.row(1), 1)
+        pprint(s2)
+
+    return sr_list
+
+def subresultants_vv_2(p, q, x):
+    """
+    p, q are polynomials in Z[x] (intended) or Q[x]. It is assumed
+    that degree(p, x) >= degree(q, x).
+
+    Computes the subresultant prs of p, q by triangularizing,
+    in Z[x] or in Q[x], all the smaller matrices encountered in the
+    process of triangularizing sylvester2, Sylvester's matrix of 1853;
+    see references 1 and 2 for Van Vleck's method.
+
+    If the sylvester2 matrix has big dimensions use this version,
+    where sylvester2 is used implicitly. If you want to see the final,
+    triangularized matrix sylvester2, then use the first version,
+    subresultants_vv(p, q, x, 1).
+
+    sylvester1, Sylvester's matrix of 1840, is also used to compute
+    one subresultant per remainder; namely, that of the leading
+    coefficient, in order to obtain the correct sign and to
+    ``force'' the remainder coefficients to become subresultants.
+
+    If the subresultant prs is complete, then it coincides with the
+    Euclidean sequence of the polynomials p, q.
+
+    References
+    ==========
+    1. Akritas, A. G.: ``A new method for computing polynomial greatest
+    common divisors and polynomial remainder sequences.''
+    Numerische MatheMatik 52, 119-127, 1988.
+
+    2. Akritas, A. G., G.I. Malaschonok and P.S. Vigklas: ``On a Theorem
+    by Van Vleck Regarding Sturm Sequences.''
+    Serdica Journal of Computing, 7, No 4, 101-134, 2013.
+
+    3. Akritas, A. G.:``Three New Methods for Computing Subresultant
+    Polynomial Remainder Sequences (PRS's).'' Serdica Journal of Computing 9(1) (2015), 1-26.
+
+    """
+    # make sure neither p nor q is 0
+    if p == 0 or q == 0:
+        return [p, q]
+
+    # make sure proper degrees
+    f, g = p, q
+    n = deg_f = degree(f, x)
+    m = deg_g = degree(g, x)
+    if n == 0 and m == 0:
+        return [f, g]
+    if n < m:
+        n, m, deg_f, deg_g, f, g = m, n, deg_g, deg_f, g, f
+    if n > 0 and m == 0:
+        return [f, g]
+
+    # initialize
+    s1 = sylvester(f, g, x, 1)
+    sr_list = [f, g]      # subresultant list
+    col_num = 2 * n       # columns in sylvester2
+
+    # make two rows (row0, row1) of poly coefficients
+    row0 = Poly(f, x, domain = QQ).all_coeffs()
+    leng0 = len(row0)
+    for i in range(col_num - leng0):
+        row0.append(0)
+    row0 = Matrix([row0])
+    row1 = Poly(g,x, domain = QQ).all_coeffs()
+    leng1 = len(row1)
+    for i in range(col_num - leng1):
+        row1.append(0)
+    row1 = Matrix([row1])
+
+    # main loop
+    while deg_g > 0:
+        # create a small matrix M, and triangularize it
+        M = create_ma(deg_f, deg_g, row1, row0, col_num)
+        for i in range(deg_f - deg_g + 1):
+            M1 = pivot(M, i, i)
+            M = M1[:, :]
+
+        # treat last row of M as poly; find its degree
+        d = find_degree(M, deg_f)
+        if d is None:
+            return sr_list
+        exp_deg = deg_g - 1
+
+        # evaluate one determinant & make coefficients subresultants
+        sign_value = correct_sign(n, m, s1, exp_deg, exp_deg - d)
+        poly = row2poly(M[M.rows - 1, :], d, x)
+        poly = simplify((poly / LC(poly, x)) * sign_value)
+
+        # append poly with subresultant coeffs
+        sr_list.append(poly)
+
+        # update degrees and rows
+        deg_f, deg_g = deg_g, d
+        row0 = row1
+        row1 = Poly(poly, x, domain = QQ).all_coeffs()
+        leng1 = len(row1)
+        for i in range(col_num - leng1):
+            row1.append(0)
+        row1 = Matrix([row1])
+
+    return sr_list
diff --git a/evalkit_tf437/lib/python3.10/site-packages/google_auth_oauthlib-1.2.1.dist-info/INSTALLER b/evalkit_tf437/lib/python3.10/site-packages/google_auth_oauthlib-1.2.1.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/google_auth_oauthlib-1.2.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/evalkit_tf437/lib/python3.10/site-packages/google_auth_oauthlib-1.2.1.dist-info/LICENSE b/evalkit_tf437/lib/python3.10/site-packages/google_auth_oauthlib-1.2.1.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..d645695673349e3947e8e5ae42332d0ac3164cd7
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/google_auth_oauthlib-1.2.1.dist-info/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/evalkit_tf437/lib/python3.10/site-packages/google_auth_oauthlib-1.2.1.dist-info/RECORD b/evalkit_tf437/lib/python3.10/site-packages/google_auth_oauthlib-1.2.1.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..3bc149552bf2ed641ad7f527a1baf6b2540bf0c1
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/google_auth_oauthlib-1.2.1.dist-info/RECORD
@@ -0,0 +1,25 @@
+../../../bin/google-oauthlib-tool,sha256=qIYWEW14Nt91Yo9xkx8pY8HZ9ltd5KvSHTkDihB_K3w,252
+docs/__pycache__/conf.cpython-310.pyc,,
+docs/conf.py,sha256=mHrE7AszMLyV0BLDyRxat0Dvadx_k8lW-8PpZu9Wz4I,12421
+google_auth_oauthlib-1.2.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+google_auth_oauthlib-1.2.1.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+google_auth_oauthlib-1.2.1.dist-info/METADATA,sha256=xZAdF__2rk5uRgN8mkIG6CzHA23Ax0-tpJHMsECuVzA,2696
+google_auth_oauthlib-1.2.1.dist-info/RECORD,,
+google_auth_oauthlib-1.2.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+google_auth_oauthlib-1.2.1.dist-info/WHEEL,sha256=0XQbNV6JE5ziJsWjIU8TRRv0N6SohNonLWgP86g5fiI,109
+google_auth_oauthlib-1.2.1.dist-info/entry_points.txt,sha256=DL3GRTp3HgwLxdBZCPkz9o8sK9cnENZMmu09EzAovkk,88
+google_auth_oauthlib-1.2.1.dist-info/top_level.txt,sha256=1UIrxRzACA8j-HW3CjjUghyqzTMl5NOXgMwHPpTY-BU,42
+google_auth_oauthlib/__init__.py,sha256=TTUgKl-F0eTBxBmbwDwDbIN-L33LmD4JbNKwXE-HngU,846
+google_auth_oauthlib/__pycache__/__init__.cpython-310.pyc,,
+google_auth_oauthlib/__pycache__/flow.cpython-310.pyc,,
+google_auth_oauthlib/__pycache__/helpers.cpython-310.pyc,,
+google_auth_oauthlib/__pycache__/interactive.cpython-310.pyc,,
+google_auth_oauthlib/flow.py,sha256=EdWWBE6lCWdXhODkDyianOvzjAsofrZahCO3p6WuMpQ,19710
+google_auth_oauthlib/helpers.py,sha256=C6oIR1TZsizfH61SxdhaLI7utttHgI4Ww0tMrLhYnAY,5729
+google_auth_oauthlib/interactive.py,sha256=BW-L8FToU4iXf8Fd85U6kWJvjWSyS5FVvYvAIDe4NVM,6063
+google_auth_oauthlib/tool/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+google_auth_oauthlib/tool/__main__.py,sha256=BeX0cYaM50IInJ1c5U3ukxtuI9q1no-KIJhW7ynJBfs,3835
+google_auth_oauthlib/tool/__pycache__/__init__.cpython-310.pyc,,
+google_auth_oauthlib/tool/__pycache__/__main__.cpython-310.pyc,,
+scripts/readme-gen/__pycache__/readme_gen.cpython-310.pyc,,
+scripts/readme-gen/readme_gen.py,sha256=rLla3D5hsLF6rDhgQ-XrAbx8-gHYaYKp4Pf4h5td-UI,1750
diff --git a/evalkit_tf437/lib/python3.10/site-packages/google_auth_oauthlib-1.2.1.dist-info/REQUESTED b/evalkit_tf437/lib/python3.10/site-packages/google_auth_oauthlib-1.2.1.dist-info/REQUESTED
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/evalkit_tf437/lib/python3.10/site-packages/google_auth_oauthlib-1.2.1.dist-info/WHEEL b/evalkit_tf437/lib/python3.10/site-packages/google_auth_oauthlib-1.2.1.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..7601b88b4a3b444bfddeee3ddf1172c2629f4991
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/google_auth_oauthlib-1.2.1.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (70.2.0)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/evalkit_tf437/lib/python3.10/site-packages/google_auth_oauthlib-1.2.1.dist-info/entry_points.txt b/evalkit_tf437/lib/python3.10/site-packages/google_auth_oauthlib-1.2.1.dist-info/entry_points.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a33f32fa2ef02405f14d1457af1055e1e2fc44c4
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/google_auth_oauthlib-1.2.1.dist-info/entry_points.txt
@@ -0,0 +1,2 @@
+[console_scripts]
+google-oauthlib-tool = google_auth_oauthlib.tool.__main__:main [tool]
diff --git a/evalkit_tf437/lib/python3.10/site-packages/prompt_toolkit/input/__pycache__/vt100.cpython-310.pyc b/evalkit_tf437/lib/python3.10/site-packages/prompt_toolkit/input/__pycache__/vt100.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1e97c5afaaa2995a04fbc6c638bd960879b078bf
Binary files /dev/null and b/evalkit_tf437/lib/python3.10/site-packages/prompt_toolkit/input/__pycache__/vt100.cpython-310.pyc differ
diff --git a/evalkit_tf437/lib/python3.10/site-packages/prompt_toolkit/input/base.py b/evalkit_tf437/lib/python3.10/site-packages/prompt_toolkit/input/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..3dcb994bd95b4e7ed333374364e37cc7c0793110
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/prompt_toolkit/input/base.py
@@ -0,0 +1,153 @@
+"""
+Abstraction of CLI Input.
+"""
+
+from __future__ import annotations
+
+from abc import ABCMeta, abstractmethod, abstractproperty
+from contextlib import contextmanager
+from typing import Callable, ContextManager, Generator
+
+from prompt_toolkit.key_binding import KeyPress
+
+__all__ = [
+    "Input",
+    "PipeInput",
+    "DummyInput",
+]
+
+
+class Input(metaclass=ABCMeta):
+    """
+    Abstraction for any input.
+
+    An instance of this class can be given to the constructor of a
+    :class:`~prompt_toolkit.application.Application` and will also be
+    passed to the :class:`~prompt_toolkit.eventloop.base.EventLoop`.
+    """
+
+    @abstractmethod
+    def fileno(self) -> int:
+        """
+        Fileno for putting this in an event loop.
+        """
+
+    @abstractmethod
+    def typeahead_hash(self) -> str:
+        """
+        Identifier for storing type ahead key presses.
+        """
+
+    @abstractmethod
+    def read_keys(self) -> list[KeyPress]:
+        """
+        Return a list of Key objects which are read/parsed from the input.
+        """
+
+    def flush_keys(self) -> list[KeyPress]:
+        """
+        Flush the underlying parser. and return the pending keys.
+        (Used for vt100 input.)
+        """
+        return []
+
+    def flush(self) -> None:
+        "The event loop can call this when the input has to be flushed."
+        pass
+
+    @abstractproperty
+    def closed(self) -> bool:
+        "Should be true when the input stream is closed."
+        return False
+
+    @abstractmethod
+    def raw_mode(self) -> ContextManager[None]:
+        """
+        Context manager that turns the input into raw mode.
+        """
+
+    @abstractmethod
+    def cooked_mode(self) -> ContextManager[None]:
+        """
+        Context manager that turns the input into cooked mode.
+        """
+
+    @abstractmethod
+    def attach(self, input_ready_callback: Callable[[], None]) -> ContextManager[None]:
+        """
+        Return a context manager that makes this input active in the current
+        event loop.
+        """
+
+    @abstractmethod
+    def detach(self) -> ContextManager[None]:
+        """
+        Return a context manager that makes sure that this input is not active
+        in the current event loop.
+        """
+
+    def close(self) -> None:
+        "Close input."
+        pass
+
+
+class PipeInput(Input):
+    """
+    Abstraction for pipe input.
+    """
+
+    @abstractmethod
+    def send_bytes(self, data: bytes) -> None:
+        """Feed byte string into the pipe"""
+
+    @abstractmethod
+    def send_text(self, data: str) -> None:
+        """Feed a text string into the pipe"""
+
+
+class DummyInput(Input):
+    """
+    Input for use in a `DummyApplication`
+
+    If used in an actual application, it will make the application render
+    itself once and exit immediately, due to an `EOFError`.
+    """
+
+    def fileno(self) -> int:
+        raise NotImplementedError
+
+    def typeahead_hash(self) -> str:
+        return f"dummy-{id(self)}"
+
+    def read_keys(self) -> list[KeyPress]:
+        return []
+
+    @property
+    def closed(self) -> bool:
+        # This needs to be true, so that the dummy input will trigger an
+        # `EOFError` immediately in the application.
+        return True
+
+    def raw_mode(self) -> ContextManager[None]:
+        return _dummy_context_manager()
+
+    def cooked_mode(self) -> ContextManager[None]:
+        return _dummy_context_manager()
+
+    def attach(self, input_ready_callback: Callable[[], None]) -> ContextManager[None]:
+        # Call the callback immediately once after attaching.
+        # This tells the callback to call `read_keys` and check the
+        # `input.closed` flag, after which it won't receive any keys, but knows
+        # that `EOFError` should be raised. This unblocks `read_from_input` in
+        # `application.py`.
+        input_ready_callback()
+
+        return _dummy_context_manager()
+
+    def detach(self) -> ContextManager[None]:
+        return _dummy_context_manager()
+
+
+@contextmanager
+def _dummy_context_manager() -> Generator[None, None, None]:
+    yield
diff --git a/evalkit_tf437/lib/python3.10/site-packages/prompt_toolkit/shortcuts/progress_bar/__pycache__/__init__.cpython-310.pyc b/evalkit_tf437/lib/python3.10/site-packages/prompt_toolkit/shortcuts/progress_bar/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..efdacb788a3c7a9eeb77a41754d3a6631de2907d
Binary files /dev/null and b/evalkit_tf437/lib/python3.10/site-packages/prompt_toolkit/shortcuts/progress_bar/__pycache__/__init__.cpython-310.pyc differ
diff --git a/evalkit_tf437/lib/python3.10/site-packages/prompt_toolkit/shortcuts/progress_bar/__pycache__/formatters.cpython-310.pyc b/evalkit_tf437/lib/python3.10/site-packages/prompt_toolkit/shortcuts/progress_bar/__pycache__/formatters.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..73c104f56bb1ecd1f560b11777d4c9985f9294a9
Binary files /dev/null and b/evalkit_tf437/lib/python3.10/site-packages/prompt_toolkit/shortcuts/progress_bar/__pycache__/formatters.cpython-310.pyc differ
diff --git a/evalkit_tf437/lib/python3.10/site-packages/prompt_toolkit/shortcuts/progress_bar/base.py b/evalkit_tf437/lib/python3.10/site-packages/prompt_toolkit/shortcuts/progress_bar/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..a7c2a527d800b44cffa619bc9453382be09b8c87
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/prompt_toolkit/shortcuts/progress_bar/base.py
@@ -0,0 +1,449 @@
+"""
+Progress bar implementation on top of prompt_toolkit.
+
+::
+
+    with ProgressBar(...) as pb:
+        for item in pb(data):
+            ...
+"""
+
+from __future__ import annotations
+
+import contextvars
+import datetime
+import functools
+import os
+import signal
+import threading
+import traceback
+from typing import (
+    Callable,
+    Generic,
+    Iterable,
+    Iterator,
+    Sequence,
+    Sized,
+    TextIO,
+    TypeVar,
+    cast,
+)
+
+from prompt_toolkit.application import Application
+from prompt_toolkit.application.current import get_app_session
+from prompt_toolkit.filters import Condition, is_done, renderer_height_is_known
+from prompt_toolkit.formatted_text import (
+    AnyFormattedText,
+    StyleAndTextTuples,
+    to_formatted_text,
+)
+from prompt_toolkit.input import Input
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.key_binding.key_processor import KeyPressEvent
+from prompt_toolkit.layout import (
+    ConditionalContainer,
+    FormattedTextControl,
+    HSplit,
+    Layout,
+    VSplit,
+    Window,
+)
+from prompt_toolkit.layout.controls import UIContent, UIControl
+from prompt_toolkit.layout.dimension import AnyDimension, D
+from prompt_toolkit.output import ColorDepth, Output
+from prompt_toolkit.styles import BaseStyle
+from prompt_toolkit.utils import in_main_thread
+
+from .formatters import Formatter, create_default_formatters
+
+__all__ = ["ProgressBar"]
+
+E = KeyPressEvent
+
+_SIGWINCH = getattr(signal, "SIGWINCH", None)
+
+
+def create_key_bindings(cancel_callback: Callable[[], None] | None) -> KeyBindings:
+    """
+    Key bindings handled by the progress bar.
+    (The main thread is not supposed to handle any key bindings.)
+    """
+    kb = KeyBindings()
+
+    @kb.add("c-l")
+    def _clear(event: E) -> None:
+        event.app.renderer.clear()
+
+    if cancel_callback is not None:
+
+        @kb.add("c-c")
+        def _interrupt(event: E) -> None:
+            "Kill the 'body' of the progress bar, but only if we run from the main thread."
+            assert cancel_callback is not None
+            cancel_callback()
+
+    return kb
+
+
+_T = TypeVar("_T")
+
+
+class ProgressBar:
+    """
+    Progress bar context manager.
+
+    Usage ::
+
+        with ProgressBar(...) as pb:
+            for item in pb(data):
+                ...
+
+    :param title: Text to be displayed above the progress bars. This can be a
+        callable or formatted text as well.
+    :param formatters: List of :class:`.Formatter` instances.
+    :param bottom_toolbar: Text to be displayed in the bottom toolbar. This
+        can be a callable or formatted text.
+    :param style: :class:`prompt_toolkit.styles.BaseStyle` instance.
+    :param key_bindings: :class:`.KeyBindings` instance.
+    :param cancel_callback: Callback function that's called when control-c is
+        pressed by the user. This can be used for instance to start "proper"
+        cancellation if the wrapped code supports it.
+    :param file: The file object used for rendering, by default `sys.stderr` is used.
+
+    :param color_depth: `prompt_toolkit` `ColorDepth` instance.
+    :param output: :class:`~prompt_toolkit.output.Output` instance.
+    :param input: :class:`~prompt_toolkit.input.Input` instance.
+    """
+
+    def __init__(
+        self,
+        title: AnyFormattedText = None,
+        formatters: Sequence[Formatter] | None = None,
+        bottom_toolbar: AnyFormattedText = None,
+        style: BaseStyle | None = None,
+        key_bindings: KeyBindings | None = None,
+        cancel_callback: Callable[[], None] | None = None,
+        file: TextIO | None = None,
+        color_depth: ColorDepth | None = None,
+        output: Output | None = None,
+        input: Input | None = None,
+    ) -> None:
+        self.title = title
+        self.formatters = formatters or create_default_formatters()
+        self.bottom_toolbar = bottom_toolbar
+        self.counters: list[ProgressBarCounter[object]] = []
+        self.style = style
+        self.key_bindings = key_bindings
+        self.cancel_callback = cancel_callback
+
+        # If no `cancel_callback` was given, and we're creating the progress
+        # bar from the main thread. Cancel by sending a `KeyboardInterrupt` to
+        # the main thread.
+        if self.cancel_callback is None and in_main_thread():
+
+            def keyboard_interrupt_to_main_thread() -> None:
+                os.kill(os.getpid(), signal.SIGINT)
+
+            self.cancel_callback = keyboard_interrupt_to_main_thread
+
+        # Note that we use __stderr__ as default error output, because that
+        # works best with `patch_stdout`.
+        self.color_depth = color_depth
+        self.output = output or get_app_session().output
+        self.input = input or get_app_session().input
+
+        self._thread: threading.Thread | None = None
+
+        self._has_sigwinch = False
+        self._app_started = threading.Event()
+
+    def __enter__(self) -> ProgressBar:
+        # Create UI Application.
+        title_toolbar = ConditionalContainer(
+            Window(
+                FormattedTextControl(lambda: self.title),
+                height=1,
+                style="class:progressbar,title",
+            ),
+            filter=Condition(lambda: self.title is not None),
+        )
+
+        bottom_toolbar = ConditionalContainer(
+            Window(
+                FormattedTextControl(
+                    lambda: self.bottom_toolbar, style="class:bottom-toolbar.text"
+                ),
+                style="class:bottom-toolbar",
+                height=1,
+            ),
+            filter=~is_done
+            & renderer_height_is_known
+            & Condition(lambda: self.bottom_toolbar is not None),
+        )
+
+        def width_for_formatter(formatter: Formatter) -> AnyDimension:
+            # Needs to be passed as callable (partial) to the 'width'
+            # parameter, because we want to call it on every resize.
+            return formatter.get_width(progress_bar=self)
+
+        progress_controls = [
+            Window(
+                content=_ProgressControl(self, f, self.cancel_callback),
+                width=functools.partial(width_for_formatter, f),
+            )
+            for f in self.formatters
+        ]
+
+        self.app: Application[None] = Application(
+            min_redraw_interval=0.05,
+            layout=Layout(
+                HSplit(
+                    [
+                        title_toolbar,
+                        VSplit(
+                            progress_controls,
+                            height=lambda: D(
+                                preferred=len(self.counters), max=len(self.counters)
+                            ),
+                        ),
+                        Window(),
+                        bottom_toolbar,
+                    ]
+                )
+            ),
+            style=self.style,
+            key_bindings=self.key_bindings,
+            refresh_interval=0.3,
+            color_depth=self.color_depth,
+            output=self.output,
+            input=self.input,
+        )
+
+        # Run application in different thread.
+        def run() -> None:
+            try:
+                self.app.run(pre_run=self._app_started.set)
+            except BaseException as e:
+                traceback.print_exc()
+                print(e)
+
+        ctx: contextvars.Context = contextvars.copy_context()
+
+        self._thread = threading.Thread(target=ctx.run, args=(run,))
+        self._thread.start()
+
+        return self
+
+    def __exit__(self, *a: object) -> None:
+        # Wait for the app to be started. Make sure we don't quit earlier,
+        # otherwise `self.app.exit` won't terminate the app because
+        # `self.app.future` has not yet been set.
+        self._app_started.wait()
+
+        # Quit UI application.
+        if self.app.is_running and self.app.loop is not None:
+            self.app.loop.call_soon_threadsafe(self.app.exit)
+
+        if self._thread is not None:
+            self._thread.join()
+
+    def __call__(
+        self,
+        data: Iterable[_T] | None = None,
+        label: AnyFormattedText = "",
+        remove_when_done: bool = False,
+        total: int | None = None,
+    ) -> ProgressBarCounter[_T]:
+        """
+        Start a new counter.
+
+        :param label: Title text or description for this progress. (This can be
+            formatted text as well).
+        :param remove_when_done: When `True`, hide this progress bar.
+        :param total: Specify the maximum value if it can't be calculated by
+            calling ``len``.
+        """
+        counter = ProgressBarCounter(
+            self, data, label=label, remove_when_done=remove_when_done, total=total
+        )
+        self.counters.append(counter)
+        return counter
+
+    def invalidate(self) -> None:
+        self.app.invalidate()
+
+
+class _ProgressControl(UIControl):
+    """
+    User control for the progress bar.
+    """
+
+    def __init__(
+        self,
+        progress_bar: ProgressBar,
+        formatter: Formatter,
+        cancel_callback: Callable[[], None] | None,
+    ) -> None:
+        self.progress_bar = progress_bar
+        self.formatter = formatter
+        self._key_bindings = create_key_bindings(cancel_callback)
+
+    def create_content(self, width: int, height: int) -> UIContent:
+        items: list[StyleAndTextTuples] = []
+
+        for pr in self.progress_bar.counters:
+            try:
+                text = self.formatter.format(self.progress_bar, pr, width)
+            except BaseException:
+                traceback.print_exc()
+                text = "ERROR"
+
+            items.append(to_formatted_text(text))
+
+        def get_line(i: int) -> StyleAndTextTuples:
+            return items[i]
+
+        return UIContent(get_line=get_line, line_count=len(items), show_cursor=False)
+
+    def is_focusable(self) -> bool:
+        return True  # Make sure that the key bindings work.
+
+    def get_key_bindings(self) -> KeyBindings:
+        return self._key_bindings
+
+
+_CounterItem = TypeVar("_CounterItem", covariant=True)
+
+
+class ProgressBarCounter(Generic[_CounterItem]):
+    """
+    An individual counter (A progress bar can have multiple counters).
+    """
+
+    def __init__(
+        self,
+        progress_bar: ProgressBar,
+        data: Iterable[_CounterItem] | None = None,
+        label: AnyFormattedText = "",
+        remove_when_done: bool = False,
+        total: int | None = None,
+    ) -> None:
+        self.start_time = datetime.datetime.now()
+        self.stop_time: datetime.datetime | None = None
+        self.progress_bar = progress_bar
+        self.data = data
+        self.items_completed = 0
+        self.label = label
+        self.remove_when_done = remove_when_done
+        self._done = False
+        self.total: int | None
+
+        if total is None:
+            try:
+                self.total = len(cast(Sized, data))
+            except TypeError:
+                self.total = None  # We don't know the total length.
+        else:
+            self.total = total
+
+    def __iter__(self) -> Iterator[_CounterItem]:
+        if self.data is not None:
+            try:
+                for item in self.data:
+                    yield item
+                    self.item_completed()
+
+                # Only done if we iterate to the very end.
+                self.done = True
+            finally:
+                # Ensure counter has stopped even if we did not iterate to the
+                # end (e.g. break or exceptions).
+                self.stopped = True
+        else:
+            raise NotImplementedError("No data defined to iterate over.")
+
+    def item_completed(self) -> None:
+        """
+        Start handling the next item.
+
+        (Can be called manually in case we don't have a collection to loop through.)
+        """
+        self.items_completed += 1
+        self.progress_bar.invalidate()
+
+    @property
+    def done(self) -> bool:
+        """Whether a counter has been completed.
+
+        Done counter have been stopped (see stopped) and removed depending on
+        remove_when_done value.
+
+        Contrast this with stopped. A stopped counter may be terminated before
+        100% completion. A done counter has reached its 100% completion.
+        """
+        return self._done
+
+    @done.setter
+    def done(self, value: bool) -> None:
+        self._done = value
+        self.stopped = value
+
+        if value and self.remove_when_done:
+            self.progress_bar.counters.remove(self)
+
+    @property
+    def stopped(self) -> bool:
+        """Whether a counter has been stopped.
+
+        Stopped counters no longer have increasing time_elapsed. This distinction is
+        also used to prevent the Bar formatter with unknown totals from continuing to run.
+
+        A stopped counter (but not done) can be used to signal that a given counter has
+        encountered an error but allows other counters to continue
+        (e.g. download X of Y failed). Given how only done counters are removed
+        (see remove_when_done) this can help aggregate failures from a large number of
+        successes.
+
+        Contrast this with done. A done counter has reached its 100% completion.
+        A stopped counter may be terminated before 100% completion.
+        """
+        return self.stop_time is not None
+
+    @stopped.setter
+    def stopped(self, value: bool) -> None:
+        if value:
+            # This counter has not already been stopped.
+            if not self.stop_time:
+                self.stop_time = datetime.datetime.now()
+        else:
+            # Clearing any previously set stop_time.
+            self.stop_time = None
+
+    @property
+    def percentage(self) -> float:
+        if self.total is None:
+            return 0
+        else:
+            return self.items_completed * 100 / max(self.total, 1)
+
+    @property
+    def time_elapsed(self) -> datetime.timedelta:
+        """
+        Return how much time has been elapsed since the start.
+        """
+        if self.stop_time is None:
+            return datetime.datetime.now() - self.start_time
+        else:
+            return self.stop_time - self.start_time
+
+    @property
+    def time_left(self) -> datetime.timedelta | None:
+        """
+        Timedelta representing the time left.
+        """
+        if self.total is None or not self.percentage:
+            return None
+        elif self.done or self.stopped:
+            return datetime.timedelta(0)
+        else:
+            return self.time_elapsed * (100 - self.percentage) / self.percentage
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/__init__.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..20a980e2d0a79ed63d0b8e2b88e96551301b31e2
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/__init__.py
@@ -0,0 +1,71 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+import logging
+import os
+
+import torch
+
+from . import _cpp_lib
+from .checkpoint import (  # noqa: E402, F401
+    checkpoint,
+    get_optimal_checkpoint_policy,
+    list_operators,
+    selective_checkpoint_wrapper,
+)
+
+try:
+    from .version import __version__  # noqa: F401
+except ImportError:
+    __version__ = "0.0.0"
+
+
+logger = logging.getLogger("xformers")
+
+_has_cpp_library: bool = _cpp_lib._cpp_library_load_exception is None
+
+_is_opensource: bool = True
+
+
+def compute_once(func):
+    value = None
+
+    def func_wrapper():
+        nonlocal value
+        if value is None:
+            value = func()
+        return value
+
+    return func_wrapper
+
+
+@compute_once
+def _is_triton_available():
+    if not torch.cuda.is_available():
+        return False
+    if os.environ.get("XFORMERS_FORCE_DISABLE_TRITON", "0") == "1":
+        return False
+    # We have many errors on V100 with recent triton versions
+    # Let's just drop support for triton kernels below A100
+    if torch.cuda.get_device_capability("cuda") < (8, 0):
+        return False
+    try:
+        from xformers.triton.softmax import softmax as triton_softmax  # noqa
+
+        return True
+    except (ImportError, AttributeError):
+        logger.warning(
+            "A matching Triton is not available, some optimizations will not be enabled",
+            exc_info=True,
+        )
+        return False
+
+
+@compute_once
+def get_python_lib():
+    return torch.library.Library("xformers_python", "DEF")
+
+
+# end of file
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/__init__.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..882ca9e1d4c855f7d80044e20a02727e1c4577b7
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/__init__.py
@@ -0,0 +1,11 @@
+from xformers.components import MultiHeadDispatchConfig  # noqa
+from xformers.components.attention import AttentionConfig  # noqa
+from xformers.components.feedforward import FeedforwardConfig  # noqa
+from xformers.components.positional_embedding import PositionEmbeddingConfig  # noqa
+
+from .block_factory import xFormerDecoderBlock  # noqa
+from .block_factory import xFormerDecoderConfig  # noqa
+from .block_factory import xFormerEncoderBlock  # noqa
+from .block_factory import xFormerEncoderConfig  # noqa
+from .model_factory import xFormer, xFormerConfig  # noqa
+from .weight_init import xFormerWeightInit  # noqa
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/__pycache__/__init__.cpython-310.pyc b/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4c6551ce8eed8b417e1d8f39b04d291e9f4709c6
Binary files /dev/null and b/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/__pycache__/__init__.cpython-310.pyc differ
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/__pycache__/block_configs.cpython-310.pyc b/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/__pycache__/block_configs.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..62fc1773b8282c90ff57b4abae6d95f51c85cf40
Binary files /dev/null and b/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/__pycache__/block_configs.cpython-310.pyc differ
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/__pycache__/block_factory.cpython-310.pyc b/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/__pycache__/block_factory.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4b870119c6695d8a7a6f44af70a49956084e26a3
Binary files /dev/null and b/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/__pycache__/block_factory.cpython-310.pyc differ
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/__pycache__/hydra_helper.cpython-310.pyc b/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/__pycache__/hydra_helper.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..689a855b162ca9a30148eb23a31da4717ab3883b
Binary files /dev/null and b/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/__pycache__/hydra_helper.cpython-310.pyc differ
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/__pycache__/model_factory.cpython-310.pyc b/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/__pycache__/model_factory.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fdbc4b29551c45ed8fe9471474be76ab02c919e4
Binary files /dev/null and b/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/__pycache__/model_factory.cpython-310.pyc differ
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/__pycache__/weight_init.cpython-310.pyc b/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/__pycache__/weight_init.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..17dbbcc41572525813ad44c8eb39c19d56d4fdff
Binary files /dev/null and b/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/__pycache__/weight_init.cpython-310.pyc differ
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/block_configs.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/block_configs.py
new file mode 100644
index 0000000000000000000000000000000000000000..a628fa1510e31e6bdf43135bddd300c1443ecd91
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/block_configs.py
@@ -0,0 +1,237 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Dict, Optional
+
+from xformers.components import NormalizationType, ResidualNormStyle
+from xformers.components.feedforward import FEEDFORWARD_REGISTRY, FeedforwardConfig
+from xformers.components.positional_embedding import (
+    POSITION_EMBEDDING_REGISTRY,
+    PositionEmbeddingConfig,
+)
+from xformers.utils import generate_matching_config
+
+
+class LayerPositionBitmask(int, Enum):
+    First = 0b01
+    Last = 0b10
+    Default = 0b11
+
+
+class LayerPosition:
+    """Bitmask to mark this layer as first, last, nothing or both"""
+
+    def __init__(self):
+        self.bitmask = LayerPositionBitmask.Default
+
+    def is_first(self):
+        return bool(self.bitmask & LayerPositionBitmask.First)
+
+    def is_last(self):
+        return bool(self.bitmask & LayerPositionBitmask.Last)
+
+    def mark_not_first(self):
+        self.bitmask &= ~LayerPositionBitmask.First
+
+    def mark_not_last(self):
+        self.bitmask &= ~LayerPositionBitmask.Last
+
+
+class BlockType(str, Enum):
+    Encoder = "encoder"
+    Decoder = "decoder"
+
+
+@dataclass(init=False)  # handle constructors explicitly to force type changes
+class xFormerBlockConfig:
+    """
+    The configuration structure to define a Transformer block.
+    This base class is applicable to both encoder and decoder definitions.
+
+    This completely defines each of the blocks, for instance in terms of dimensions,
+    position encoding, pre or post layer norms or reversibility.
+    """
+
+    dim_model: int
+    feedforward_config: FeedforwardConfig
+    position_encoding_config: Optional[PositionEmbeddingConfig]
+    block_type: BlockType
+    residual_norm_style: ResidualNormStyle
+    normalization: NormalizationType
+    layer_position: LayerPosition
+    use_triton: bool
+    reversible: bool
+    num_layers: int
+
+    def __init__(
+        self,
+        dim_model: int,
+        feedforward_config: Dict[str, Any],
+        position_encoding_config: Optional[Dict[str, Any]],
+        block_type: BlockType,
+        residual_norm_style: ResidualNormStyle = ResidualNormStyle("post"),
+        normalization: NormalizationType = NormalizationType.LayerNorm,
+        reversible: bool = False,
+        num_layers: int = 1,
+        layer_position: Optional[LayerPosition] = None,
+    ):
+
+        self.dim_model = dim_model
+        self.block_type = block_type
+        self.residual_norm_style = residual_norm_style
+        self.reversible = reversible
+        self.num_layers = num_layers
+        self.normalization = normalization
+
+        # Fill in possible gaps in the config for subparts of the block
+        self.feedforward_config = generate_matching_config(
+            feedforward_config,
+            FEEDFORWARD_REGISTRY[feedforward_config["name"]].config,
+        )
+
+        self.position_encoding_config = (
+            generate_matching_config(
+                position_encoding_config,
+                POSITION_EMBEDDING_REGISTRY[position_encoding_config["name"]].config,
+            )
+            if position_encoding_config is not None
+            else None
+        )
+
+        # Default is that this layer is the only one, so both first and last
+        if layer_position:
+            self.layer_position = layer_position
+        else:
+            self.layer_position = LayerPosition()
+
+
+@dataclass(init=False)
+class xFormerEncoderConfig(xFormerBlockConfig):
+    """
+    The configuration structure for an encoder block
+    """
+
+    multi_head_config: Dict[str, Any]
+    use_triton: bool
+    simplicial_embeddings: Optional[Dict[str, Any]]
+    patch_embedding_config: Optional[Dict[str, Any]]
+
+    def __init__(
+        self,
+        dim_model: int,
+        feedforward_config: Dict[str, Any],
+        multi_head_config: Dict[str, Any],
+        position_encoding_config: Optional[Dict[str, Any]] = None,
+        residual_norm_style: str = "post",
+        normalization: NormalizationType = NormalizationType.LayerNorm,
+        use_triton: bool = True,
+        simplicial_embeddings: Optional[Dict[str, Any]] = None,
+        patch_embedding_config: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ):
+        # Convenience, fill in duplicated fields
+        try:
+            if "dim_model" not in multi_head_config.keys():
+                multi_head_config["dim_model"] = dim_model
+
+            if "dim_model" not in feedforward_config.keys():
+                feedforward_config["dim_model"] = dim_model
+
+            if (
+                position_encoding_config is not None
+                and "dim_model" not in position_encoding_config.keys()
+            ):
+                position_encoding_config["dim_model"] = dim_model
+
+            if (
+                patch_embedding_config is not None
+                and "out_channels" not in patch_embedding_config.keys()
+            ):
+                patch_embedding_config["out_channels"] = dim_model
+
+        except AttributeError:
+            # A config instance was passed in, this is fine
+            pass
+        if "block_type" in kwargs:
+            assert kwargs["block_type"] == "encoder"
+        kwargs["block_type"] = BlockType("encoder")
+        super().__init__(
+            dim_model=dim_model,
+            feedforward_config=feedforward_config,
+            position_encoding_config=position_encoding_config,
+            residual_norm_style=ResidualNormStyle(residual_norm_style),
+            normalization=NormalizationType(normalization),
+            **kwargs,
+        )
+
+        self.multi_head_config = multi_head_config
+        self.use_triton = use_triton
+        self.simplicial_embeddings = simplicial_embeddings
+        self.patch_embedding_config = patch_embedding_config
+
+
+@dataclass(init=False)
+class xFormerDecoderConfig(xFormerBlockConfig):
+    """
+    The configuration structure for a decoder block.
+
+    This specifically defines the masked and cross attention mechanisms,
+    on top of the settings defining all blocks.
+    """
+
+    multi_head_config_masked: Dict[str, Any]  # prior to encoder output
+    multi_head_config_cross: Dict[str, Any]  # cross attention, takes encoder output
+
+    def __init__(
+        self,
+        dim_model: int,
+        feedforward_config: Dict[str, Any],
+        multi_head_config_masked: Dict[str, Any],
+        multi_head_config_cross: Dict[str, Any],
+        position_encoding_config: Optional[Dict[str, Any]] = None,
+        residual_norm_style: str = "post",
+        normalization: NormalizationType = NormalizationType.LayerNorm,
+        use_triton: bool = True,
+        **kwargs,
+    ):
+
+        # Convenience, fill in duplicated field
+        try:
+            if "dim_model" not in multi_head_config_masked.keys():
+                multi_head_config_masked["dim_model"] = dim_model
+
+            if "dim_model" not in multi_head_config_cross.keys():
+                multi_head_config_cross["dim_model"] = dim_model
+
+            if "dim_model" not in feedforward_config.keys():
+                feedforward_config["dim_model"] = dim_model
+
+            if (
+                position_encoding_config is not None
+                and "dim_model" not in position_encoding_config.keys()
+            ):
+                position_encoding_config["dim_model"] = dim_model
+        except AttributeError:
+            # A config instance was passed in, this is fine
+            pass
+        if "block_type" in kwargs.keys():
+            assert kwargs["block_type"] == "decoder"
+        kwargs["block_type"] = BlockType("decoder")
+
+        super().__init__(
+            dim_model=dim_model,
+            feedforward_config=feedforward_config,
+            position_encoding_config=position_encoding_config,
+            residual_norm_style=ResidualNormStyle(residual_norm_style),
+            normalization=NormalizationType(normalization),
+            **kwargs,
+        )
+
+        self.multi_head_config_masked = multi_head_config_masked
+        self.multi_head_config_cross = multi_head_config_cross
+        self.use_triton = use_triton
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/block_factory.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/block_factory.py
new file mode 100644
index 0000000000000000000000000000000000000000..4868f9f4de9ce63c7613ccad270974f3abcb65ff
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/block_factory.py
@@ -0,0 +1,358 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+import logging
+from dataclasses import asdict
+from typing import Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+
+from xformers._deprecation_warning import deprecated_function
+from xformers.components import (
+    PatchEmbeddingConfig,
+    PostNorm,
+    PreNorm,
+    Residual,
+    ResidualNormStyle,
+    build_multi_head_attention,
+    build_patch_embedding,
+)
+from xformers.components.attention import AttentionMask
+from xformers.components.feedforward import build_feedforward
+from xformers.components.positional_embedding import build_positional_embedding
+from xformers.components.residual import get_deepnorm_coefficients
+from xformers.components.simplicial_embedding import SimplicialEmbedding
+from xformers.factory.block_configs import (
+    NormalizationType,
+    xFormerDecoderConfig,
+    xFormerEncoderConfig,
+)
+
+logger = logging.getLogger("xformers")
+
+
+def _get_ln_factory(
+    d_model: int,
+    residual_norm_style: Optional[ResidualNormStyle],
+    use_triton: bool,
+    residual: bool,
+    normalization: NormalizationType = NormalizationType.LayerNorm,
+    residual_scale: float = 1.0,
+):
+    """
+    Handle all the supported residual path configurations.
+
+    ..Note: we return the appropriate constructor, not an actual layer
+    """
+
+    def get_layer_wrapper(
+        d_model: int,
+        sublayer: nn.Module,
+        residual_norm_style: Optional[ResidualNormStyle],
+        residual: bool,
+        residual_scale: float,
+    ):
+        if residual:
+            if residual_norm_style == ResidualNormStyle.Pre:
+                return Residual(
+                    layer=PreNorm(d_model, sublayer, normalization, use_triton),
+                    scale=None,
+                )
+            elif residual_norm_style == ResidualNormStyle.Post:
+                return PostNorm(
+                    d_model,
+                    Residual(layer=sublayer, scale=None),
+                    normalization,
+                    use_triton,
+                )
+            elif residual_norm_style == ResidualNormStyle.DeepNorm:
+                return PostNorm(
+                    d_model,
+                    Residual(layer=sublayer, scale=residual_scale),
+                    normalization,
+                    use_triton=use_triton,
+                )
+            else:
+                raise ValueError
+
+        return (
+            PreNorm(d_model, sublayer, normalization, use_triton)
+            if residual_norm_style == ResidualNormStyle.Pre
+            else PostNorm(d_model, sublayer, normalization, use_triton)
+        )
+
+    def ln_factory(sublayer: nn.Module):
+        return get_layer_wrapper(
+            d_model, sublayer, residual_norm_style, residual, residual_scale
+        )
+
+    return ln_factory
+
+
+class xFormerEncoderBlock(torch.nn.Module):
+    r"""A vanilla Transformer Encoder block"""
+
+    def __init__(self, config: xFormerEncoderConfig, **kwargs):
+        super().__init__()
+        deprecated_function(self)
+
+        self.reversible_f = None
+        self.reversible_g = None
+        self.residual_norm_style = config.residual_norm_style
+        self.dim_model = config.dim_model
+
+        # If this layer is the first one, and a pose encoding has been requested
+        if (
+            config.position_encoding_config is not None
+            and config.layer_position.is_first()
+        ):
+            self.pose_encoding = build_positional_embedding(
+                asdict(config.position_encoding_config)
+            )
+
+            pos_encoding_dim = config.position_encoding_config.dim_model
+            mha_dim = config.multi_head_config["dim_model"]
+
+            if pos_encoding_dim != mha_dim:
+                logger.warning(
+                    f"The embedding dim and model dim do not match ({pos_encoding_dim} vs {mha_dim}), adding a projector layer."  # noqa
+                )
+                self.embedding_projector = nn.Linear(pos_encoding_dim, mha_dim)
+        else:
+            self.pose_encoding = None
+
+        if config.residual_norm_style == ResidualNormStyle.DeepNorm:
+            # Just use the layer norm coefficient here,
+            # the init will be handled at the xformers level (knows about encoder and decoder blocks)
+            deep_norm_coefficients, _ = get_deepnorm_coefficients(
+                encoder_layers=config.num_layers, decoder_layers=0
+            )
+            assert deep_norm_coefficients is not None
+            residual_scale = deep_norm_coefficients.alpha
+        else:
+            residual_scale = 1.0
+
+        # mini helper, builds a normalization layer with the right Pre/Post config, residuals, and the right dimensions
+        ln_factory = _get_ln_factory(
+            config.dim_model,
+            config.residual_norm_style,
+            use_triton=config.use_triton,
+            residual=True,
+            residual_scale=residual_scale,
+            normalization=config.normalization,
+        )
+
+        mha = build_multi_head_attention(config.multi_head_config)
+        feedforward = build_feedforward(asdict(config.feedforward_config))
+
+        # Expose attention specific capabilities
+        self.supports_attention_mask = mha.attention.supports_attention_mask
+        self.requires_same_k_q_dimensions = mha.attention.requires_same_k_q_dimensions
+        self.causal = (
+            mha.attention.causal if hasattr(mha.attention, "causal") else False
+        )
+
+        # Wrappers handle the different layer norm styles (pre- and post-) and the residual path
+        self.wrap_att = ln_factory(mha)
+        self.wrap_ff: Union[Residual, PostNorm] = ln_factory(feedforward)
+        if (
+            config.residual_norm_style == ResidualNormStyle.Pre
+            and config.layer_position.is_last()
+        ):
+            self.wrap_ff = PostNorm(
+                config.dim_model,
+                self.wrap_ff,
+                normalization=config.normalization,
+                use_triton=config.use_triton,
+            )
+
+        # Simplicial embeddings are only used if specified, and on the last layer
+        self.simplicial_embedding: Optional[SimplicialEmbedding] = None
+        if config.simplicial_embeddings is not None and config.layer_position.is_last():
+            self.simplicial_embedding = SimplicialEmbedding(
+                **config.simplicial_embeddings
+            )
+
+        # Optional patch embedding
+        self.patch_emb: Optional[nn.Module] = None
+
+        if config.patch_embedding_config is not None:
+            self.patch_emb = build_patch_embedding(
+                PatchEmbeddingConfig(**config.patch_embedding_config)
+            )
+
+    @classmethod
+    def from_config(cls, config: xFormerEncoderConfig):
+        return cls(config)
+
+    @staticmethod
+    def get_reversible_layer(config) -> Tuple[nn.Module, nn.Module]:
+        ln_factory = _get_ln_factory(
+            config.dim_model,
+            config.residual_norm_style,
+            residual=False,
+            use_triton=config.use_triton,
+            normalization=config.normalization,
+        )
+
+        mha = build_multi_head_attention(config.multi_head_config)
+        feedforward = build_feedforward(asdict(config.feedforward_config))
+
+        reversible_f = ln_factory(mha)
+        reversible_g = ln_factory(feedforward)
+        return reversible_f, reversible_g
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        att_mask: Optional[Union[torch.Tensor, AttentionMask]] = None,
+        input_mask: Optional[torch.Tensor] = None,
+    ):
+        if self.patch_emb is not None:
+            x = self.patch_emb(x)
+
+        if self.pose_encoding is not None:
+            x = self.pose_encoding(x)
+
+            if hasattr(self, "embedding_projector"):
+                x = self.embedding_projector(x)
+
+        # Handle the optional input masking, differs on Q, K, V
+        if input_mask is not None:
+            q = x
+            k = x * input_mask.unsqueeze(-1)
+            v = k
+        else:
+            q, k, v = x, x, x
+
+        # Pre/Post norms and residual paths are already handled
+        x = self.wrap_att(inputs=[q, k, v], att_mask=att_mask)
+        x = self.wrap_ff(inputs=[x])
+
+        # Optional simplicial embeddings
+        if self.simplicial_embedding is not None:
+            x = self.simplicial_embedding(x)
+
+        return x
+
+
+class xFormerDecoderBlock(torch.nn.Module):
+    r"""A vanilla Transformer Decoder block
+
+    ... note: this implementation is not (yet ?) reversible"""
+
+    def __init__(self, config: xFormerDecoderConfig, **kwargs):
+        super().__init__()
+        deprecated_function(self)
+
+        # If this layer is the first one, and a pose encoding as been requested
+        if (
+            config.position_encoding_config is not None
+            and config.layer_position.is_first()
+        ):
+            self.pose_encoding = build_positional_embedding(
+                config.position_encoding_config
+            )
+
+            pos_encoding_dim = config.position_encoding_config.dim_model
+            mha_dim = config.multi_head_config_masked["dim_model"]
+
+            if pos_encoding_dim != mha_dim:
+
+                logger.warning(
+                    f"The embedding dim and model dim do not match ({pos_encoding_dim} vs {mha_dim}), adding a projector layer."  # noqa
+                )
+
+                self.embedding_projector = nn.Linear(pos_encoding_dim, mha_dim)
+        else:
+            self.pose_encoding = None
+
+        if config.residual_norm_style == ResidualNormStyle.DeepNorm:
+            # Just use the layer norm coefficient here,
+            # the init will be handled at the xformers level (knows about encoder and decoder blocks)
+            _, deep_norm_coefficients = get_deepnorm_coefficients(
+                encoder_layers=0, decoder_layers=config.num_layers
+            )
+            assert deep_norm_coefficients is not None
+            residual_scale = deep_norm_coefficients.alpha
+        else:
+            residual_scale = 1.0
+
+        # mini helper, builds a LayerNorm with the right Pre/Post config and the right dimensions
+        ln_factory = _get_ln_factory(
+            config.dim_model,
+            config.residual_norm_style,
+            use_triton=config.use_triton,
+            residual=True,
+            residual_scale=residual_scale,
+            normalization=config.normalization,
+        )
+
+        mha = build_multi_head_attention(config.multi_head_config_masked)
+        cross_mha = build_multi_head_attention(config.multi_head_config_cross)
+        feedforward = build_feedforward(config.feedforward_config)
+
+        # Expose attention or feedforward specific capabilities
+        self.supports_attention_mask = mha.attention.supports_attention_mask
+        self.requires_same_k_q_dimensions = mha.attention.requires_same_k_q_dimensions
+        self.requires_squared_context_length = (
+            feedforward.requires_squared_context
+            or mha.attention.requires_squared_context
+        )
+
+        self.causal_attention = (
+            mha.attention.causal if hasattr(mha.attention, "causal") else False
+        )
+
+        # Wrappers handle the different layer norm styles (pre- and post-) and the residual path
+        self.wrap_att = ln_factory(mha)
+        self.wrap_cross = ln_factory(cross_mha)
+        self.wrap_ff: Union[Residual, PostNorm] = ln_factory(feedforward)
+
+        if (
+            config.residual_norm_style == ResidualNormStyle.Pre
+            and config.layer_position.is_last()
+        ):
+            self.wrap_ff = PostNorm(
+                config.dim_model,
+                self.wrap_ff,
+                normalization=NormalizationType.LayerNorm,
+            )
+
+    @classmethod
+    def from_config(cls, config: xFormerDecoderConfig):
+        return cls(config)
+
+    def forward(
+        self,
+        target: torch.Tensor,
+        memory: torch.Tensor,
+        encoder_att_mask: Optional[Union[torch.Tensor, AttentionMask]] = None,
+        decoder_att_mask: Optional[Union[torch.Tensor, AttentionMask]] = None,
+        input_mask: Optional[torch.Tensor] = None,
+    ):
+        if self.pose_encoding is not None:
+            target = self.pose_encoding(target)
+
+            if hasattr(self, "embedding_projector"):
+                target = self.embedding_projector(target)
+
+        # Handle the optional input masking, differs on Q, K, V
+        if input_mask is not None:
+            target_q = target
+            target_k = target * input_mask.unsqueeze(-1)
+            target_v = target_k
+        else:
+            target_q, target_k, target_v = target, target, target
+
+        x = self.wrap_att(
+            inputs=[target_q, target_k, target_v], att_mask=decoder_att_mask
+        )
+        x = self.wrap_cross(inputs=[x, memory, memory], att_mask=encoder_att_mask)
+        x = self.wrap_ff(inputs=[x])
+
+        return x
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/hydra_helper.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/hydra_helper.py
new file mode 100644
index 0000000000000000000000000000000000000000..f94557e85a25ff964bfb0535f66420df4a455109
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/hydra_helper.py
@@ -0,0 +1,36 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+# register components configs into Hydra ConfigStore
+# component config classes could be used to validate configs
+import logging
+
+from hydra.core.config_store import ConfigStore
+from omegaconf.errors import ValidationError
+
+from xformers.components.attention import ATTENTION_REGISTRY
+from xformers.components.feedforward import FEEDFORWARD_REGISTRY
+from xformers.components.positional_embedding import POSITION_EMBEDDING_REGISTRY
+
+logger = logging.getLogger("xformers")
+
+
+def import_xformer_config_schema():
+    """
+    Best effort - OmegaConf supports limited typing, so we may fail to import
+    certain config classes. For example, pytorch typing are not supported.
+    """
+    cs = ConfigStore.instance()
+
+    for k, v in {
+        "ff": FEEDFORWARD_REGISTRY,
+        "pe": POSITION_EMBEDDING_REGISTRY,
+        "attention": ATTENTION_REGISTRY,
+    }.items():
+        for kk in v.keys():
+            try:
+                cs.store(name=f"{kk}_schema", node=v[kk].config, group=f"xformers/{k}")
+            except ValidationError as e:
+                logger.debug(f"Error registering {kk}_schema, error: {e}")
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/model_factory.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/model_factory.py
new file mode 100644
index 0000000000000000000000000000000000000000..d4be38876fb62a8485e751edc0bd9b86257a4a31
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/model_factory.py
@@ -0,0 +1,313 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+import logging
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Union
+
+import torch
+
+from xformers._deprecation_warning import deprecated_function
+from xformers.components import reversible as rv
+from xformers.components.residual import ResidualNormStyle, get_deepnorm_coefficients
+from xformers.factory.block_configs import (
+    xFormerBlockConfig,
+    xFormerDecoderConfig,
+    xFormerEncoderConfig,
+)
+from xformers.factory.block_factory import xFormerDecoderBlock, xFormerEncoderBlock
+from xformers.factory.weight_init import get_weight_init_fn, xFormerWeightInit
+
+logger = logging.getLogger("xformers")
+
+
+@dataclass(init=False)
+class xFormerConfig:
+    """
+    The configuration structure to define a full Transformer.
+    This can include a stack of encoder layers, and a stack of decoder layers.
+
+    It is optionally possible to share the embedding weights in between
+    the encoder and decoder positional encoding, as proposed for instance by
+    `Using the Output Embedding to Improve Language Models`, Press et al.
+
+    A full config example is for instance as follows:
+
+    ::
+
+        xformer_config = [
+            {
+                "reversible": False,  # Turn on to test the effect of using reversible layers
+                "block_type": "encoder",
+                "num_layers": LAYERS,
+                "dim_model": EMB,
+                "residual_norm_style": "pre",
+                "position_encoding_config": {
+                    "name": "vocab",
+                    "seq_len": CONTEXT,
+                    "vocab_size": VOCAB_SIZE,
+                },
+                "multi_head_config": {
+                    "num_heads": NUM_HEADS,
+                    "residual_dropout": RES_DROP,
+                    "use_rotary_embeddings": True,
+                    "attention": {
+                        "name": ATTENTION_MECHANISM_STR,
+                        "dropout": ATTN_DROP,
+                        "causal": True,
+                        "seq_len": CONTEXT,
+                    },
+                },
+                "feedforward_config": {
+                    "name": "FusedMLP",  # Use MLP if Triton is not available
+                    "dropout": MLP_DROP,
+                    "activation": "gelu",
+                    "hidden_layer_multiplier": MLP_MULTIPLIER,
+                },
+            }
+        ]
+
+
+    .. _`Using the Output Embedding to Improve Language Models`: https://arxiv.org/pdf/1608.05859.pdf
+    """
+
+    stack_configs: Union[List[xFormerBlockConfig], Dict[str, xFormerBlockConfig]]
+    tie_embedding_weights: bool = False
+    weight_init: xFormerWeightInit = xFormerWeightInit.ViT
+
+    def __init__(
+        self,
+        stack_configs: Union[List[Dict[str, Any]], Dict[str, Dict[str, Any]]],
+        tie_embedding_weights: bool = False,
+        weight_init: xFormerWeightInit = xFormerWeightInit.ViT,
+    ):
+        # Type all the configurations. Possible typos are caught here
+        if isinstance(stack_configs, dict):
+            self.stack_configs = {}
+            for k, config in stack_configs.items():
+                if config["block_type"] == "encoder":
+                    self.stack_configs[k] = xFormerEncoderConfig(**config)
+                else:
+                    self.stack_configs[k] = xFormerDecoderConfig(**config)
+        else:
+            self.stack_configs = []
+            for config in stack_configs:
+                if config["block_type"] == "encoder":
+                    self.stack_configs.append(xFormerEncoderConfig(**config))
+                else:
+                    self.stack_configs.append(xFormerDecoderConfig(**config))
+
+        self.tie_embedding_weights = tie_embedding_weights
+        self.weight_init = weight_init
+        deprecated_function(self)
+
+
+class xFormer(torch.nn.Module):
+    def __init__(
+        self,
+        stack_configs: Union[
+            xFormerBlockConfig, List[xFormerBlockConfig], Dict[str, xFormerBlockConfig]
+        ],
+        tie_embedding_weights: bool = False,
+        weight_init: xFormerWeightInit = xFormerWeightInit.ViT,
+    ):
+        """
+        Given a serialized configuration, generate the corresponding model.
+        This is only a helper and can easily be bypassed
+        """
+        super().__init__()
+        deprecated_function(self)
+
+        if isinstance(stack_configs, Dict):
+            stack_configs = list(stack_configs.values())
+
+        # Convenience, users can pass either a list of configs or a single one
+        if not isinstance(stack_configs, List):
+            stack_configs = [stack_configs]
+
+        # Sanity checks, some config combinations do not make sense
+        self._verify_reversible(stack_configs)
+        self._verify_deepnorm(stack_configs)
+
+        encoders: List[torch.nn.Module] = []
+        decoders: List[torch.nn.Module] = []
+
+        self.reversible_encoder = False
+        self.rev_enc_pose_encoding = None
+
+        # Unroll the configs and build the model
+        for config in stack_configs:
+            # Handle either Encoder or Decoder stacks
+            builder = (
+                xFormerEncoderBlock.from_config
+                if isinstance(config, xFormerEncoderConfig)
+                else xFormerDecoderBlock.from_config
+            )
+            recipient = (
+                encoders if isinstance(config, xFormerEncoderConfig) else decoders
+            )
+
+            # Build up the stack
+            for i in range(config.num_layers):
+                # Label where this layer is in the stack
+                # (for instance useful for the positional encoding, or late layer norm)
+                if len(recipient) > 0:
+                    config.layer_position.mark_not_first()
+
+                if config != stack_configs[-1] or i < config.num_layers - 1:
+                    config.layer_position.mark_not_last()
+
+                block = builder(config)  # type: ignore
+
+                # If reversible: extract the reversible sub-parts, else append the block as-is
+                if config.reversible:
+                    # WARNING: only one pose encoding is saved here (not Focal Transformer compatible for instance)
+                    assert isinstance(config, xFormerEncoderConfig)
+                    if block.pose_encoding is not None:
+                        self.rev_enc_pose_encoding = block.pose_encoding
+                    self.reversible_encoder = True
+
+                    f, g = xFormerEncoderBlock.get_reversible_layer(config)
+                    recipient.append(torch.nn.ModuleList([f, g]))
+                else:
+                    recipient.append(block)  # type: ignore
+
+        # Tie embedding weights, if requested and possible
+        assert (
+            not tie_embedding_weights or not self.reversible_encoder
+        ), "Reversible layers and  tied embeddings is not supported for now"
+
+        if (
+            tie_embedding_weights
+            and encoders
+            and encoders[0].pose_encoding
+            and decoders
+            and decoders[0].pose_encoding
+            and not config.reversible
+        ):
+            logger.info("Tying encoder and decoder embeddings, as requested")
+            encoders[0].pose_encoding = decoders[0].pose_encoding
+
+        self.encoders: torch.nn.Module = (
+            rv.ReversibleSequence(torch.nn.ModuleList(encoders))
+            if self.reversible_encoder
+            else torch.nn.ModuleList(encoders)
+        )
+        self.decoders = torch.nn.ModuleList(decoders)
+
+        use_deepnorm = (
+            stack_configs[0].residual_norm_style == ResidualNormStyle.DeepNorm
+        )
+
+        assert (
+            not use_deepnorm or not self.reversible_encoder
+        ), "Reversible layers and deepnorm is not supported for now"
+
+        self.init_weights(weight_init=weight_init, use_deep_norm=use_deepnorm)
+
+    @classmethod
+    def from_config(cls, config: xFormerConfig):
+        return cls(
+            config.stack_configs, config.tie_embedding_weights, config.weight_init
+        )
+
+    def _verify_reversible(self, stack_configs: List[xFormerBlockConfig]):
+        reversible = [
+            c.reversible
+            for c in filter(lambda x: x.block_type == "encoder", stack_configs)
+        ]
+
+        assert all(reversible) or not any(reversible), (
+            "All layers need to have the same reversibility setting. "
+            + f"Currently {reversible}"
+        )
+
+    def _verify_deepnorm(self, stack_configs: List[xFormerBlockConfig]):
+        deepnorm = [
+            c.residual_norm_style == ResidualNormStyle.DeepNorm for c in stack_configs
+        ]
+
+        assert all(deepnorm) or not any(deepnorm), (
+            "All layers need to have the same deepnorm setting. "
+            + f"Currently {deepnorm}"
+        )
+
+    def init_weights(self, weight_init: xFormerWeightInit, use_deep_norm: bool):
+        # The deepnorm weight initialization method requires different gain factors for the encoder
+        # and decoder, depending on the general model structure (number of respective layers)
+        if use_deep_norm:
+            encoder_coefficients, decoder_coefficients = get_deepnorm_coefficients(
+                encoder_layers=len(self.encoders), decoder_layers=len(self.decoders)  # type: ignore
+            )
+        else:
+            encoder_coefficients, decoder_coefficients = None, None
+
+        encoder_gain = (
+            encoder_coefficients.beta if encoder_coefficients is not None else 1.0
+        )
+        decoder_gain = (
+            decoder_coefficients.beta if decoder_coefficients is not None else 1.0
+        )
+
+        # Pick the desired init function
+        init_fn = get_weight_init_fn(weight_init)
+
+        # Initialize all the encoder weights
+        for name, module in self.encoders.named_children():
+            init_fn(module=module, name=name, gain=encoder_gain)
+
+        for name, module in self.decoders.named_children():
+            init_fn(module=module, name=name, gain=decoder_gain)
+
+    def forward(
+        self,
+        src: torch.Tensor,
+        tgt: Optional[torch.Tensor] = None,
+        encoder_input_mask: Optional[torch.Tensor] = None,
+        decoder_input_mask: Optional[torch.Tensor] = None,
+    ) -> Optional[torch.Tensor]:
+
+        # Encode to latent space if encoder is present
+        if len(list(self.encoders.parameters())) > 0:
+            encoders = self.encoders
+            memory = src.clone()
+            if isinstance(encoders, torch.nn.ModuleList):
+                for encoder in encoders:
+                    memory = encoder(memory, input_mask=encoder_input_mask)
+            else:
+                if self.rev_enc_pose_encoding:
+                    memory = self.rev_enc_pose_encoding(src)
+
+                # Reversible Encoder
+                x = torch.cat([memory, memory], dim=-1)
+
+                # Apply the optional input masking
+                if encoder_input_mask is not None:
+                    if x.dim() - encoder_input_mask.dim() > 1:
+                        encoder_input_mask.unsqueeze(0)
+                    x += encoder_input_mask.unsqueeze(-1)
+
+                x = encoders(x)
+                memory = torch.stack(x.chunk(2, dim=-1)).mean(dim=0)
+
+            if not self.decoders:
+                return memory
+
+        # If decoder: either use the encoder ouput, or just decode, both options are possible
+        if len(self.decoders) > 0:
+            tgt = src.clone() if tgt is None else tgt
+
+            for decoder in self.decoders:
+                tgt = decoder(
+                    target=tgt,
+                    # pyre-fixme[61]: `memory` is not always initialized here.
+                    memory=memory,
+                    input_mask=decoder_input_mask,
+                )
+
+            return tgt
+
+        return None
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/weight_init.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/weight_init.py
new file mode 100644
index 0000000000000000000000000000000000000000..754d3bed632ae4c7e90cf2e1c4167e8761377665
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/factory/weight_init.py
@@ -0,0 +1,293 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+# CREDITS: Reusing a lot of code from the Timm repo
+# main difference is probably the handling of deepnorm init, and adapting to some xformers specificities
+# https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/vision_transformer.py
+
+import logging
+import math
+from enum import Enum
+from typing import Callable
+
+import torch
+import torch.nn as nn
+from torch.nn.init import (
+    _calculate_fan_in_and_fan_out,
+    _no_grad_trunc_normal_,
+    _no_grad_uniform_,
+)
+
+logger = logging.getLogger("xformers")
+
+
+_assert_if_not_initialized = False
+
+
+class xFormerWeightInit(str, Enum):
+    Timm = "timm"
+    ViT = "vit"
+    Moco = "moco"
+    Small = "small"
+
+
+def get_weight_init_fn(init_choice: xFormerWeightInit):
+    """
+    Provide the xFormers factory with weight init routines.
+
+    Supported initializations are:
+    - Small: follow the method outlined in `Transformer Without Tears`_
+    - ViT: follow the initialization in the reference ViT_ codebase
+    - Timm: follow the initialization in the reference Timm_ codebase
+    - Moco: follow the initialization in the reference MocoV3_ codebase
+
+    .. _ViT: https://github.com/google-research/vision_transformer
+    .. _Timm: https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/vision_transformer.py
+    .. _MocoV3: https://github.com/facebookresearch/moco-v3
+    """
+    return {
+        xFormerWeightInit.Timm: _init_weights_vit_timm,
+        xFormerWeightInit.ViT: _init_weights_vit_jax,
+        xFormerWeightInit.Moco: _init_weights_vit_moco,
+        xFormerWeightInit.Small: _init_weights_small,
+    }[init_choice]
+
+
+# Define pattern matches
+def is_ffn(n):
+    return "feedforward" in n or ("wrap_ff" in n and not n.endswith("norm"))
+
+
+def is_mha_input_projection(n):
+    return "q_proj" in n or "k_proj" in n or "v_proj" in n
+
+
+# Define distribution helpers
+def _small_init_(tensor: torch.Tensor, gain: float = 1.0) -> torch.Tensor:
+    r"""Fills the input `Tensor` with values according to the method
+    described in `Transformer Without Tears`_, using a uniform distribution.
+
+    This is a variation of the Xavier init. The resulting tensor will have values sampled from
+    :math:`\mathcal{U}(-a, a)` where
+
+    .. math::
+        a = \text{gain} \times \sqrt{\frac{6}{\text{fan\_in} + 4 * \text{fan\_out}}}
+
+    Also known as Glorot initialization.
+
+    Args:
+        tensor: an n-dimensional `torch.Tensor`
+        gain: an optional scaling factor
+
+    .. _`Transformer Without Tears`: https://arxiv.org/abs/1910.05895
+
+    """
+    fan_in, fan_out = _calculate_fan_in_and_fan_out(tensor)
+    std = gain * math.sqrt(2.0 / float(fan_in + 4 * fan_out))
+    a = math.sqrt(3.0) * std  # Calculate uniform bounds from standard deviation
+
+    return _no_grad_uniform_(tensor, -a, a)
+
+
+def _lecun_normal(tensor, gain=1.0):
+    fan_in, _ = _calculate_fan_in_and_fan_out(tensor)
+    denom = fan_in
+    variance = gain / denom
+
+    # constant is stddev of standard normal truncated to (-2, 2)
+    _no_grad_trunc_normal_(
+        tensor,
+        mean=0.0,
+        std=math.sqrt(variance) / 0.87962566103423978,
+        a=-2.0,
+        b=2.0,
+    )
+
+
+# Helpers to keep all the functions typesafe, and handle corner cases and common behaviours in one place
+def _maybe_init_tensor(module: nn.Module, attr: str, distribution_: Callable, **kwargs):
+    #  Small helper to catch all the corner cases, while staying type safe
+    if hasattr(module, attr):
+        maybe_tensor = getattr(module, attr)
+        if maybe_tensor is not None and isinstance(maybe_tensor, torch.Tensor):
+            distribution_(maybe_tensor, **kwargs)
+
+
+def _maybe_report_no_init(module, name):
+    if len(list(module.named_children())) == 0 and (
+        hasattr(module, "weight") or hasattr(module, "bias")
+    ):
+        # Skip layer norm, this is ok
+        if isinstance(module, torch.nn.LayerNorm):
+            return
+
+        # Skip nn.Embedding, we typically initialize it one level up, else Pytorch has a valid default
+        if isinstance(module, torch.nn.Embedding):
+            return
+
+        # This is unexpected, warn about a possible unhandled weight
+        logger.warning(
+            f"Not initializing weights in {name}, this could be a mistake.\nModule {module}"
+        )
+
+        if _assert_if_not_initialized:
+            assert False, (
+                f"Uninitialized weight found in {module}."
+                + " If you have a custom module, please provide a `init_weights()` method"
+            )
+
+
+# Define the different initialization schemes
+def _init_weights_vit_jax(
+    module: nn.Module,
+    name: str = "",
+    head_bias: float = 0.0,
+    gain: float = 1.0,
+    deepnorm_style: bool = False,
+    **kwargs,
+):
+    """ViT weight initialization, matching JAX (Flax) impl"""
+
+    if is_ffn(name):
+        _maybe_init_tensor(module, "bias", nn.init.normal_, std=1e-6)
+        _maybe_init_tensor(module, "weight", torch.nn.init.xavier_uniform_, gain=gain)
+
+    elif is_mha_input_projection(name) or isinstance(module, nn.Linear):
+        if deepnorm_style and (
+            "q_proj" in name.split(".") or "k_proj" in name.split(".")
+        ):
+            gain = 1.0
+
+        _maybe_init_tensor(module, "weight", torch.nn.init.xavier_uniform_, gain=gain)
+        _maybe_init_tensor(module, "bias", nn.init.zeros_)
+
+    elif isinstance(module, nn.Conv2d):
+        _maybe_init_tensor(module, "weight", _lecun_normal, gain=gain)
+        _maybe_init_tensor(module, "bias", nn.init.zeros_)
+
+    elif hasattr(module, "init_weights"):
+        module.init_weights()  # type: ignore
+
+    else:
+        _maybe_report_no_init(module, name)
+
+    # Recurse over the children, if the weight init is being handled here
+    if not hasattr(module, "init_weights"):
+        for child_name, child_module in module.named_children():
+            _init_weights_vit_jax(child_module, f"{name}.{child_name}", head_bias, gain)
+
+
+def _init_weights_vit_moco(
+    module: nn.Module,
+    name: str = "",
+    gain: float = 1.0,
+    **kwargs,
+):
+    """ViT weight initialization, matching moco-v3 impl minus fixed PatchEmbed"""
+
+    assert (
+        "deepnorm_style" not in kwargs.keys()
+    ), "This initialization method does not support deepnorm"
+
+    if is_ffn(name):
+        _maybe_init_tensor(module, "weight", torch.nn.init.xavier_uniform_, gain=gain)
+        _maybe_init_tensor(module, "bias", nn.init.zeros_)
+
+    elif is_mha_input_projection(name) or isinstance(module, nn.Linear):
+        if isinstance(module.weight, torch.Tensor):
+            val = (
+                math.sqrt(6.0 / float(module.weight.shape[0] + module.weight.shape[1]))
+                * gain
+            )
+            _maybe_init_tensor(module, "weight", nn.init.uniform_, a=-val, b=val)
+
+        _maybe_init_tensor(module, "bias", nn.init.zeros_)
+
+    elif hasattr(module, "init_weights"):
+        module.init_weights(gain=gain)  # type: ignore
+
+    else:
+        _maybe_report_no_init(module, name)
+
+    # Recurse over the children, if the weight init is being handled here
+    if not hasattr(module, "init_weights"):
+        for child_name, child_module in module.named_children():
+            _init_weights_vit_moco(child_module, child_name, gain)
+
+
+def _init_weights_small(
+    module: nn.Module,
+    name: str = "",
+    head_bias: float = 0.0,
+    gain: float = 1.0,
+    deepnorm_style: bool = False,
+    **kwargs,
+):
+    """Follow the `Transformer Without Tears`_ initialization for self-attention"""
+
+    if is_ffn(name):
+        _maybe_init_tensor(module, "weight", torch.nn.init.xavier_uniform_, gain=gain)
+        _maybe_init_tensor(module, "bias", nn.init.normal_, std=1e-6)
+
+    elif is_mha_input_projection(name) or isinstance(module, nn.Linear):
+        # "small init" only scales the attention layers init, not the FFN
+        if deepnorm_style and (
+            "q_proj" in name.split(".") or "k_proj" in name.split(".")
+        ):
+            gain = 1.0
+
+        _maybe_init_tensor(module, "weight", _small_init_, gain=gain)
+        _maybe_init_tensor(module, "bias", nn.init.zeros_)
+
+    elif isinstance(module, nn.Conv2d):
+        _maybe_init_tensor(module, "weight", _lecun_normal)
+        _maybe_init_tensor(module, "bias", nn.init.zeros_)
+    elif hasattr(module, "init_weights"):
+        module.init_weights()  # type: ignore
+    else:
+        _maybe_report_no_init(module, name)
+
+    # Recurse over the children, if the weight init is being handled here
+    if not hasattr(module, "init_weights"):
+        for child_name, child_module in module.named_children():
+            _init_weights_small(child_module, f"{name}.{child_name}", head_bias, gain)
+
+
+def _init_weights_vit_timm(
+    module: nn.Module,
+    name: str = "",
+    gain: float = 1.0,
+    deepnorm_style: bool = False,
+    **kwargs,
+):
+    """
+    ViT weight initialization, original timm impl (for reproducibility).
+
+    See DeepNet_ for all the DeepNorm specific codepaths
+    """
+
+    if isinstance(module, nn.Linear):
+        if deepnorm_style and (
+            "q_proj" in name.split(".") or "k_proj" in name.split(".")
+        ):
+            gain = 1
+
+        std = 0.02 * gain
+        a = math.sqrt(3.0) * std  # Calculate uniform bounds from standard deviation
+
+        _maybe_init_tensor(
+            module, "weight", _no_grad_trunc_normal_, mean=0.0, std=std, a=-a, b=a
+        )
+        _maybe_init_tensor(module, "bias", nn.init.zeros_)
+
+    elif hasattr(module, "init_weights"):
+        module.init_weights(gain=gain)  # type: ignore
+    else:
+        _maybe_report_no_init(module, name)
+
+    # Recurse over the children, if the weight init is being handled here
+    if not hasattr(module, "init_weights"):
+        for child_name, child_module in module.named_children():
+            _init_weights_vit_timm(child_module, child_name, gain)
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/info.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/info.py
new file mode 100644
index 0000000000000000000000000000000000000000..1a17586e66b0c21498713cf23725f6c875008516
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/info.py
@@ -0,0 +1,76 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+from typing import Dict
+
+import torch
+
+from . import __version__, _cpp_lib, _is_opensource, _is_triton_available, ops
+from .ops.common import OPERATORS_REGISTRY
+from .profiler.profiler_dcgm import DCGM_PROFILER_AVAILABLE
+
+
+def get_features_status() -> Dict[str, str]:
+    features = {}
+    for op in OPERATORS_REGISTRY:
+        status_str = "available" if op.is_available() else "unavailable"
+        features[f"{op.OPERATOR_CATEGORY}.{op.NAME}"] = status_str
+    for k, v in ops.swiglu_op._info().items():
+        features[f"swiglu.{k}"] = v
+    features["is_triton_available"] = str(_is_triton_available())
+    return features
+
+
+def print_info():
+    features = get_features_status()
+    print(f"xFormers {__version__}")
+    features["pytorch.version"] = torch.__version__
+    if torch.cuda.is_available():
+        features["pytorch.cuda"] = "available"
+        device = torch.cuda.current_device()
+        cap = torch.cuda.get_device_capability(device)
+        features["gpu.compute_capability"] = ".".join(str(ver) for ver in cap)
+        features["gpu.name"] = torch.cuda.get_device_name(device)
+    else:
+        features["pytorch.cuda"] = "not available"
+
+    features["dcgm_profiler"] = (
+        "available" if DCGM_PROFILER_AVAILABLE else "unavailable"
+    )
+
+    build_info = _cpp_lib._build_metadata
+    if build_info is None and isinstance(
+        _cpp_lib._cpp_library_load_exception, _cpp_lib.xFormersInvalidLibException
+    ):
+        build_info = _cpp_lib._cpp_library_load_exception.build_info
+    if build_info is not None:
+        features["build.info"] = "available"
+        features["build.cuda_version"] = build_info.cuda_version
+        features["build.python_version"] = build_info.python_version
+        features["build.torch_version"] = build_info.torch_version
+        for k, v in build_info.build_env.items():
+            features[f"build.env.{k}"] = v
+    else:
+        features["build.info"] = "none"
+
+    try:
+        features["build.nvcc_version"] = ".".join(
+            str(v) for v in torch.ops.xformers._nvcc_build_version()
+        )
+    except (RuntimeError, AttributeError):
+        pass
+
+    if _is_opensource:
+        features["source.privacy"] = "open source"
+    else:
+        features["source.privacy"] = "fairinternal"
+
+    for name, status in features.items():
+        print("{:<50} {}".format(f"{name}:", status))
+
+
+if __name__ == "__main__":
+    print_info()
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/ops/_triton/sequence_parallel_fused_kernels.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/ops/_triton/sequence_parallel_fused_kernels.py
new file mode 100644
index 0000000000000000000000000000000000000000..c6ba954dc46db6cb913bf0472a43bf6429aacbe0
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/ops/_triton/sequence_parallel_fused_kernels.py
@@ -0,0 +1,741 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+import itertools
+from typing import List, Optional, Set, Tuple, cast
+
+import torch
+import triton
+import triton.language as tl
+from triton.ops.matmul_perf_model import early_config_prune, estimate_matmul_time
+
+
+def init_to_zero(*names):
+    def result(nargs):
+        if nargs["blocks_done_counters"].numel() > 0:
+            nargs["blocks_done_counters"].zero_()
+        for name in names:
+            nargs[name].zero_()
+
+    return result
+
+
+def gen_config(
+    block_m: int,
+    block_n: int,
+    block_k: int,
+    stages: int,
+    warps: int,
+    split_k: int = 1,
+    group_m: int = 8,
+) -> triton.Config:
+    """A more compact way to define a triton.Config, so it fits on one line"""
+
+    return triton.Config(
+        {
+            "BLOCK_M": block_m,
+            "BLOCK_N": block_n,
+            "BLOCK_K": block_k,
+            "SPLIT_K": split_k,
+            "GROUP_M": group_m,
+        },
+        num_stages=stages,
+        num_warps=warps,
+        pre_hook=init_to_zero("C1", "C2", "C3") if split_k > 1 else init_to_zero(),
+    )
+
+
+BASIC_MATMUL_CONFIGS = [
+    gen_config(block_m=128, block_n=256, block_k=32, stages=3, warps=8),
+    gen_config(block_m=256, block_n=128, block_k=32, stages=3, warps=8),
+    gen_config(block_m=256, block_n=64, block_k=32, stages=4, warps=4),
+    gen_config(block_m=64, block_n=256, block_k=32, stages=4, warps=4),
+    gen_config(block_m=128, block_n=128, block_k=32, stages=4, warps=4),
+    gen_config(block_m=128, block_n=64, block_k=32, stages=4, warps=4),
+    gen_config(block_m=64, block_n=128, block_k=32, stages=4, warps=4),
+    gen_config(block_m=128, block_n=32, block_k=32, stages=4, warps=4),
+    gen_config(block_m=64, block_n=32, block_k=32, stages=5, warps=2),
+]
+
+
+INT8_MATMUL_CONFIGS = [
+    gen_config(block_m=128, block_n=256, block_k=128, stages=3, warps=8),
+    gen_config(block_m=256, block_n=128, block_k=128, stages=3, warps=8),
+    gen_config(block_m=256, block_n=64, block_k=128, stages=4, warps=4),
+    gen_config(block_m=64, block_n=256, block_k=128, stages=4, warps=4),
+    gen_config(block_m=128, block_n=128, block_k=128, stages=4, warps=4),
+    gen_config(block_m=128, block_n=64, block_k=64, stages=4, warps=4),
+    gen_config(block_m=64, block_n=128, block_k=64, stages=4, warps=4),
+    gen_config(block_m=128, block_n=32, block_k=64, stages=4, warps=4),
+    gen_config(block_m=64, block_n=32, block_k=64, stages=5, warps=2),
+]
+
+
+IO_BOUND_MATMUL_CONFIGS_STAGES = [2, 3, 4, 5, 6]
+IO_BOUND_MATMUL_CONFIGS_BLOCK_M = [16, 32]
+IO_BOUND_MATMUL_CONFIGS_BLOCK_K = [32, 64]
+IO_BOUND_MATMUL_CONFIGS_BLOCK_N = [32, 64, 128, 256]
+IO_BOUND_MATMUL_CONFIGS_SPLIT_K = [1, 2, 4, 8, 16]
+
+
+IO_BOUND_MATMUL_CONFIGS = [
+    gen_config(
+        block_m=block_m,
+        block_n=block_n,
+        block_k=block_k,
+        stages=stages,
+        warps=2 if block_n <= 64 else 4,
+        split_k=split_k,
+    )
+    for stages, block_m, block_k, block_n, split_k in itertools.product(
+        IO_BOUND_MATMUL_CONFIGS_STAGES,
+        IO_BOUND_MATMUL_CONFIGS_BLOCK_M,
+        IO_BOUND_MATMUL_CONFIGS_BLOCK_K,
+        IO_BOUND_MATMUL_CONFIGS_BLOCK_N,
+        IO_BOUND_MATMUL_CONFIGS_SPLIT_K,
+    )
+]
+
+
+TRITON_CONFIGS = BASIC_MATMUL_CONFIGS + INT8_MATMUL_CONFIGS + IO_BOUND_MATMUL_CONFIGS
+
+
+BACKWARDS_WITH_ME_FIRST = 0
+FORWARDS_WITH_ME_LAST = 1
+
+NUM_SPINS_BETWEEN_TIMEOUT_CHECKS = 1000
+
+
+@triton.jit
+def determine_tile(
+    A,
+    B1,
+    B2,
+    B3,
+    C1,
+    C2,
+    C3,
+    A_my_shard,
+    C1_my_shard,
+    C2_my_shard,
+    C3_my_shard,
+    M,
+    N1,
+    N2,
+    N3,
+    my_rank,
+    world_size,
+    direction,
+    stride_am,
+    stride_bk1,
+    stride_bk2,
+    stride_bk3,
+    stride_bn1,
+    stride_bn2,
+    stride_bn3,
+    stride_cm1,
+    stride_cm2,
+    stride_cm3,
+    stride_cn1,
+    stride_cn2,
+    stride_cn3,
+    BLOCK_M,
+    BLOCK_N,
+    GROUP_M,
+):
+    # tl.device_assert(M % world_size == 0)
+    M_per_rank = M // world_size
+    # matrix multiplication
+    pid = tl.program_id(0)
+    grid_m_per_rank = tl.cdiv(M_per_rank, BLOCK_M)
+    grid_n1 = tl.cdiv(N1, BLOCK_N)
+    grid_n2 = tl.cdiv(N2, BLOCK_N)
+    grid_n3 = tl.cdiv(N3, BLOCK_N)
+    grid_n = grid_n1 + grid_n2 + grid_n3
+
+    # Blocks with lower pid will be executed first (this isn't a documented
+    # guarantee, but seems to happen in practice, and Triton already leverages
+    # it for its swizzling just below). We want the first blocks to operate on
+    # the local rank's shard, since it's immediately available, then once that's
+    # all done operate on the first remote contribution to arrive (the one from
+    # my_rank - 1), etc. Thus we change the pointers to A and C, and the value
+    # of pid, as needed to operate on the input in the order we want.
+    blocks_per_rank = grid_m_per_rank * grid_n
+    if direction == BACKWARDS_WITH_ME_FIRST:
+        other_rank = (my_rank - (pid // blocks_per_rank) + world_size) % world_size
+    else:  # direction == FORWARDS_WITH_ME_LAST:
+        other_rank = (my_rank + (pid // blocks_per_rank + 1)) % world_size
+    pid = pid % blocks_per_rank
+
+    # re-order program ID for better L2 performance
+    width = GROUP_M * grid_n
+    group_id = pid // width
+    group_size = min(grid_m_per_rank - group_id * GROUP_M, GROUP_M)
+    pid_m = group_id * GROUP_M + (pid % group_size)
+    pid_n = (pid % width) // (group_size)
+
+    B = tl.where(pid_n < grid_n1, B1, tl.where(pid_n < grid_n1 + grid_n2, B2, B3))
+    C = tl.where(pid_n < grid_n1, C1, tl.where(pid_n < grid_n1 + grid_n2, C2, C3))
+    C_my_shard = tl.where(
+        pid_n < grid_n1,
+        C1_my_shard,
+        tl.where(pid_n < grid_n1 + grid_n2, C2_my_shard, C3_my_shard),
+    )
+    stride_bk = tl.where(
+        pid_n < grid_n1,
+        stride_bk1,
+        tl.where(pid_n < grid_n1 + grid_n2, stride_bk2, stride_bk3),
+    )
+    stride_bn = tl.where(
+        pid_n < grid_n1,
+        stride_bn1,
+        tl.where(pid_n < grid_n1 + grid_n2, stride_bn2, stride_bn3),
+    )
+    stride_cm = tl.where(
+        pid_n < grid_n1,
+        stride_cm1,
+        tl.where(pid_n < grid_n1 + grid_n2, stride_cm2, stride_cm3),
+    )
+    stride_cn = tl.where(
+        pid_n < grid_n1,
+        stride_cn1,
+        tl.where(pid_n < grid_n1 + grid_n2, stride_cn2, stride_cn3),
+    )
+    N = tl.where(pid_n < grid_n1, N1, tl.where(pid_n < grid_n1 + grid_n2, N2, N3))
+    pid_n = tl.where(
+        pid_n < grid_n1,
+        pid_n,
+        tl.where(pid_n < grid_n1 + grid_n2, pid_n - grid_n1, pid_n - grid_n1 - grid_n2),
+    )
+
+    A = tl.where(
+        other_rank == my_rank, A_my_shard, A + other_rank * M_per_rank * stride_am
+    )
+    C = tl.where(
+        other_rank == my_rank, C_my_shard, C + other_rank * M_per_rank * stride_cm
+    )
+
+    return (
+        A,
+        B,
+        C,
+        M_per_rank,
+        N,
+        stride_bk,
+        stride_bn,
+        stride_cm,
+        stride_cn,
+        pid_m,
+        pid_n,
+        other_rank,
+        blocks_per_rank,
+    )
+
+
+@triton.jit
+def wait_for_recv(
+    seq_num,
+    wait_counters,
+    other_rank,
+    my_rank,
+    stripe,
+    num_stripes,
+    _wait,
+    do_wait,
+    timeout_ns,
+):
+    if (_wait and do_wait) and other_rank != my_rank:
+        wait_counter = wait_counters + other_rank * num_stripes + stripe
+        start_time_ns = tl.extra.cuda.globaltimer()
+        num_spins = 0
+        # There's no atomic_load, hence we simulate it with a CAS.
+        while tl.atomic_cas(wait_counter, 0, 0) != seq_num:
+            num_spins += 1
+            if num_spins == NUM_SPINS_BETWEEN_TIMEOUT_CHECKS:
+                if tl.extra.cuda.globaltimer() - start_time_ns > timeout_ns:
+                    tl.device_assert(
+                        False,
+                        "xFormers's fused kernels for sequence parallelism "
+                        "timed out waiting for a peer GPU. To prevent "
+                        "downstream computations from operating on corrupted "
+                        "data, we're bringing the CUDA context down with us.",
+                    )
+                num_spins = 0
+
+
+@triton.jit
+def do_matmul(
+    A,
+    B,
+    C,
+    pid_m,
+    pid_n,
+    pid_z,
+    M,
+    N,
+    K,
+    stride_am,
+    stride_ak,
+    stride_bk,
+    stride_bn,
+    stride_cm,
+    stride_cn,
+    BLOCK_M,
+    BLOCK_N,
+    BLOCK_K,
+    ACC_TYPE,
+    SPLIT_K,
+    EVEN_K,
+):
+    # do matrix multiplication
+    rm = pid_m * BLOCK_M + tl.arange(0, BLOCK_M)
+    rn = pid_n * BLOCK_N + tl.arange(0, BLOCK_N)
+    ram = tl.max_contiguous(tl.multiple_of(rm % M, BLOCK_M), BLOCK_M)
+    rbn = tl.max_contiguous(tl.multiple_of(rn % N, BLOCK_N), BLOCK_N)
+    rk = pid_z * BLOCK_K + tl.arange(0, BLOCK_K)
+    # pointers
+    A = A + (ram[:, None] * stride_am + rk[None, :] * stride_ak)
+    B = B + (rk[:, None] * stride_bk + rbn[None, :] * stride_bn)
+    acc = tl.zeros((BLOCK_M, BLOCK_N), dtype=ACC_TYPE)
+    for k in range(0, tl.cdiv(K, BLOCK_K * SPLIT_K)):
+        if EVEN_K:
+            a = tl.load(A)
+            b = tl.load(B)
+        else:
+            k_remaining = K - k * (BLOCK_K * SPLIT_K)
+            a = tl.load(A, mask=rk[None, :] < k_remaining, other=0.0)
+            b = tl.load(B, mask=rk[:, None] < k_remaining, other=0.0)
+        acc += tl.dot(a, b)
+        A += BLOCK_K * SPLIT_K * stride_ak
+        B += BLOCK_K * SPLIT_K * stride_bk
+    acc = acc.to(C.dtype.element_ty)
+    # rematerialize rm and rn to save registers
+    rm = pid_m * BLOCK_M + tl.arange(0, BLOCK_M)
+    rn = pid_n * BLOCK_N + tl.arange(0, BLOCK_N)
+    C = C + (rm[:, None] * stride_cm + rn[None, :] * stride_cn)
+    mask = (rm < M)[:, None] & (rn < N)[None, :]
+    # handles write-back with reduction-splitting
+    if SPLIT_K == 1:
+        tl.store(C, acc, mask=mask)
+    else:
+        tl.atomic_add(C, acc, mask=mask)
+
+
+@triton.jit
+def trigger_send(
+    seq_num,
+    blocks_done_counters,
+    write_counters,
+    other_rank,
+    my_rank,
+    num_stripes,
+    stripe,
+    num_blocks_3d,
+    _wait,
+    do_write,
+):
+    if (_wait and do_write) and other_rank != my_rank:
+        num_blocks_done = (
+            tl.atomic_add(
+                blocks_done_counters + other_rank + tl.arange(0, 1),
+                1,
+                sem="acq_rel",
+            )
+            + 1
+        )
+        tl.atomic_xchg(
+            write_counters + other_rank * num_stripes + stripe + tl.arange(0, 1),
+            seq_num,
+            mask=num_blocks_done == num_blocks_3d,
+            sem="release",
+        )
+
+
+def our_estimate_matmul_time(B1, C1, N1, N2, N3, **kwargs):
+    """Call into Triton's upstream cost model, with the right args
+
+    The upstream function expects arguments to have certain names. Since we
+    renamed a few of them in our implementation, we rename them back.
+
+    At the time of writing (July 2023) the arguments that Triton expects are:
+    M, N, K, A, B, C, BLOCK_M, BLOCK_N, BLOCK_K, SPLIT_K, num_warps, num_stages.
+
+    """
+    return estimate_matmul_time(N=N1 + N2 + N3, B=B1, C=C1, **kwargs)
+
+
+@triton.autotune(
+    configs=TRITON_CONFIGS,
+    key=["M", "N1", "N2", "N3", "K"],
+    prune_configs_by={
+        "early_config_prune": early_config_prune,
+        "perf_model": our_estimate_matmul_time,
+        "top_k": 10,
+    },
+    reset_to_zero=["blocks_done_counters"],
+)
+@triton.heuristics(
+    {
+        "EVEN_K": lambda args: args["K"] % (args["BLOCK_K"] * args["SPLIT_K"]) == 0,
+    }
+)
+@triton.jit(
+    do_not_specialize=[
+        "wait_counters",
+        "blocks_done_counters",
+        "write_counters",
+        "do_wait",
+        "do_write",
+        "direction",
+        "stripe",
+        "seq_num",
+        "num_stripes",
+        "_wait",
+        "my_rank",
+        "world_size",
+        "timeout_ns",
+    ],
+    debug=True,  # To avoid stripping device asserts
+)
+def _xformers_seqpar_matmul_kernel(
+    A_my_shard,
+    A,  # DO NOT CHANGE NAME: MUST MATCH PERF MODEL
+    B1,
+    B2,
+    B3,
+    C1,
+    C2,
+    C3,
+    C1_my_shard,
+    C2_my_shard,
+    C3_my_shard,
+    wait_counters,
+    blocks_done_counters,
+    write_counters,
+    M,  # DO NOT CHANGE NAME: MUST MATCH PERF MODEL
+    N1,
+    N2,
+    N3,
+    K,  # DO NOT CHANGE NAME: MUST MATCH PERF MODEL
+    stride_am,
+    stride_ak,
+    stride_bk1,
+    stride_bk2,
+    stride_bk3,
+    stride_bn1,
+    stride_bn2,
+    stride_bn3,
+    stride_cm1,
+    stride_cm2,
+    stride_cm3,
+    stride_cn1,
+    stride_cn2,
+    stride_cn3,
+    do_wait,
+    do_write,
+    direction,
+    stripe,
+    seq_num,
+    num_stripes,
+    _wait,
+    my_rank,
+    world_size,
+    timeout_ns,
+    BLOCK_M: tl.constexpr,  # DO NOT CHANGE NAME: MUST MATCH PERF MODEL
+    BLOCK_N: tl.constexpr,  # DO NOT CHANGE NAME: MUST MATCH PERF MODEL
+    BLOCK_K: tl.constexpr,  # DO NOT CHANGE NAME: MUST MATCH PERF MODEL
+    GROUP_M: tl.constexpr,
+    SPLIT_K: tl.constexpr,  # DO NOT CHANGE NAME: MUST MATCH PERF MODEL
+    EVEN_K: tl.constexpr,
+    ACC_TYPE: tl.constexpr,
+):
+    (
+        A,
+        B,
+        C,
+        M,
+        N,
+        stride_bk,
+        stride_bn,
+        stride_cm,
+        stride_cn,
+        pid_m,
+        pid_n,
+        other_rank,
+        num_blocks_2d,
+    ) = determine_tile(
+        A,
+        B1,
+        B2,
+        B3,
+        C1,
+        C2,
+        C3,
+        A_my_shard,
+        C1_my_shard,
+        C2_my_shard,
+        C3_my_shard,
+        M,
+        N1,
+        N2,
+        N3,
+        my_rank,
+        world_size,
+        direction,
+        stride_am,
+        stride_bk1,
+        stride_bk2,
+        stride_bk3,
+        stride_bn1,
+        stride_bn2,
+        stride_bn3,
+        stride_cm1,
+        stride_cm2,
+        stride_cm3,
+        stride_cn1,
+        stride_cn2,
+        stride_cn3,
+        BLOCK_M,
+        BLOCK_N,
+        GROUP_M,
+    )
+    pid_z = tl.program_id(1)
+
+    wait_for_recv(
+        seq_num,
+        wait_counters,
+        other_rank,
+        my_rank,
+        stripe,
+        num_stripes,
+        _wait,
+        do_wait,
+        timeout_ns,
+    )
+
+    do_matmul(
+        A,
+        B,
+        C,
+        pid_m,
+        pid_n,
+        pid_z,
+        M,
+        N,
+        K,
+        stride_am,
+        stride_ak,
+        stride_bk,
+        stride_bn,
+        stride_cm,
+        stride_cn,
+        BLOCK_M,
+        BLOCK_N,
+        BLOCK_K,
+        ACC_TYPE,
+        SPLIT_K,
+        EVEN_K,
+    )
+
+    trigger_send(
+        seq_num,
+        blocks_done_counters,
+        write_counters,
+        other_rank,
+        my_rank,
+        num_stripes,
+        stripe,
+        num_blocks_2d * SPLIT_K,
+        _wait,
+        do_write,
+    )
+
+
+AUTOTUNED_SIZES: Set[Tuple[int, Tuple[int, ...], int, torch.dtype]] = set()
+
+
+def common_alignment(*args):
+    for div in [16, 8, 4, 2]:
+        if all(a % div == 0 for a in args):
+            return div
+    return 1
+
+
+def _launch_triton_matmul(
+    a_my_shard: Optional[torch.Tensor],
+    a: torch.Tensor,
+    bs: List[torch.Tensor],
+    cs: List[torch.Tensor],
+    cs_my_shard: Optional[List[torch.Tensor]],
+    my_rank: int,
+    world_size: int,
+    wait_counters: Optional[torch.Tensor],
+    write_counters: Optional[torch.Tensor],
+    direction: int,
+    stripe: int,
+    seq_num: int,
+    num_stripes: int,
+    timeout_s: int,
+    _wait: bool = True,
+) -> None:
+    # checks constraints
+    assert 0 <= my_rank < world_size
+    assert 0 <= stripe < num_stripes and 0 <= seq_num < 2**8
+    assert direction in (BACKWARDS_WITH_ME_FIRST, FORWARDS_WITH_ME_LAST)
+
+    assert len(bs) == len(cs)
+    assert a.ndim == 2
+    assert all(b.ndim == 2 for b in bs)
+    assert all(c.ndim == 2 for c in cs)
+    M, K = a.shape
+    Ns = [b.shape[1] for b in bs]
+    assert all(b.shape[0] == K for b in bs)
+    assert all(c.shape[0] == M for c in cs)
+    assert all(c.shape[1] == N for c, N in zip(cs, Ns))
+    stride_am, stride_ak = cast(Tuple[int, int], a.stride())
+    strides_bk, strides_bn = zip(*(cast(Tuple[int, int], b.stride()) for b in bs))
+    strides_cm, strides_cn = zip(*(cast(Tuple[int, int], c.stride()) for c in cs))
+    assert stride_am == 1 or stride_ak == 1
+    assert all(s == 1 for s in strides_bk) or all(s == 1 for s in strides_bn)
+    assert all(s == 1 for s in strides_cm) or all(s == 1 for s in strides_cn)
+
+    if a_my_shard is not None:
+        assert a_my_shard.ndim == 2
+        assert a_my_shard.shape[0] * world_size == a.shape[0]
+        assert a_my_shard.shape[1] == a.shape[1]
+        assert a_my_shard.stride() == a.stride()
+    else:
+        assert a.shape[0] % world_size == 0
+        a_my_shard = a.tensor_split(world_size)[my_rank]
+
+    if cs_my_shard is not None:
+        assert len(cs_my_shard) == len(cs)
+        assert all(c_my_shard.ndim == 2 for c_my_shard in cs_my_shard)
+        assert all(
+            c_my_shard.shape[0] * world_size == c.shape[0]
+            for c, c_my_shard in zip(cs, cs_my_shard)
+        )
+        assert all(
+            c_my_shard.shape[1] == c.shape[1] for c, c_my_shard in zip(cs, cs_my_shard)
+        )
+        assert all(
+            c_my_shard.stride() == c.stride() for c, c_my_shard in zip(cs, cs_my_shard)
+        )
+    else:
+        assert all(c.shape[0] % world_size == 0 for c in cs)
+        cs_my_shard = [c.tensor_split(world_size)[my_rank] for c in cs]
+
+    if wait_counters is not None:
+        assert wait_counters.shape == (world_size, num_stripes)
+        assert wait_counters.dtype is torch.int
+        assert wait_counters.is_contiguous()
+        do_wait = True
+    else:
+        do_wait = False
+        wait_counters = torch.empty((0,), dtype=torch.int, device=a.device)
+
+    if write_counters is not None:
+        assert write_counters.shape == (world_size, num_stripes)
+        assert write_counters.dtype is torch.int
+        assert write_counters.is_contiguous()
+        do_write = True
+        blocks_done_counters = torch.empty(
+            (world_size,), dtype=torch.int, device=a.device
+        )
+    else:
+        do_write = False
+        write_counters = torch.empty((0,), dtype=torch.int, device=a.device)
+        blocks_done_counters = torch.empty((0,), dtype=torch.int, device=a.device)
+
+    # accumulator types
+    assert all(c.dtype == cs[0].dtype for c in cs)
+    ACC_TYPE = (
+        tl.float32
+        if cs[0].dtype in [torch.float16, torch.bfloat16, torch.float32]
+        else tl.int32
+    )
+
+    # launch kernel
+    def grid(META):
+        return (
+            world_size
+            * triton.cdiv(M // world_size, META["BLOCK_M"])
+            * sum(triton.cdiv(N, META["BLOCK_N"]) for N in Ns),
+            META["SPLIT_K"],
+        )
+
+    # Can be raised if needed.
+    assert len(bs) <= 3
+
+    # We auto-tune the kernel's tiling and other parameters for each set of
+    # sizes. However, auto-tuning performs a device sync (it has to retrieve
+    # timings), which can be problematic: the kernel may busy-wait for something
+    # that will only be scheduled later, and the sync would never return. Thus,
+    # for auto-tuning, we'd like to set _wait to False, and then set it to True
+    # for the real run. (We assume that the kernel is idempotent, and that it
+    # won't have a wildly different perf profile when it runs on garbage data
+    # compared to real data).
+
+    # Define the args/kwargs corresponding to the default invocation.
+    # We can't just use kwargs because Triton expects some args as positional.
+    args = (
+        a_my_shard,
+        a,
+        bs[0],
+        bs[min(1, len(bs) - 1)],
+        bs[min(2, len(bs) - 1)],
+        cs[0],
+        cs[min(1, len(cs) - 1)],
+        cs[min(2, len(cs) - 1)],
+        cs_my_shard[0],
+        cs_my_shard[min(1, len(cs_my_shard) - 1)],
+        cs_my_shard[min(2, len(cs_my_shard) - 1)],
+        wait_counters,
+        blocks_done_counters,
+        write_counters,
+        M,
+        Ns[0],
+        Ns[1] if len(Ns) >= 2 else 0,
+        Ns[2] if len(Ns) >= 3 else 0,
+        K,
+    )
+    kwargs = dict(
+        stride_am=stride_am,
+        stride_ak=stride_ak,
+        stride_bk1=strides_bk[0],
+        stride_bk2=strides_bk[min(1, len(strides_bk) - 1)],
+        stride_bk3=strides_bk[min(2, len(strides_bk) - 1)],
+        stride_bn1=strides_bn[0],
+        stride_bn2=strides_bn[min(1, len(strides_bn) - 1)],
+        stride_bn3=strides_bn[min(2, len(strides_bn) - 1)],
+        stride_cm1=strides_cm[0],
+        stride_cm2=strides_cm[min(1, len(strides_cm) - 1)],
+        stride_cm3=strides_cm[min(2, len(strides_cm) - 1)],
+        stride_cn1=strides_cn[0],
+        stride_cn2=strides_cn[min(1, len(strides_cn) - 1)],
+        stride_cn3=strides_cn[min(2, len(strides_cn) - 1)],
+        do_wait=do_wait,
+        do_write=do_write,
+        direction=direction,
+        stripe=stripe,
+        seq_num=seq_num,
+        num_stripes=num_stripes,
+        _wait=_wait,
+        my_rank=my_rank,
+        world_size=world_size,
+        timeout_ns=timeout_s * 1_000_000_000,
+        ACC_TYPE=ACC_TYPE,
+    )
+
+    # Run without waiting to auto-tune this set of sizes, if needed
+    if (M, tuple(Ns), K, cs[0].dtype) not in AUTOTUNED_SIZES:
+        kwargs["_wait"] = False
+        _xformers_seqpar_matmul_kernel[grid](*args, **kwargs)
+        kwargs["_wait"] = _wait
+        AUTOTUNED_SIZES.add((M, tuple(Ns), K, cs[0].dtype))
+
+    # Run the actual kernel
+    _xformers_seqpar_matmul_kernel[grid](*args, **kwargs)
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/ops/fmha/__init__.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/ops/fmha/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..bf7368da3b2de7913f92e1034820e0c6887db73b
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/ops/fmha/__init__.py
@@ -0,0 +1,448 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+from typing import Any, Optional, Sequence, Tuple, Type, Union
+
+import torch
+
+from . import attn_bias, cutlass, decoder, flash, small_k, triton, triton_splitk
+from .attn_bias import AttentionBias, BlockDiagonalMask, LowerTriangularMask
+from .common import (
+    AttentionBwOpBase,
+    AttentionFwOpBase,
+    AttentionOp,
+    AttentionOpBase,
+    AttentionOpDispatch,
+    Context,
+    Gradients,
+    Inputs,
+    bmk2bmhk,
+)
+from .dispatch import _dispatch_bw, _dispatch_fw, _ensure_op_supports_or_raise
+
+MemoryEfficientAttentionCutlassOp = (cutlass.FwOp, cutlass.BwOp)
+MemoryEfficientAttentionCutlassFwdFlashBwOp = (cutlass.FwOp, flash.BwOp)
+MemoryEfficientAttentionDecoderOp = (decoder.FwOp, cutlass.BwOp)
+MemoryEfficientAttentionTritonFwdFlashBwOp = (triton.FwOp, flash.BwOp)
+MemoryEfficientAttentionFlashAttentionOp = (flash.FwOp, flash.BwOp)
+MemoryEfficientAttentionOp = (small_k.FwOp, small_k.BwOp)
+TritonFlashAttentionOp = (triton.FwOp, triton.BwOp)
+
+
+class _fMHA(torch.autograd.Function):
+    @staticmethod
+    # type: ignore
+    def forward(ctx, op: AttentionOp, *args: Any) -> Any:
+        inp = Inputs(*args)
+        op_fw = op[0] if op is not None else None
+        op_bw = op[1] if op is not None else None
+
+        out, op_ctx = _memory_efficient_attention_forward_requires_grad(
+            inp=inp, op=op_fw
+        )
+
+        # Saving attn_bias is a bit complicated, as the
+        # torch part should go in `save_for_backward`
+        if isinstance(inp.attn_bias, torch.Tensor):
+            attn_bias_tensor = inp.attn_bias
+            attn_bias_ctx = None
+        else:
+            attn_bias_tensor = None
+            attn_bias_ctx = inp.attn_bias
+
+        ctx.save_for_backward(
+            inp.query,
+            inp.key,
+            inp.value,
+            op_ctx.out,
+            op_ctx.lse,
+        )
+        ctx.rng_state = op_ctx.rng_state
+        ctx.attn_bias_tensor = attn_bias_tensor
+        if op_ctx.op_bw is not None:
+            if op_bw is not None and op_bw is not op_ctx.op_bw:
+                raise ValueError(
+                    f"Specified op_bw={op_bw.NAME}, but forward op "
+                    f"can only run with op_bw={op_ctx.op_bw.NAME}. Please set op_bw=None."
+                )
+            op_bw = op_ctx.op_bw
+        ctx.op_fw = op_fw
+        ctx.op_bw = op_bw
+        ctx.p = inp.p
+
+        ctx.scale = inp.scale
+        ctx.attn_bias_ctx = attn_bias_ctx
+        ctx.n_args = len(args)
+        return out
+
+    @staticmethod
+    def deserialize_bias(
+        attn_bias_ctx, attn_bias_tensor: Optional[torch.Tensor]
+    ) -> Any:
+        if attn_bias_tensor is None:
+            return attn_bias_ctx
+        return attn_bias_tensor
+
+    @classmethod
+    @torch.autograd.function.once_differentiable
+    def backward(cls, ctx, grad):
+        # Re-create context
+        query, key, value, out, lse = ctx.saved_tensors
+        attn_bias_tensor = ctx.attn_bias_tensor
+        rng_state = ctx.rng_state
+        inp = Inputs(
+            query=query,
+            key=key,
+            value=value,
+            attn_bias=cls.deserialize_bias(ctx.attn_bias_ctx, attn_bias_tensor),
+            p=ctx.p,
+            scale=ctx.scale,
+        )
+        op_ctx = Context(
+            lse=lse,
+            out=out,
+            rng_state=rng_state,
+        )
+        grads = _memory_efficient_attention_backward(
+            ctx=op_ctx, inp=inp, grad=grad, op=ctx.op_bw
+        )
+        return (None, grads.dq, grads.dk, grads.dv, grads.db) + (None,) * (
+            ctx.n_args - 2
+        )
+
+
+def memory_efficient_attention(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    value: torch.Tensor,
+    attn_bias: Optional[Union[torch.Tensor, AttentionBias]] = None,
+    p: float = 0.0,
+    scale: Optional[float] = None,
+    *,
+    op: Optional[AttentionOp] = None,
+) -> torch.Tensor:
+    """Implements the memory-efficient attention mechanism following
+    `"Self-Attention Does Not Need O(n^2) Memory" <http://arxiv.org/abs/2112.05682>`_.
+
+    :Inputs shape:
+
+    - Input tensors must be in format ``[B, M, H, K]``, where B is the batch size, M \
+        the sequence length, H the number of heads, and K the embeding size per head
+
+    - If inputs have dimension 3, it is assumed that the dimensions are ``[B, M, K]`` and ``H=1``
+
+    - Inputs can also be of dimension 5 with GQA - see note below
+
+    - Inputs can be non-contiguous - we only require the last dimension's stride to be 1
+
+
+    :Equivalent pytorch code:
+
+    .. code-block:: python
+
+        scale = 1 / query.shape[-1] ** 0.5
+        query = query * scale
+        attn = query @ key.transpose(-2, -1)
+        if attn_bias is not None:
+            attn = attn + attn_bias
+        attn = attn.softmax(-1)
+        attn = F.dropout(attn, p)
+        return attn @ value
+
+    :Examples:
+
+    .. code-block:: python
+
+        import xformers.ops as xops
+
+        # Compute regular attention
+        y = xops.memory_efficient_attention(q, k, v)
+
+        # With a dropout of 0.2
+        y = xops.memory_efficient_attention(q, k, v, p=0.2)
+
+        # Causal attention
+        y = xops.memory_efficient_attention(
+            q, k, v,
+            attn_bias=xops.LowerTriangularMask()
+        )
+
+    :Supported hardware:
+
+        NVIDIA GPUs with compute capability above 6.0 (P100+), datatype ``f16``, ``bf16`` and ``f32``.
+
+    :EXPERIMENTAL: Using with Multi Query Attention (MQA) and Grouped Query Attention (GQA):
+
+        MQA/GQA is an experimental feature supported only for the forward pass.
+        If you have 16 heads in query, and 2 in key/value, you can provide 5-dim tensors
+        in the ``[B, M, G, H, K]`` format, where ``G`` is the number of head groups (here 2), and
+        ``H`` is the number of heads per group (8 in the example).
+
+        Please note that xFormers will not automatically broadcast the inputs, so you will need
+        to broadcast it manually before calling `memory_efficient_attention`.
+
+    :GQA/MQA example:
+
+    .. code-block:: python
+
+        import torch
+        import xformers.ops as xops
+
+        B, M, K = 3, 32, 128
+        kwargs = dict(device="cuda", dtype=torch.float16)
+        q = torch.randn([B, M, 8, K], **kwargs)
+        k = torch.randn([B, M, 2, K], **kwargs)
+        v = torch.randn([B, M, 2, K], **kwargs)
+        out_gqa = xops.memory_efficient_attention(
+            q.reshape([B, M, 2, 4, K]),
+            k.reshape([B, M, 2, 1, K]).expand([B, M, 2, 4, K]),
+            v.reshape([B, M, 2, 1, K]).expand([B, M, 2, 4, K]),
+        )
+
+    Raises:
+        NotImplementedError: if there is no operator available to compute the MHA
+        ValueError: if inputs are invalid
+
+    :parameter query: Tensor of shape ``[B, Mq, H, K]``
+    :parameter key: Tensor of shape ``[B, Mkv, H, K]``
+    :parameter value: Tensor of shape ``[B, Mkv, H, Kv]``
+    :parameter attn_bias: Bias to apply to the attention matrix - defaults to no masking. \
+        For common biases implemented efficiently in xFormers, see :attr:`xformers.ops.fmha.attn_bias.AttentionBias`. \
+        This can also be a :attr:`torch.Tensor` for an arbitrary mask (slower).
+    :parameter p: Dropout probability. Disabled if set to ``0.0``
+    :parameter scale: Scaling factor for ``Q @ K.transpose()``. If set to ``None``, the default \
+        scale (q.shape[-1]**-0.5) will be used.
+    :parameter op: The operators to use - see :attr:`xformers.ops.AttentionOpBase`. \
+        If set to ``None`` (recommended), xFormers \
+        will dispatch to the best available operator, depending on the inputs \
+        and options.
+    :return: multi-head attention Tensor with shape ``[B, Mq, H, Kv]``
+    """
+    return _memory_efficient_attention(
+        Inputs(
+            query=query, key=key, value=value, p=p, attn_bias=attn_bias, scale=scale
+        ),
+        op=op,
+    )
+
+
+def memory_efficient_attention_forward(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    value: torch.Tensor,
+    attn_bias: Optional[Union[torch.Tensor, AttentionBias]] = None,
+    p: float = 0.0,
+    scale: Optional[float] = None,
+    *,
+    op: Optional[Type[AttentionFwOpBase]] = None,
+) -> torch.Tensor:
+    """
+    Calculates the forward pass of :attr:`xformers.ops.memory_efficient_attention`.
+    """
+    return _memory_efficient_attention_forward(
+        Inputs(
+            query=query, key=key, value=value, p=p, attn_bias=attn_bias, scale=scale
+        ),
+        op=op,
+    )
+
+
+def memory_efficient_attention_forward_requires_grad(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    value: torch.Tensor,
+    attn_bias: Optional[Union[torch.Tensor, AttentionBias]] = None,
+    p: float = 0.0,
+    scale: Optional[float] = None,
+    *,
+    op: Optional[Type[AttentionFwOpBase]] = None,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    Returns a tuple (output, lse), where `lse` can be used to compute the backward pass later.
+    See :attr:`xformers.ops.memory_efficient_attention` for an explanation of the arguments
+    See :attr:`xformers.ops.memory_efficient_attention_backward` for running the backward pass
+    """
+    if p != 0.0:
+        raise NotImplementedError(
+            "dropout is not supported on the non-autograd API."
+            " If you want to use dropout, please call `memory_efficient_attention` directly"
+        )
+    out, ctx = _memory_efficient_attention_forward_requires_grad(
+        Inputs(
+            query=query, key=key, value=value, p=p, attn_bias=attn_bias, scale=scale
+        ),
+        op=op,
+    )
+    return out, ctx.lse
+
+
+def memory_efficient_attention_backward(
+    grad: torch.Tensor,
+    output: torch.Tensor,
+    lse: torch.Tensor,
+    query: torch.Tensor,
+    key: torch.Tensor,
+    value: torch.Tensor,
+    attn_bias: Optional[Union[torch.Tensor, AttentionBias]] = None,
+    p: float = 0.0,
+    scale: Optional[float] = None,
+    *,
+    op: Optional[Type[AttentionBwOpBase]] = None,
+) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    """
+    Computes the gradient of the attention.
+    Returns a tuple (dq, dk, dv)
+    See :attr:`xformers.ops.memory_efficient_attention` for an explanation of the arguments.
+    `lse` is the tensor returned by :attr:`xformers.ops.memory_efficient_attention_forward_requires_grad`
+    """
+    if p != 0.0:
+        raise NotImplementedError(
+            "dropout is not supported on the non-autograd API."
+            " If you want to use dropout, please call `memory_efficient_attention` directly"
+        )
+    gradients = _memory_efficient_attention_backward(
+        Context(out=output, lse=lse),
+        Inputs(
+            query=query, key=key, value=value, p=p, attn_bias=attn_bias, scale=scale
+        ),
+        grad,
+        op=op,
+    )
+    return (gradients.dq, gradients.dk, gradients.dv)
+
+
+def _memory_efficient_attention(
+    inp: Inputs, op: Optional[AttentionOp] = None
+) -> torch.Tensor:
+    # fast-path that doesn't require computing the logsumexp for backward computation
+    if all(x.requires_grad is False for x in [inp.query, inp.key, inp.value]):
+        return _memory_efficient_attention_forward(
+            inp, op=op[0] if op is not None else None
+        )
+
+    output_shape = inp.normalize_bmhk()
+    return _fMHA.apply(
+        op, inp.query, inp.key, inp.value, inp.attn_bias, inp.p, inp.scale
+    ).reshape(output_shape)
+
+
+def _memory_efficient_attention_forward(
+    inp: Inputs, op: Optional[Type[AttentionFwOpBase]]
+) -> torch.Tensor:
+    inp.validate_inputs()
+    output_shape = inp.normalize_bmhk()
+    if op is None:
+        op = _dispatch_fw(inp, False)
+    else:
+        _ensure_op_supports_or_raise(ValueError, "memory_efficient_attention", op, inp)
+
+    out, *_ = op.apply(inp, needs_gradient=False)
+    return out.reshape(output_shape)
+
+
+def _memory_efficient_attention_forward_requires_grad(
+    inp: Inputs, op: Optional[Type[AttentionFwOpBase]]
+) -> Tuple[torch.Tensor, Context]:
+    inp.validate_inputs()
+    output_shape = inp.normalize_bmhk()
+    if op is None:
+        op = _dispatch_fw(inp, True)
+    else:
+        _ensure_op_supports_or_raise(ValueError, "memory_efficient_attention", op, inp)
+    out = op.apply(inp, needs_gradient=True)
+    assert out[1] is not None
+    return (out[0].reshape(output_shape), out[1])
+
+
+def _memory_efficient_attention_backward(
+    ctx: Context, inp: Inputs, grad: torch.Tensor, op: Optional[Type[AttentionBwOpBase]]
+) -> Gradients:
+    """Warning: grad/ctx.out is potentially in BMK format"""
+    inp.validate_inputs()
+    if grad.ndim != inp.query.ndim or grad.ndim != ctx.out.ndim:
+        raise ValueError(
+            "All tensors should be either in BMK (ndim=3) or BMHK (ndim=4) format. \n"
+            f"grad.shape : {grad.shape} \n"
+            f"out.shape  : {ctx.out.shape} \n"
+            f"query.shape: {inp.query.shape}"
+        )
+    shape_dq, shape_dk, shape_dv = tuple(
+        x.shape for x in (inp.query, inp.key, inp.value)
+    )
+    inp.normalize_bmhk()
+    # LSE has shape [B, H, M] while query has shape [B, M, H, K]
+    if (
+        ctx.lse.ndim != 3
+        # Dim 0
+        or (
+            not isinstance(inp.attn_bias, BlockDiagonalMask)
+            and ctx.lse.shape[0] != inp.query.shape[0]
+        )
+        or (
+            isinstance(inp.attn_bias, BlockDiagonalMask)
+            and ctx.lse.shape[0] != inp.attn_bias.q_seqinfo.seqstart.shape[0] - 1
+        )
+        # Dim 1
+        or ctx.lse.shape[1] != inp.query.shape[2]
+        # Dim 2
+        or (
+            not isinstance(inp.attn_bias, BlockDiagonalMask)
+            and ctx.lse.shape[2] < inp.query.shape[1]
+        )
+    ):
+        raise ValueError(
+            "Input tensors have incompatible shapes."
+            f"lse.shape    : {ctx.lse.shape} \n"
+            f"query.shape  : {inp.query.shape}"
+        )
+    grad = bmk2bmhk(grad, 1)
+    ctx.out = bmk2bmhk(ctx.out, 1)
+
+    if op is None:
+        op = _dispatch_bw(inp)
+    else:
+        _ensure_op_supports_or_raise(
+            ValueError, "memory_efficient_attention_backward", op, inp
+        )
+
+    grads = op.apply(ctx, inp, grad)
+    grads.dq = grads.dq.reshape(shape_dq)
+    grads.dk = grads.dk.reshape(shape_dk)
+    grads.dv = grads.dv.reshape(shape_dv)
+    return grads
+
+
+ALL_FW_OPS: Sequence[Type[AttentionFwOpBase]] = [
+    cutlass.FwOp,
+    flash.FwOp,
+    triton.FwOp,
+    small_k.FwOp,
+    triton_splitk.FwOp,
+]
+
+ALL_BW_OPS: Sequence[Type[AttentionBwOpBase]] = [
+    cutlass.BwOp,
+    flash.BwOp,
+    triton.BwOp,
+    small_k.BwOp,
+]
+
+__all__ = [
+    "AttentionBias",
+    "AttentionOp",
+    "AttentionOpBase",
+    "AttentionOpDispatch",
+    "LowerTriangularMask",
+    "MemoryEfficientAttentionCutlassFwdFlashBwOp",
+    "MemoryEfficientAttentionTritonFwdFlashBwOp",
+    "MemoryEfficientAttentionCutlassOp",
+    "MemoryEfficientAttentionFlashAttentionOp",
+    "MemoryEfficientAttentionOp",
+    "TritonFlashAttentionOp",
+    "memory_efficient_attention",
+    "ALL_FW_OPS",
+    "ALL_BW_OPS",
+    "attn_bias",
+]
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/ops/fmha/decoder.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/ops/fmha/decoder.py
new file mode 100644
index 0000000000000000000000000000000000000000..c3a5e1b4b3cc132c17ef00e443bf71feabd14f23
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/ops/fmha/decoder.py
@@ -0,0 +1,101 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+from typing import Any, List, Optional, Set, Tuple
+
+import numpy as np
+import torch
+
+from ..common import get_xformers_operator, register_operator
+from .attn_bias import BlockDiagonalCausalWithOffsetPaddedKeysMask
+from .common import AttentionFwOpBase, Context, Inputs
+
+
+@register_operator
+class FwOp(AttentionFwOpBase):
+    """An operator optimized for very small values of K (``K <= 32``) \
+        and f32 pre-Ampere as it does not use TensorCores.
+    Only supports contiguous inputs in BMK format, so an extra reshape \
+        or contiguous call might be done.
+
+    :Deprecated:
+
+        This operator is deprecated and should not be used in new code
+    """
+
+    OPERATOR = get_xformers_operator("efficient_attention_forward_decoder")
+    SUPPORTED_DEVICES = {"cuda"}
+    SUPPORTED_DTYPES = {torch.bfloat16, torch.half, torch.float32}
+    CUDA_MINIMUM_COMPUTE_CAPABILITY = (7, 0)
+    SUPPORTED_MAX_K: float = 128
+    SUPPORTED_ATTN_BIAS_TYPES: Set[Any] = {BlockDiagonalCausalWithOffsetPaddedKeysMask}
+    SUPPORTS_DROPOUT = False
+    SUPPORTS_CUSTOM_SCALE = True
+    SUPPORTS_BMGHK = True
+    NAME = "decoderF"
+
+    @classmethod
+    def not_supported_reasons(cls, d: Inputs) -> List[str]:
+        reasons = super(FwOp, cls).not_supported_reasons(d)
+
+        attn_bias = d.attn_bias
+        if isinstance(attn_bias, BlockDiagonalCausalWithOffsetPaddedKeysMask):
+            # If we don't get here, we've an error elsewhere
+            if d.query.shape[0] != 1:
+                reasons.append("One formal batch element expected")
+
+            if d.query.shape[-1] != 128:
+                reasons.append("Only head_dim==128 for now.")
+
+            if d.key.stride(-1) != 1:
+                reasons.append("expect keys to have last dim contiguous")
+
+            if d.value.stride(-1) != 1:
+                reasons.append("expect values to have last dim contiguous")
+
+            q_starts = attn_bias.q_seqinfo.seqstart_py
+            if attn_bias.q_seqinfo.max_seqlen != 1:
+                reasons.append("decoding expects one query")
+            elif d.query.shape[1] != len(q_starts) - 1:
+                reasons.append("empty lanes not supported yet")
+
+            if attn_bias.k_seqinfo.padding > 8192:
+                reasons.append("key padding exceeds 8192")
+
+        return reasons
+
+    @classmethod
+    def apply(
+        cls, inp: Inputs, needs_gradient: bool
+    ) -> Tuple[torch.Tensor, Optional[Context]]:
+        if needs_gradient:
+            raise NotImplementedError("gradient")
+        attn_bias = inp.attn_bias
+        assert isinstance(attn_bias, BlockDiagonalCausalWithOffsetPaddedKeysMask)
+
+        attn_bias.k_seqinfo.to(inp.query.device)
+        attn_bias.q_seqinfo.to(inp.query.device)
+
+        padding = attn_bias.k_seqinfo.padding
+        query, key, value = inp.get_qkv_in_bmghk()
+        query = query[0, :, None]
+        key = key[0].unflatten(0, (-1, padding))
+        value = value[0].unflatten(0, (-1, padding))
+
+        seq_positions = attn_bias.k_seqinfo.seqlen
+
+        if inp.scale is not None:
+            qk_scale = inp.scale
+        else:
+            qk_scale = 1.0 / np.sqrt(key.shape[-1])
+
+        out = cls.OPERATOR(
+            query=query,
+            key=key,
+            value=value,
+            seq_positions=seq_positions,
+            scale=qk_scale,
+        )
+        return out, None
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/profiler/__init__.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/profiler/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae14c7ddbc5a2aa895f30e81e1b982002ac040db
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/profiler/__init__.py
@@ -0,0 +1,17 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+from .api import profile, step
+from .profiler import MemSnapshotsProfiler, NsightProfiler, PyTorchProfiler
+from .slow_ops_profiler import DetectSlowOpsProfiler
+
+__all__ = [
+    "profile",
+    "step",
+    "MemSnapshotsProfiler",
+    "PyTorchProfiler",
+    "NsightProfiler",
+    "DetectSlowOpsProfiler",
+]
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/profiler/__pycache__/__init__.cpython-310.pyc b/evalkit_tf437/lib/python3.10/site-packages/xformers/profiler/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..05439c9a11c19cbc36d314fd082c5b32027678b3
Binary files /dev/null and b/evalkit_tf437/lib/python3.10/site-packages/xformers/profiler/__pycache__/__init__.cpython-310.pyc differ
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/profiler/__pycache__/profiler.cpython-310.pyc b/evalkit_tf437/lib/python3.10/site-packages/xformers/profiler/__pycache__/profiler.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f5dc9f58b51a63781237f69c55409894a7b38c43
Binary files /dev/null and b/evalkit_tf437/lib/python3.10/site-packages/xformers/profiler/__pycache__/profiler.cpython-310.pyc differ
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/profiler/__pycache__/profiler_dcgm.cpython-310.pyc b/evalkit_tf437/lib/python3.10/site-packages/xformers/profiler/__pycache__/profiler_dcgm.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f2cebc2dbaf109369c10940ebc13bbfdef84ec4c
Binary files /dev/null and b/evalkit_tf437/lib/python3.10/site-packages/xformers/profiler/__pycache__/profiler_dcgm.cpython-310.pyc differ
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/profiler/device_limits.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/profiler/device_limits.py
new file mode 100644
index 0000000000000000000000000000000000000000..f2e9caf9ef4543caab2b62795dbc1f6c60f203ff
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/profiler/device_limits.py
@@ -0,0 +1,113 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+import math
+from dataclasses import dataclass, field
+from typing import Mapping, Tuple
+
+import torch
+
+
+@dataclass
+class DeviceLimit:
+    name: str = "default"  # pattern to match from `torch.cuda.get_device_name()`
+    source: str = ""
+    sm: Tuple[int, int] = (0, 0)
+    # bytes/s
+    gmem_bandwidth: float = math.inf
+    # dtype -> TFlop/s
+    gemm_tflops: Mapping[torch.dtype, float] = field(default_factory=dict)
+
+
+# For f32, we assume we can use tf32
+DEVICE_LIMITS: Tuple[DeviceLimit, ...] = (
+    DeviceLimit(
+        "H100",
+        "https://resources.nvidia.com/en-us-tensor-core/nvidia-tensor-core-gpu-datasheet",  # noqa: E501
+        sm=(9, 0),
+        gmem_bandwidth=3.35 * (1024**4),  # NOTE: PCIe is 2 TB/s
+        gemm_tflops={
+            torch.float64: 67,
+            # NOTE: NVIDIA gives all numbers "with 2:4 sparsity"
+            # but we want the full GEMM numbers
+            torch.float32: 989 // 2,
+            torch.float16: 1979 // 2,
+            torch.bfloat16: 1979 // 2,
+            torch.int8: 3958 // 2,
+        },
+    ),
+    DeviceLimit(
+        "A100",
+        "https://www.nvidia.com/content/dam/en-zz/Solutions/Data-Center/a100/pdf/nvidia-a100-datasheet-us-nvidia-1758950-r4-web.pdf",  # noqa: E501
+        sm=(8, 0),
+        gmem_bandwidth=2 * (1024**4),  # NOTE: PCIe is 1.5 TB/s
+        gemm_tflops={
+            torch.float64: 19.5,
+            torch.float32: 156,
+            torch.float16: 312,
+            torch.bfloat16: 312,
+            torch.int8: 624,
+        },
+    ),
+    DeviceLimit(
+        "A30",
+        "https://www.nvidia.com/content/dam/en-zz/Solutions/data-center/products/a30-gpu/pdf/a30-datasheet.pdf",
+        sm=(8, 0),
+        gmem_bandwidth=933 * (1024**3),
+        gemm_tflops={
+            torch.float64: 10.3,
+            torch.float32: 82,
+            torch.float16: 165,
+            torch.bfloat16: 165,
+            torch.int8: 330,
+        },
+    ),
+    DeviceLimit(
+        "T4",
+        "https://www.nvidia.com/content/dam/en-zz/Solutions/Data-Center/tesla-t4/t4-tensor-core-datasheet-951643.pdf",
+        sm=(7, 5),
+        gmem_bandwidth=300 * (1024**3),
+        gemm_tflops={
+            torch.float32: 8.1,
+            torch.float16: 65,
+            torch.int8: 130,
+        },
+    ),
+    # Assuming SXM2
+    DeviceLimit(
+        "V100",
+        "https://images.nvidia.com/content/technologies/volta/pdf/tesla-volta-v100-datasheet-letter-fnl-web.pdf",
+        sm=(7, 0),
+        gmem_bandwidth=900 * (1024**3),
+        gemm_tflops={
+            torch.float64: 7.8,
+            torch.float32: 15.7,
+            torch.float16: 125,
+        },
+    ),
+    DeviceLimit(
+        "P100",
+        "https://images.nvidia.com/content/tesla/pdf/nvidia-tesla-p100-datasheet.pdf",
+        sm=(6, 0),
+        gmem_bandwidth=732 * (1024**3),
+        gemm_tflops={
+            torch.float64: 5.3,
+            torch.float32: 10.6,
+            torch.float16: 21.2,
+        },
+    ),
+)
+
+
+def get_device_limits(device) -> DeviceLimit:
+    """Currently only implemented for GPUs"""
+    if device is not None and device.type == "cuda":
+        device_sm = torch.cuda.get_device_capability(device)
+        device_name = torch.cuda.get_device_name(device)
+        for lim in DEVICE_LIMITS:
+            if lim.sm == device_sm:
+                if lim.name in device_name:
+                    return lim
+    return DeviceLimit()
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/profiler/profiler.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/profiler/profiler.py
new file mode 100644
index 0000000000000000000000000000000000000000..63770fb208c0e19c19a2c7618f6cb6145256ecc5
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/profiler/profiler.py
@@ -0,0 +1,363 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+import logging
+import os
+import queue
+import socket
+import weakref
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, List, Optional, Sequence, Tuple
+
+import torch.cuda.memory
+import torch.cuda.nvtx
+import torch.nn as nn
+import torch.profiler
+import torch.utils.hooks
+
+logger = logging.getLogger(__name__)
+
+
+def _normalize_tuple(x):
+    if not isinstance(x, tuple):
+        return (x,)
+    return x
+
+
+class NsightProfiler:
+    """Profiler that triggers start of NSight profiler.
+
+    NOTE: you need to ensure that the script running this code actually is running with
+    ``nsys profile`` and also has a flag ``--capture-range=cudaProfilerApi`` so the
+    capturing is performed by this profiler during certain steps.
+    """
+
+    def __init__(self, main_profiler: "_Profiler") -> None:
+        self.main_profiler = main_profiler
+        # TODO figure out if there is a way to know if nsys is launched at this point
+
+    def __enter__(self):
+        self.main_profiler._install_hooks()
+        torch.cuda.profiler.start()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        torch.cuda.profiler.stop()
+        self.main_profiler._remove_hooks()
+
+    def step(self) -> None:
+        pass
+
+
+class PyTorchProfiler:
+    """Profiler which relies on native Pytorch profiling. Current setting of the profiler
+    captures traces, memory footprint and other info that could be read via TensorBoard.
+    """
+
+    ACTIVITIES = [
+        torch.profiler.ProfilerActivity.CPU,
+        torch.profiler.ProfilerActivity.CUDA,
+    ]
+
+    def __init__(self, main_profiler: "_Profiler") -> None:
+        self.main_profiler = main_profiler
+        activities_str = "_".join(a.name for a in self.ACTIVITIES)
+        trace_handler = torch.profiler.tensorboard_trace_handler(
+            dir_name=str(
+                main_profiler.output_dir
+                / f"profile_{activities_str}_{main_profiler.done_steps:06}"
+            ),
+            worker_name=main_profiler.worker_name,
+            use_gzip=True,
+        )
+        self.hta = torch.profiler.profile(
+            on_trace_ready=trace_handler,
+            profile_memory=True,
+            record_shapes=True,
+            with_stack=True,
+            activities=self.ACTIVITIES,
+        )
+        self.done_steps = 0
+
+    def __enter__(self):
+        torch.cuda.synchronize()
+        self.hta.__enter__()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        torch.cuda.synchronize()
+        self.hta.__exit__(exc_type, exc_val, exc_tb)
+
+    def step(self) -> None:
+        self.hta.step()
+        self.done_steps += 1
+
+
+class PyTorchProfiler_CUDAOnly(PyTorchProfiler):
+    # This profiler does not profile the CPU-side of things
+    # so we expect it to have almost no overhead
+    ACTIVITIES = [torch.profiler.ProfilerActivity.CUDA]
+
+
+class MemSnapshotsProfiler:
+    """Profiler that captures memory traces for allocation and deallocation of memory for
+    tensors.
+    """
+
+    def __init__(self, main_profiler: "_Profiler") -> None:
+        self.main_profiler = main_profiler
+        self.enabled = False
+
+    @property
+    def _has_trace_plot(self) -> bool:
+        return hasattr(torch.cuda._memory_viz, "trace_plot")
+
+    def __enter__(self):
+        if not self._has_trace_plot:
+            return
+        self.enabled = True
+        # TODO: This does not show the previous memory allocations
+        # We could at least have a placeholder with how much
+        # memory was allocated before
+        torch.cuda.memory._record_memory_history(
+            True,
+            # keep 100,000 alloc/free events from before the snapshot
+            trace_alloc_max_entries=100000,
+            # record stack information for the trace events
+            trace_alloc_record_context=True,
+        )
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if not self._has_trace_plot:
+            self.main_profiler.summary.append(
+                ("MemTrace", "(not available with your Pytorch version)")
+            )
+            return
+        assert self.enabled
+        snapshot = torch.cuda.memory._snapshot()
+        torch.cuda.memory._record_memory_history(False)
+        # No data was recorded - avoids a `ValueError` in `trace_plot`
+        if all(len(t) == 0 for t in snapshot["device_traces"]):
+            self.main_profiler.summary.append(("MemTrace", "(no allocation recorded)"))
+            return
+        # Dump to disk
+        filename = self.main_profiler._create_output_filename("memory_trace_plot.html")
+        self.main_profiler.summary.append(("MemTrace", filename))
+        with open(filename, "w+") as fd:
+            fd.write(
+                torch.cuda._memory_viz.trace_plot(
+                    snapshot, device=None, plot_segments=False
+                )
+            )
+
+    def step(self) -> None:
+        pass
+
+
+@dataclass
+class _ProfilerState:
+    cls: Any
+    iter_begin: int
+    iter_end: int
+    object: Any = None
+
+
+class _Profiler:
+    _CURRENT_PROFILER = None
+
+    def __init__(
+        self,
+        output_dir: str,
+        schedule: Sequence[Tuple[Any, int, int]],
+        module: Optional[nn.Module],
+    ) -> None:
+        self.check_schedule(schedule)
+        self.done_steps = 0
+        self.output_dir = Path(output_dir).absolute()
+        self.output_dir.mkdir(exist_ok=True, parents=True)
+        self.worker_name = ""
+        if torch.distributed.is_initialized():
+            self.worker_name = "{}_{}".format(socket.gethostname(), str(os.getpid()))
+
+        self.module = weakref.ref(module if module is not None else nn.Module())
+        self.parents = ["Global"]
+        self.hooks: List[torch.utils.hooks.RemovableHandle] = []
+        self.hooks_refcount = 0
+        self.profilers: List[_ProfilerState] = sorted(
+            [_ProfilerState(cls, begin, end) for cls, begin, end in schedule],
+            key=lambda x: x.iter_begin,
+        )
+        self.last_step = self.profilers[-1].iter_end if self.profilers else 0
+        self.summary: List[Tuple[str, str]] = []
+
+    def check_schedule(self, schedule: Sequence[Tuple[Any, int, int]]) -> None:
+        if len(schedule) == 0:
+            logger.warning(
+                "You specified empty schedule for profiling. No data will be captured."
+            )
+
+        pq: Any = queue.PriorityQueue()
+        for cls, begin, end in schedule:
+            assert (
+                begin >= 0
+            ), f"Begin step of profiler must be non-negative, found: {begin}"
+            assert end > 0, f"End step of profiler must be positive, found: {end}"
+            assert (
+                begin < end
+            ), f"Start must be before the end, found: begin={begin} and end={end}"
+
+            pq.put((begin, end))
+
+        prev_end = -1
+        for begin, end in pq.queue:
+            assert begin >= prev_end, (
+                "There is some overlapping in profiler scheduling. Please do not"
+                + " overlap profilers by step as they may affect each other. Schedule:"
+                + f" {schedule}"
+            )
+            prev_end = end
+
+    def update_profilers_on_step(self) -> None:
+        for p in self.profilers:
+            if p.iter_begin <= self.done_steps and self.done_steps < p.iter_end:
+                if p.object is None:
+                    o = p.cls(self)
+                    logging.info(f"Starting {p.cls.__name__} profiler...")
+                    o.__enter__()
+                    p.object = o
+                else:
+                    p.object.step()
+            else:
+                if p.object is not None:
+                    o = p.object
+                    p.object = None
+                    logging.info(f"Shutting down {p.cls.__name__} profiler...")
+                    o.__exit__(None, None, None)
+
+    def _create_output_filename(self, filename: str) -> Path:
+        """
+        Returns where to write a file with desired filename.
+        Handles the case where we are in distributed settings, or when
+        we need to output the same file multiple times (eg if a profiler
+        runs for several steps)
+        """
+        if self.worker_name != "":
+            file = Path(filename)
+            folder = self.output_dir / file.stem
+            folder.mkdir(parents=True, exist_ok=True)
+            return folder / f"{self.done_steps:06}_{self.worker_name}{file.suffix}"
+        return self.output_dir / f"{self.done_steps:06}_{filename}"
+
+    def _install_hooks(self) -> None:
+        self.hooks_refcount += 1
+        # Already installed
+        if self.hooks:
+            return
+        module = self.module()
+        if module is None:
+            return
+        for name, sub_mod in module.named_modules():
+            if name == "":
+                continue
+            name = name.split(".")[-1]
+            self.hooks += [
+                sub_mod.register_forward_pre_hook(self._enter_module_hook(name)),
+                sub_mod.register_forward_hook(self._exit_module_hook(name)),
+            ]
+
+    def _remove_hooks(self) -> None:
+        self.hooks_refcount -= 1
+        if self.hooks_refcount == 0:
+            for h in self.hooks:
+                h.remove()
+
+    def _enter_module_hook(self, name):
+        class PopState(torch.autograd.Function):
+            @staticmethod
+            def forward(ctx, *args):
+                if len(args) == 1:
+                    return args[0]
+                return args
+
+            @staticmethod
+            def backward(ctx, *grad_outs):
+                self._exit_module(name)
+                return grad_outs
+
+        def f(module, inputs):
+            self._enter_module(name)
+            inputs = _normalize_tuple(inputs)
+            out = PopState.apply(*inputs)
+            return out
+
+        return f
+
+    def _exit_module_hook(self, name):
+        class PushState(torch.autograd.Function):
+            @staticmethod
+            def forward(ctx, *args):
+                if len(args) == 1:
+                    return args[0]
+                return args
+
+            @staticmethod
+            def backward(ctx, *grad_outs):
+                self._enter_module(name)
+                return grad_outs
+
+        def f(module, inputs, outputs):
+            self._exit_module(name)
+            outputs = _normalize_tuple(outputs)
+            return PushState.apply(*outputs)
+
+        return f
+
+    def _enter_module(self, name) -> None:
+        self.parents.append(name)
+        torch.cuda.nvtx.range_push(name)
+
+    def _exit_module(self, name) -> None:
+        torch.cuda.nvtx.range_pop()
+        assert self.parents[-1] == name
+        self.parents.pop()
+
+    def start(self):
+        self.__enter__()
+
+    def stop(self, exc_type=None, exc_val=None, exc_tb=None):
+        self.__exit__(exc_type, exc_val, exc_tb)
+
+    def __enter__(self):
+        if _Profiler._CURRENT_PROFILER is not None:
+            raise ValueError("Only one xformers profiler can be active at a time")
+        _Profiler._CURRENT_PROFILER = self
+        self.update_profilers_on_step()
+
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        _Profiler._CURRENT_PROFILER = None
+
+        for p in self.profilers:
+            if p.object is not None:
+                p.object.__exit__(exc_type, exc_val, exc_tb)
+
+    def step(self) -> None:
+        """Signals the profiler that the next profiling step has started."""
+        self.done_steps += 1
+
+        if self.done_steps <= self.last_step:
+            self.parents = ["Global"]
+            self.update_profilers_on_step()
+        if self.done_steps == self.last_step:
+            logger.info("xFormers profiler done. %s", self.format_summary())
+
+    def format_summary(self) -> str:
+        if len(self.summary) == 0:
+            return ""
+        pad_titles = max(len(title) for title, value in self.summary)
+        return "summary:\n" + "\n".join(
+            [f"  {title.ljust(pad_titles)}: {value}" for title, value in self.summary]
+        )
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/profiler/profiler_dcgm.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/profiler/profiler_dcgm.py
new file mode 100644
index 0000000000000000000000000000000000000000..12f2d6cf6df745a73d2e0e5a218636f46b74de30
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/profiler/profiler_dcgm.py
@@ -0,0 +1,46 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+import sys
+
+from .profiler import _Profiler, logger
+
+DCGM_PROFILER_AVAILABLE = False
+try:
+    DCGM_PYTHON_PATH: str = "/usr/local/dcgm/bindings/python3"
+    sys.path.insert(0, DCGM_PYTHON_PATH)
+    from .profiler_dcgm_impl import DCGMProfiler
+
+    DCGM_PROFILER_AVAILABLE = True
+except ModuleNotFoundError:
+    logger.warning(
+        f"Unable to find python bindings at {DCGM_PYTHON_PATH}. "
+        "No data will be captured."
+    )
+
+    class DCGMProfiler:  # type: ignore
+        """The dummy DCGM Profiler."""
+
+        def __init__(
+            self,
+            main_profiler: "_Profiler",
+            gpus_to_profile=None,
+            field_ids_to_profile=None,
+            updateFreq=None,
+        ) -> None:
+            pass
+
+        def __enter__(self) -> None:
+            pass
+
+        def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+            pass
+
+        def step(self) -> None:
+            pass
+
+
+del sys.path[0]
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/test.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/test.py
new file mode 100644
index 0000000000000000000000000000000000000000..6677db08c0dcd87f7570a3249f61cc3eabe0532a
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/test.py
@@ -0,0 +1,4 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/__init__.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..444220453277aa561ca9f60f437181dea93a43aa
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/__init__.py
@@ -0,0 +1,27 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+import torch
+
+_triton_available = torch.cuda.is_available()
+if _triton_available:
+    try:
+        from .dropout import FusedDropoutBias, dropout  # noqa
+        from .fused_linear_layer import FusedLinear  # noqa
+        from .layer_norm import FusedLayerNorm, layer_norm  # noqa
+        from .softmax import log_softmax, softmax  # noqa
+
+        __all__ = [
+            "dropout",
+            "softmax",
+            "log_softmax",
+            "FusedDropoutBias",
+            "FusedLinear",
+            "FusedLayerNorm",
+            "layer_norm",
+        ]
+    except ImportError:
+        __all__ = []
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/__pycache__/dropout.cpython-310.pyc b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/__pycache__/dropout.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0e01b983c964ba3c8366cbc0f60d8afa12e02e11
Binary files /dev/null and b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/__pycache__/dropout.cpython-310.pyc differ
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/__pycache__/fused_linear_layer.cpython-310.pyc b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/__pycache__/fused_linear_layer.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b596fb8f4a8da14ce50f67746dc07a3fe45e6e93
Binary files /dev/null and b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/__pycache__/fused_linear_layer.cpython-310.pyc differ
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/__pycache__/k_layer_norm.cpython-310.pyc b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/__pycache__/k_layer_norm.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..97a41154c7285e0ea5b7220927a9af6249df7440
Binary files /dev/null and b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/__pycache__/k_layer_norm.cpython-310.pyc differ
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/__pycache__/softmax.cpython-310.pyc b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/__pycache__/softmax.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6f6d6a5226b240283344232922d5ba08233ec3ad
Binary files /dev/null and b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/__pycache__/softmax.cpython-310.pyc differ
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/dropout.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/dropout.py
new file mode 100644
index 0000000000000000000000000000000000000000..d36a05646bd0766e0395a6ee5e44f1e710a0dafe
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/dropout.py
@@ -0,0 +1,243 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+# CREDITS: This is heavily inspired by the Triton dropout tutorial
+# https://raw.githubusercontent.com/openai/triton/master/python/tutorials/04-low-memory-dropout.py
+
+from typing import Optional
+
+import torch
+import triton
+from torch.cuda.amp import custom_bwd, custom_fwd
+
+from xformers.components.activations import Activation, build_activation
+from xformers.triton.k_activations import get_triton_activation_index
+from xformers.triton.k_dropout import k_dropout_bw, k_dropout_fw
+
+BLOCK_M = 32
+BLOCK_N = 64  # NOTE: This should ideally be GPU dependent, big impact on perf
+
+
+# Helper to handle the SPMD launch grid and error cases
+class _dropout(torch.autograd.Function):
+    @staticmethod
+    @custom_fwd(cast_inputs=torch.float16)
+    def forward(ctx, x, p, bias, activation, trainable_bias):
+        # Soft-flatten an hypothetical 3rd dimension
+        x_ = x.reshape(-1, x.shape[-1]).contiguous()
+        y = torch.empty_like(x_)
+        M, N = x_.shape
+
+        assert bias is None or (bias.dtype == x.dtype and bias.shape[0] == N)
+        assert p > 0.0
+
+        def grid(meta):
+            return (
+                triton.cdiv(M, meta["BLOCK_M"]),
+                triton.cdiv(N, meta["BLOCK_N"]),
+            )
+
+        N_BLOCK_N = triton.cdiv(N, BLOCK_N)
+
+        # Generate one seed per sample
+        # seed max is int32 max for positive numbers: 2**16
+        seeds = torch.randint(65536, (N_BLOCK_N,), device=x.device, dtype=torch.int32)
+
+        # fmt: off
+        bias_ptr = bias if bias is not None else x_  # Possibly not being used
+
+        k_dropout_fw[grid](
+            y, x_,
+            bias_ptr,
+            seeds,
+            y.stride(0),
+            M, N,
+            p,
+            x.dtype == torch.float16,
+            USE_BIAS=bias is not None,
+            ACTIVATION=activation,
+            BLOCK_M=BLOCK_M,
+            BLOCK_N=BLOCK_N,
+        )
+        # fmt: on
+
+        if activation is not None:
+            ctx.save_for_backward(seeds, bias, x)
+        else:
+            ctx.save_for_backward(seeds, bias, None)
+
+        ctx.trainable_bias = bias is not None and trainable_bias
+        ctx.activation = activation
+        ctx.p = p
+
+        return y.reshape_as(x)
+
+    @staticmethod
+    @custom_bwd
+    def backward(
+        ctx, grad_out
+    ):  # pragma: no cover  # This is covered, but called from C++ and not tracked
+        (seeds, bias, inputs) = ctx.saved_tensors
+
+        # Soft-flatten an hypothetical 3rd dimension
+        grad_out_ = grad_out.reshape(-1, grad_out.shape[-1]).contiguous()
+        grad_in = torch.empty_like(grad_out_)
+
+        M, N = grad_out_.shape
+
+        # Optional inputs to compute the activation contribution to the gradient
+        assert inputs is not None or ctx.activation is None
+
+        if inputs is None:
+            inputs = grad_out_
+        elif inputs.ndim > 2:
+            inputs = inputs.reshape(-1, N)
+
+        # We split the problem in tiles:
+        # - over M there will be a follow up reduction
+        # - over N we compromise in between trying to use as much memory paralellism as possible,
+        # (fill in the warps, there are 32 threads per warps, and 4 warps default), and not being too
+        # big because of register spilling
+        N_BLOCKS_M = triton.cdiv(M, BLOCK_M)
+
+        if ctx.trainable_bias:
+            grad_bias = torch.empty(
+                (
+                    N_BLOCKS_M,
+                    N,
+                ),
+                device=grad_in.device,
+                dtype=grad_in.dtype,
+            )
+
+        else:
+            grad_bias = grad_in  # will not be used
+
+        def grid(meta):
+            # NOTE: We use Triton Philox random number generator, which optimally generates 4 blocks for
+            # a given seed and offsets. "BLOCK_M" here describes the size of one of these blocks
+            # but we need to take this factor of 4 into account when scheduling all the kernels
+            return (
+                N_BLOCKS_M,
+                triton.cdiv(N, meta["BLOCK_N"]),
+            )
+
+        # fmt: off
+        k_dropout_bw[grid](
+            grad_in, grad_bias, grad_out_,
+            inputs, bias if bias is not None else inputs,
+            seeds,
+            grad_out_.stride(0), inputs.stride(0),
+            M, N,
+            ctx.p,
+            grad_in.dtype == torch.float16,
+            USE_BIAS=bias is not None,
+            ACTIVATION=ctx.activation,
+            TRAINABLE_BIAS=ctx.trainable_bias,
+            BLOCK_M=BLOCK_M,
+            BLOCK_N=BLOCK_N,
+        )
+        # fmt: on
+
+        return (
+            grad_in.reshape_as(grad_out),
+            None,
+            torch.sum(grad_bias, dim=0) if ctx.trainable_bias else None,
+            None,
+            None,
+            None,
+        )
+
+
+def dropout(
+    x: torch.Tensor,
+    p: float,
+    bias: Optional[torch.Tensor] = None,
+    activation: Optional[Activation] = None,
+):
+    """
+    Apply dropout on the input tensor.
+    Optionally add a bias, the computation will be fused.
+    """
+
+    assert p <= 1.0 and p >= 0.0
+
+    if p == 1.0:
+        return torch.zeros_like(x)
+
+    # Micro optim, skip dropout
+    if p == 0.0:
+        x = x + bias if bias is not None else x
+        if activation is not None:
+            activation_fn = build_activation(activation)
+            return activation_fn(x)
+        return x
+
+    # The normal triton enabled codepath
+    activation_index = get_triton_activation_index(activation)
+    return _dropout.apply(
+        x,
+        float(p),
+        bias,
+        activation_index,
+        bias is not None and bias.requires_grad,
+    )
+
+
+class FusedDropoutBias(torch.nn.Module):
+    """
+    A layer which fuses the computation of Dropout(Activation(x))
+    in a single GPU kernel
+    """
+
+    def __init__(
+        self,
+        p: float,
+        bias_shape: Optional[int],
+        activation: Optional[Activation] = None,
+    ) -> None:
+        super().__init__()
+
+        self.p = float(p)
+
+        assert (
+            self.p < 1.0
+        ), f"We don't want to drop all the values, most probably p={p} is not properly set"
+
+        self.activation_type = activation
+        self.bias = (
+            torch.zeros(bias_shape, requires_grad=True)
+            if bias_shape is not None
+            else None
+        )
+
+        self.activation = get_triton_activation_index(self.activation_type)
+        self.activation_pytorch = build_activation(self.activation_type)
+
+    def init_weights(self, *args, **kwargs):
+        with torch.no_grad():
+            if self.bias is not None:
+                self.bias.fill_(0.0)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        # Convenience, catch a possible type or device mismatch
+        if self.bias is not None:
+            self.bias = self.bias.to(dtype=x.dtype, device=x.device)  # type: ignore
+
+        # Train/inference
+        p = self.p if self.training else 0.0
+
+        # This kernel is slower than pytorch for small buffers, bypassing it in that case
+        perf_check = x.shape[-1] > 512
+
+        # Catch a non-cuda setup, fallback to pytorch
+        if not x.is_cuda or not perf_check or p == 0.0:
+            x = x + self.bias if self.bias is not None else x
+            x = self.activation_pytorch(x)
+            return torch.nn.functional.dropout(x, p) if p > 0.0 else x
+
+        # The normal, Triton-backed path
+        return _dropout.apply(x, p, self.bias, self.activation, True)
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/fused_linear_layer.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/fused_linear_layer.py
new file mode 100644
index 0000000000000000000000000000000000000000..998cdbdc6ae03d1d9c41494d57c6b928aa18d99f
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/fused_linear_layer.py
@@ -0,0 +1,119 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+import math
+from typing import Any, Optional
+
+import torch
+import torch.nn as nn
+from torch.cuda.amp import custom_bwd, custom_fwd
+
+from xformers.components.activations import Activation
+from xformers.triton.k_activations import get_triton_activation_index
+from xformers.triton.k_fused_matmul_bw import fused_matmul_backward
+from xformers.triton.k_fused_matmul_fw import fused_matmul
+
+
+class _fused_linear_triton(torch.autograd.Function):
+    @staticmethod
+    @custom_fwd(cast_inputs=torch.float16)
+    def forward(
+        ctx,
+        x,
+        weight,
+        bias,
+        activation,
+        trainable_weight,
+        trainable_bias,
+        save_activation_inputs,
+    ):
+
+        # Kick the fused Triton kernel, handling bias and activation in one go
+        y, activation_inputs = fused_matmul(
+            x, weight, bias, activation, save_activation_inputs
+        )
+
+        ctx.activation = activation
+        ctx.trainable_weight = trainable_weight
+        ctx.trainable_bias = trainable_bias
+
+        # Micro-optimization: saving these is not always needed (?)
+        if x.requires_grad or ctx.trainable_weight or ctx.trainable_bias:
+            ctx.save_for_backward(weight, activation_inputs, x)
+
+        return y
+
+    @staticmethod
+    @custom_bwd
+    def backward(
+        ctx: Any, grad_out: torch.Tensor
+    ) -> Any:  # pragma: no cover  # this is covered, but called directly from C++
+        """
+        Compute the derivative with respect to x, other tensors were not trainable inputs.
+        """
+        (weight, activation_inputs, x) = ctx.saved_tensors
+
+        grad_input, grad_weight, grad_bias = fused_matmul_backward(
+            grad_out=grad_out,
+            inputs=x,
+            act_in=activation_inputs,
+            weight=weight,
+            trainable_weight=ctx.trainable_weight,
+            trainable_bias=ctx.trainable_bias,
+            activation_grad=ctx.activation,
+        )
+
+        return grad_input, grad_weight, grad_bias, None, None, None, None, None, None
+
+
+class FusedLinear(nn.Module):
+    """
+    Handle a linear transform, like torch.nn.Linear_, and a given activation, in a single kernel.
+    The whole transform: is :math:`y = activation(xA^T + b)`.
+
+    This is typically significantly faster than PyTorch while using fp16 and non-sigmoid activations,
+    as of September 2021.
+
+    .. _torch.nn.Linear: https://pytorch.org/docs/stable/generated/torch.nn.Linear.html
+    """
+
+    def __init__(
+        self,
+        in_features: int,
+        out_features: int,
+        bias: bool = False,
+        activation: Optional[Activation] = None,
+        **_,
+    ):
+        super().__init__()
+        self.weight = nn.Parameter(
+            torch.empty(out_features, in_features), requires_grad=True
+        )
+        self.bias = (
+            nn.Parameter(torch.empty(out_features), requires_grad=True)
+            if bias
+            else None
+        )
+
+        self._activation_index = get_triton_activation_index(activation)
+        self.reset_parameters()
+
+    def reset_parameters(self) -> None:
+        torch.nn.init.kaiming_uniform_(self.weight, a=math.sqrt(5))
+        if self.bias is not None:
+            fan_in, _ = torch.nn.init._calculate_fan_in_and_fan_out(self.weight)
+            bound = 1 / math.sqrt(fan_in) if fan_in > 0 else 0
+            torch.nn.init.uniform_(self.bias, -bound, bound)
+
+    def forward(self, x):
+        return _fused_linear_triton.apply(
+            x,
+            self.weight,
+            self.bias,
+            self._activation_index,
+            self.weight.requires_grad,
+            self.bias.requires_grad if self.bias is not None else False,
+            self.training and x.requires_grad and self._activation_index > 0,
+        )
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/k_activations.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/k_activations.py
new file mode 100644
index 0000000000000000000000000000000000000000..e60b6edf3e25b88aa4f9118a3dd3c41a4968433c
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/k_activations.py
@@ -0,0 +1,152 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+import math
+from typing import Optional
+
+import triton
+import triton.language as tl
+
+from xformers.components import Activation
+
+_kAlpha = math.sqrt(2.0 / math.pi)
+
+
+def get_triton_activation_index(activation: Optional[Activation]) -> int:
+    return (
+        {
+            Activation.ReLU: 1,
+            Activation.LeakyReLU: 2,
+            Activation.GeLU: 3,
+            Activation.SquaredReLU: 4,
+            Activation.SmeLU: 5,
+            Activation.StarReLU: 6,
+        }[activation]
+        if activation is not None
+        else 0
+    )
+
+
+@triton.jit
+def tanh(x):
+    # Tanh is just a scaled sigmoid
+    return 2 * tl.sigmoid(2 * x) - 1
+
+
+@triton.jit
+def cosh(x):
+    exp_x = tl.exp(x)
+    return (exp_x + 1.0 / exp_x) * 0.5
+
+
+# a Triton implementation of the most used activations
+# See for instance http://arxiv.org/abs/1606.08415 for an overview
+
+# ReLU
+@triton.jit
+def relu(x):
+    """
+    ReLU_ activation function
+
+    .. _ReLU: https://pytorch.org/docs/stable/generated/torch.nn.ReLU.html
+    """
+    return tl.where(x >= 0, x, 0.0)
+
+
+@triton.jit
+def relu_grad(x):
+    # ReLU is different from other activations
+    # in that it does not require the input to retrospectively compute its gradient
+    # here the input is the downstream gradient, and we return the upstream gradient directly
+    return tl.where(x >= 0, 1.0, 0.0)
+
+
+@triton.jit
+def squared_relu(x):
+    """
+    Squared ReLU activation, as proposed in the Primer_ paper.
+
+    .. _Primer: https://arxiv.org/abs/2109.08668
+    """
+    x_sq = x * x
+    return tl.where(x > 0.0, x_sq, 0.0)
+
+
+@triton.jit
+def squared_relu_grad(x):
+    return tl.where(x >= 0.0, 2 * x, 0.0)
+
+
+@triton.jit
+def star_relu(x):
+    """
+    Star ReLU activation, as proposed in the "MetaFormer Baselines for Vision"_ paper.
+
+    .. _ "MetaFormer Baselines for Vision": https://arxiv.org/pdf/2210.13452.pdf
+    """
+    x_sq = x * x
+    return 0.8944 * tl.where(x > 0.0, x_sq, 0.0) - 0.4472
+
+
+@triton.jit
+def star_relu_grad(x):
+    return tl.where(x >= 0.0, 1.7888 * x, 0.0)
+
+
+# Leaky ReLU
+@triton.jit
+def leaky_relu(x):
+    """
+    LeakyReLU_ activation
+
+    .. _LeakyReLU: https://pytorch.org/docs/stable/generated/torch.nn.LeakyReLU.html
+    """
+    return tl.where(x >= 0.0, x, 0.01 * x)
+
+
+@triton.jit
+def leaky_relu_grad(x):
+    return tl.where(x >= 0.0, 1.0, 0.01)
+
+
+@triton.jit
+def gelu(x):
+    """
+    GeLU_ activation - Gaussian error linear unit
+
+    .. _GeLU: https://arxiv.org/pdf/1606.08415.pdf
+    """
+    return 0.5 * x * (1 + tanh(_kAlpha * (x + 0.044715 * x * x * x)))
+
+
+@triton.jit
+def gelu_grad(x):
+    # CREDITS: Fast implementation proposed in
+    # https://github.com/NVIDIA/Megatron-LM/blob/main/megatron/model/fused_bias_gelu.py#L30
+    tanh_out = tanh(0.79788456 * x * (1 + 0.044715 * x * x))
+    return 0.5 * x * (
+        (1 - tanh_out * tanh_out) * (0.79788456 + 0.1070322243 * x * x)
+    ) + 0.5 * (1 + tanh_out)
+
+
+@triton.jit
+def smelu(x):
+    """
+    SmeLU_ activation -  Smooth ReLU with beta=2.0
+
+    .. _SmeLU: https://arxiv.org/pdf/2202.06499.pdf
+    """
+    beta = 2.0
+
+    relu = tl.where(x >= beta, x, 0.0)
+    return tl.where(tl.abs(x) <= beta, (x + beta) * (x + beta) / (4.0 * beta), relu)
+
+
+@triton.jit
+def smelu_grad(x):
+    beta = 2.0
+
+    relu_grad = tl.where(x >= beta, 1.0, 0.0)
+    return tl.where(tl.abs(x) <= beta, (beta + x) / (2.0 * beta), relu_grad)
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/k_dropout.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/k_dropout.py
new file mode 100644
index 0000000000000000000000000000000000000000..95f1c4e634f1ee8c4b39911628c97c710f2ac7d8
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/k_dropout.py
@@ -0,0 +1,211 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+# CREDITS: This is heavily inspired by the Triton dropout tutorial
+# https://raw.githubusercontent.com/openai/triton/master/python/tutorials/04-low-memory-dropout.py
+
+import triton
+import triton.language as tl
+
+from xformers.triton.k_activations import (
+    gelu,
+    gelu_grad,
+    leaky_relu,
+    leaky_relu_grad,
+    relu,
+    relu_grad,
+    smelu,
+    smelu_grad,
+    squared_relu,
+    squared_relu_grad,
+)
+
+_configs = [
+    triton.Config({}, num_warps=1),
+    triton.Config({}, num_warps=2),
+    triton.Config({}, num_warps=4),
+    triton.Config({}, num_warps=8),
+    triton.Config({}, num_warps=16),
+]
+
+
+# fmt: off
+@triton.heuristics({"SIZE_RAND_BLOCK": lambda args: args["BLOCK_N"] * args["BLOCK_M"]})
+@triton.autotune(
+    configs=_configs,
+    key=["M", "N", "is_fp16"],
+)
+@triton.jit
+def k_dropout_fw(
+    Y, X, BIAS, SEEDS,
+    stride,
+    M, N,
+    p: tl.constexpr,
+    is_fp16: tl.constexpr,  # autotune
+    ACTIVATION: tl.constexpr,
+    # Meta-parameters
+    BLOCK_M: tl.constexpr,
+    BLOCK_N: tl.constexpr,
+    SIZE_RAND_BLOCK: tl.constexpr,
+    USE_BIAS: tl.constexpr,
+):
+    """
+    Apply dropout on an input tensor
+    Y : Output  (M, N)
+    X : Input   (M, N)
+    BIAS        (N,)
+    SEEDS       (M,)
+    p : dropout probability
+    """
+    # fmt: on
+
+    row_id = tl.program_id(axis=0)
+    rows = row_id * BLOCK_M + tl.arange(0, BLOCK_M)
+
+    col_id = tl.program_id(axis=1)
+    cols = col_id * BLOCK_N + tl.arange(0, BLOCK_N)
+
+    # pointers starting point
+    x_ptrs = X + rows[:, None] * stride + cols[None, :]
+    y_ptrs = Y + rows[:, None] * stride + cols[None, :]
+
+    # good to go, start the layer computations
+    col_mask = cols[None, :] < N
+    p_scale = 1. / (1. - p)
+    if USE_BIAS:
+        b_ptrs = BIAS + cols[None, :]
+        bias = tl.load(b_ptrs, mask=cols[None, :] < N, other=0.)
+    else:
+        bias = x_ptrs  # will not be used
+
+    block_mask = (rows[:, None] < M) & col_mask
+    x = tl.load(x_ptrs, mask=block_mask, other=0.0)
+
+    # optionally apply a fused bias
+    if USE_BIAS:
+        x += bias
+
+    # optional: fused activation (while the data is in shared memory)
+    if ACTIVATION == 1:
+        x = relu(x)
+    elif ACTIVATION == 2:
+        x = leaky_relu(x)
+    elif ACTIVATION == 3:
+        x = gelu(x)
+    elif ACTIVATION == 4:
+        x = squared_relu(x)
+    elif ACTIVATION == 5:
+        x = smelu(x)
+
+    # get the random keep mask
+    rand_offsets = tl.arange(0, SIZE_RAND_BLOCK)
+    seed_int = tl.load(SEEDS + col_id)
+    r = tl.rand(seed_int, rand_offsets)
+    keep_mask = r > p
+
+    # prune and normalize in one go
+    keep = tl.view(keep_mask, x.shape)
+    output = tl.where(keep, (x * p_scale).to(x.dtype), 0.)
+
+    tl.store(y_ptrs, output, mask=block_mask)  # output
+
+
+# fmt: off
+@triton.heuristics({"SIZE_RAND_BLOCK": lambda args: args["BLOCK_N"] * args["BLOCK_M"]})
+@triton.autotune(
+    configs=_configs,
+    key=["M", "N", "is_fp16"],
+)
+@triton.jit
+def k_dropout_bw(
+    GRAD_IN, GRAD_BIAS, GRAD_OUT,
+    INPUTS, BIAS, SEEDS,
+    stride_grad, stride_inputs,
+    M, N,
+    p: tl.constexpr,
+    is_fp16: tl.constexpr,  # autotune
+    ACTIVATION: tl.constexpr,
+    # Meta-parameters
+    BLOCK_M: tl.constexpr,  # heuristics
+    BLOCK_N: tl.constexpr,
+    SIZE_RAND_BLOCK: tl.constexpr,
+    TRAINABLE_BIAS: tl.constexpr,
+    USE_BIAS: tl.constexpr,
+):
+    """
+    Apply dropout on an input tensor
+    GRAD_OUT    (M, N)
+    GRAD_BIAS   (N,)
+    GRAD_IN     (M, N)
+    BIAS        (N,)
+    SEEDS       (N,)
+    p : dropout probability
+    """
+    # fmt: on
+
+    row_id = tl.program_id(axis=0)
+    rows = row_id * BLOCK_M + tl.arange(0, BLOCK_M)
+
+    col_id = tl.program_id(axis=1)
+    cols = col_id * BLOCK_N + tl.arange(0, BLOCK_N)
+
+    # pointers starting point
+    grad_out_ptrs = GRAD_OUT + rows[:, None] * stride_grad + cols[None, :]
+    grad_in_ptrs = GRAD_IN + rows[:, None] * stride_grad + cols[None, :]
+    input_ptrs = INPUTS + rows[:, None] * stride_inputs + cols[None, :]
+
+    # now go over the tiles
+    grad_bias = tl.zeros((BLOCK_N,), dtype=tl.float32)
+    col_mask = cols[None, :] < N
+    p_scale = 1. / (1. - p)
+
+    if USE_BIAS:
+        b_ptrs = BIAS + cols[None, :]
+        bias = tl.load(b_ptrs, mask=col_mask, other=0.)
+
+    block_mask = (rows[:, None] < M) & col_mask
+    grad_out = tl.load(grad_out_ptrs, mask=block_mask, other=0.)
+
+    # optional: fused activation (while the data is in shared memory)
+    if ACTIVATION:
+        inputs = tl.load(input_ptrs, mask=block_mask, other=0.)
+
+        # optionally apply a fused bias
+        if USE_BIAS:
+            inputs += bias
+
+        if ACTIVATION == 1:
+            act_grad = relu_grad(inputs)
+        elif ACTIVATION == 2:
+            act_grad = leaky_relu_grad(inputs)
+        elif ACTIVATION == 3:
+            act_grad = gelu_grad(inputs)
+        elif ACTIVATION == 4:
+            act_grad = squared_relu_grad(inputs)
+        elif ACTIVATION == 5:
+            act_grad = smelu_grad(inputs)
+
+        grad_out *= act_grad
+
+    # randomly prune (and scale) the resulting buffer, possibly a no-op
+    # note that even if we did not save the mask from the FW pass, it is generated
+    # from the same seeds, so the same drop mask is applied here
+    rand_offsets = tl.arange(0, SIZE_RAND_BLOCK)
+    seed_int = tl.load(SEEDS + col_id)
+    r = tl.rand(seed_int, rand_offsets)
+    r = tl.view(r, grad_out.shape)
+    output = tl.where(r > p, (grad_out * p_scale).to(grad_out.dtype), 0.)
+
+    # write-back
+    tl.store(grad_in_ptrs, output, mask=block_mask)
+
+    # optionally accumulate the bias gradient
+    if TRAINABLE_BIAS:
+        grad_bias += tl.sum(output, axis=0)
+
+    if TRAINABLE_BIAS:
+        grad_bias_ptr = GRAD_BIAS + row_id * N + cols
+        tl.store(grad_bias_ptr, grad_bias, mask=cols < N)
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/k_fused_matmul_bw.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/k_fused_matmul_bw.py
new file mode 100644
index 0000000000000000000000000000000000000000..dd1776f85bdf269cc75e13363c3147d77b826e01
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/k_fused_matmul_bw.py
@@ -0,0 +1,161 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+from typing import Optional
+
+import torch
+import triton
+import triton.language as tl
+
+from xformers.triton.k_activations import (
+    gelu_grad,
+    leaky_relu_grad,
+    relu_grad,
+    smelu_grad,
+    squared_relu_grad,
+    star_relu_grad,
+)
+
+
+# fmt: off
+@triton.autotune(
+    configs=[
+        triton.Config({"BLOCK_N": 64}, num_stages=4, num_warps=2),
+        triton.Config({"BLOCK_N": 128}, num_stages=3, num_warps=2),
+        triton.Config({"BLOCK_N": 256}, num_stages=3, num_warps=4),
+        triton.Config({"BLOCK_N": 512}, num_stages=3, num_warps=4),
+        triton.Config({"BLOCK_N": 1024}, num_stages=3, num_warps=4),
+    ],
+    key=["N"],
+)
+@triton.heuristics({
+    'EVEN_N': lambda args: args["N"] % (args['BLOCK_N']) == 0,
+})
+@triton.jit
+def kernel_bw(
+    # Pointers to matrices
+    GRAD_ACT, GRAD_OUT, ACT_INPUTS,
+    # Matrix dimensions
+    N,
+    # The stride variables represent how much to increase the ptr by when moving by 1
+    # element in a particular dimension. E.g. stride_am is how much to increase a_ptr
+    # by to get the element one row down (A has M rows)
+    stride_gom, stride_aim,
+    # Meta-parameters
+    BLOCK_N: tl.constexpr,
+    EVEN_N: tl.constexpr,
+    ACTIVATION_GRAD: tl.constexpr,
+):
+    # fmt: on
+
+    """
+    Go over all the activation inputs, compute the corresponding gradient
+    """
+
+    # this kernel is relatively simple in terms of scheduling:
+    # - per row (pid_m)
+    # - each program a given chunk on the col axis,
+    # since it's more effective memory and occupancy wise
+    pid_m, pid_n = tl.program_id(axis=0), tl.program_id(axis=1)
+    rn = pid_n * BLOCK_N + tl.arange(0, BLOCK_N)
+
+    # the memory addresses of elements in the first block of
+    # A and W can be computed using numpy-style broadcasting
+    act_input_ptrs = ACT_INPUTS + pid_m * stride_aim + rn
+
+    # compute the gradient which is related to this activation
+    if EVEN_N:
+        act_in = tl.load(act_input_ptrs)
+    else:
+        act_in = tl.load(act_input_ptrs, mask=rn < N, other=0.0)
+
+    if ACTIVATION_GRAD == 1:
+        grad_act = relu_grad(act_in)
+    elif ACTIVATION_GRAD == 2:
+        grad_act = leaky_relu_grad(act_in)
+    elif ACTIVATION_GRAD == 3:
+        grad_act = gelu_grad(act_in)
+    elif ACTIVATION_GRAD == 4:
+        grad_act = squared_relu_grad(act_in)
+    elif ACTIVATION_GRAD == 5:
+        grad_act = smelu_grad(act_in)
+    elif ACTIVATION_GRAD == 6:
+        grad_act = star_relu_grad(act_in)
+    else:
+        grad_act = act_in
+
+    # now read the incoming gradient, the backpropagated one is the multiple of both
+    grad_out_ptrs = GRAD_OUT + pid_m * stride_gom + rn
+    if EVEN_N:
+        grad_out = tl.load(grad_out_ptrs)
+    else:
+        grad_out = tl.load(grad_out_ptrs, mask=rn < N)
+
+    grad_act *= grad_out
+
+    # write back result
+    grad_act_ptrs = GRAD_ACT + pid_m * stride_gom + rn
+    tl.store(grad_act_ptrs, grad_act, mask=rn < N)
+
+
+def fused_matmul_backward(
+    grad_out: torch.Tensor,
+    inputs: torch.Tensor,
+    act_in: Optional[torch.Tensor],
+    weight: torch.Tensor,
+    trainable_weight: bool,
+    trainable_bias: bool,
+    activation_grad: int = 0,
+):
+    """
+    Compute grad_in = activation^-1(grad_out) @ weight.transpose()
+
+    .. note: The weight buffer is transposed on the fly
+    .. note: Activation gradient needs to be a Triton kernel
+    """
+
+    # Make sure that we don't have to handle the stride over cols
+    if not grad_out.is_contiguous():
+        grad_out = grad_out.contiguous()
+
+    grad_out_ = grad_out if grad_out.ndim == 2 else grad_out.flatten(0, -2)
+    inputs_ = inputs if inputs.ndim == 2 else inputs.flatten(0, -2)
+
+    assert grad_out_.shape[1] == weight.shape[0], "Incompatible dimensions in between grad_out and weight"
+
+    M, N = grad_out_.shape
+    N, _ = weight.shape
+
+    # Compute the gradient for the activation
+    if activation_grad > 0:
+        grad_act = torch.empty_like(grad_out_)
+
+        # Some activations do not require their inputs to
+        # know of their grad, the downstream grad is enough
+        if act_in is None:
+            act_in = grad_out_
+
+        grid = lambda META: (M, triton.cdiv(N, META["BLOCK_N"])) # noqa
+
+        # fmt: off
+        kernel_bw[grid](
+            grad_act, grad_out_, act_in,            # data ptrs
+            N,                                      # shapes
+            grad_act.stride(0), act_in.stride(0),   # strides
+            ACTIVATION_GRAD=activation_grad,        # optional fused activation
+        )
+        # fmt: on
+
+        # Backpropagation going up, the reference gradient is now
+        # just before the activation
+        grad_out_ = grad_act
+
+    # The following ops can also be handled by pytorch
+    grad_in = triton.ops.matmul(grad_out_, weight)
+    grad_weight = grad_out_.transpose(1, 0) @ inputs_ if trainable_weight else None
+    grad_bias = torch.sum(grad_out_, dim=0) if trainable_bias else None
+
+    return grad_in.reshape_as(inputs), grad_weight, grad_bias
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/k_fused_matmul_fw.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/k_fused_matmul_fw.py
new file mode 100644
index 0000000000000000000000000000000000000000..0f0e38125835129b0c684ced5645ac18953dd2c0
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/k_fused_matmul_fw.py
@@ -0,0 +1,253 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+from typing import Optional
+
+import torch
+import triton
+import triton.language as tl
+
+from xformers.triton.k_activations import (
+    gelu,
+    leaky_relu,
+    relu,
+    smelu,
+    squared_relu,
+    star_relu,
+)
+
+# CREDITS: Initially inspired by the Triton tutorial on matrix multiplications
+
+
+def get_configs(block_k):
+    return [
+        triton.Config(
+            {"BLOCK_M": 64, "BLOCK_N": 32, "BLOCK_K": block_k},
+            num_stages=4,
+            num_warps=2,
+        ),
+        triton.Config(
+            {"BLOCK_M": 32, "BLOCK_N": 64, "BLOCK_K": block_k},
+            num_stages=4,
+            num_warps=2,
+        ),
+        triton.Config(
+            {"BLOCK_M": 128, "BLOCK_N": 64, "BLOCK_K": block_k},
+            num_stages=3,
+            num_warps=4,
+        ),
+        triton.Config(
+            {"BLOCK_M": 64, "BLOCK_N": 128, "BLOCK_K": block_k},
+            num_stages=3,
+            num_warps=4,
+        ),
+        triton.Config(
+            {"BLOCK_M": 128, "BLOCK_N": 128, "BLOCK_K": block_k},
+            num_stages=3,
+            num_warps=4,
+        ),
+        triton.Config(
+            {"BLOCK_M": 64, "BLOCK_N": 256, "BLOCK_K": block_k},
+            num_stages=3,
+            num_warps=4,
+        ),
+        triton.Config(
+            {"BLOCK_M": 256, "BLOCK_N": 64, "BLOCK_K": block_k},
+            num_stages=3,
+            num_warps=4,
+        ),
+        # Fails on small GPUS
+        # triton.Config(
+        #     {"BLOCK_M": 128, "BLOCK_N": 256, "BLOCK_K": block_k},
+        #     num_stages=3,
+        #     num_warps=8,
+        # ),
+        # triton.Config(
+        #     {"BLOCK_M": 256, "BLOCK_N": 128, "BLOCK_K": block_k},
+        #     num_stages=3,
+        #     num_warps=8,
+        # ),
+    ]
+
+
+# fmt: off
+@triton.autotune(
+    configs=[c for block_k in [32, 64] for c in get_configs(block_k)],
+    key=["M", "N", "K"],
+)
+@triton.heuristics({
+    'EVEN_N': lambda args: args["N"] % (args['BLOCK_N']) == 0,
+})
+@triton.jit
+def kernel_fma(
+    # Pointers to matrices
+    OUT, ACT_INPUTS, INPUT, WEIGHT, bias,
+    # Matrix dimensions
+    M, N, K,
+    # The stride variables represent how much to increase the ptr by when moving by 1
+    # element in a particular dimension. E.g. stride_am is how much to increase a_ptr
+    # by to get the element one row down (A has M rows)
+    stride_om, stride_im,
+    stride_wn,
+    # Meta-parameters
+    BLOCK_M: tl.constexpr, GROUP_M: tl.constexpr,
+    BLOCK_N: tl.constexpr, BLOCK_K: tl.constexpr,
+    EVEN_N: tl.constexpr,
+    BIAS: tl.constexpr,
+    SAVE_ACT_INPUTS: tl.constexpr,
+    ACTIVATION: tl.constexpr,
+    is_fp16: tl.constexpr,  # autotune
+):
+    # fmt: on
+
+    """
+    Kernel for computing Out = activation(A x W + C)
+
+    - Input has shape (M, K)
+    - Weight has shape (K, N)
+    - Bias has shape (N,)
+    - Output has shape (M, N)
+    - ActInputs (optional) has shape (M, N)
+
+    'ActInputs' optionally saves the A x W + C intermediate for backward computations
+
+    This kernel will consolidate over K
+    """
+
+    # programs are grouped together to improve L2 hit rate
+    # the logic is that we'll consolidate over K. If the programs were not grouped,
+    # then multiple cols/rows in the result would end up pulling in the same row and lines
+    # from the inputs. By grouping the computation we ensure some data reuse, which the hardware
+    # covers via the L2 cache
+    pid = tl.program_id(axis=0)
+
+    num_pid_m = tl.cdiv(M, BLOCK_M)  # number of program ids along the M axis
+    num_pid_n = tl.cdiv(N, BLOCK_N)  # number of programs ids along the N axis
+    num_pid_in_group = GROUP_M * num_pid_n  # number of programs in group
+    group_id = pid // num_pid_in_group  # id of the group this program is in
+    first_pid_m = group_id * GROUP_M  # row-id of the first program in the group
+    GROUP_M = min(
+        num_pid_m - first_pid_m, GROUP_M
+    )  # if `num_pid_m` isn't divisible by `GROUP_M`, the last group is smaller
+
+    # *within groups*, programs are ordered in a column-major order
+    # row-id /col-id of the program in the *launch grid*
+    pid_m = first_pid_m + (pid % GROUP_M)
+    pid_n = (pid % num_pid_in_group) // GROUP_M
+
+    # now compute the block that each program will go through
+    # rm (resp. rn) denotes a range of indices
+    # for rows (resp. col) of C
+    rm = pid_m * BLOCK_M + tl.arange(0, BLOCK_M)
+    rn = pid_n * BLOCK_N + tl.arange(0, BLOCK_N)
+    rk = tl.arange(0, BLOCK_K)
+
+    # the memory addresses of elements can follow numpy broadcasting
+    input_ptrs = INPUT + rm[:, None] * stride_im
+    weight_ptrs = WEIGHT + rn[None, :] * stride_wn
+
+    # initialize and iteratively update accumulator
+    acc = tl.zeros((BLOCK_M, BLOCK_N), dtype=tl.float32)
+
+    if BIAS:
+        if EVEN_N:
+            bias = tl.load(bias + rn).to(tl.float32)
+        else:
+            bias = tl.load(bias + rn, mask=rn < N, other=0.0).to(tl.float32)
+        acc += bias[None, :]
+
+    # block level matrix multiplication.
+    # We fetch a block memory block from both inputs, matmul and accumulate, then repeat
+    mask_rn = rn < N
+    mask_rm = rm < M
+
+    for i in range(0, K, BLOCK_K):
+        rk = tl.arange(0, BLOCK_K) + i
+        a = tl.load(input_ptrs + rk[None, :], mask=((rk[None, :] < K) & mask_rm[:, None]), other=0.0)
+        w = tl.load(weight_ptrs + rk[:, None], mask=((rk[:, None] < K) & mask_rn[None, :]), other=0.0)
+
+        acc += tl.dot(a, w)
+
+    rm = pid_m * BLOCK_M + tl.arange(0, BLOCK_M)
+    rn = pid_n * BLOCK_N + tl.arange(0, BLOCK_N)
+
+    # optional: save the activation inputs
+    if SAVE_ACT_INPUTS:
+        act_in_ptrs = ACT_INPUTS + rm[:, None] * stride_om + rn[None, :]
+        tl.store(act_in_ptrs, acc, mask=mask_rm[:, None] & mask_rn[None, :])
+
+    # optional: fused activation (while the data is in shared memory)
+    if ACTIVATION == 1:
+        acc = relu(acc)
+    elif ACTIVATION == 2:
+        acc = leaky_relu(acc)
+    elif ACTIVATION == 3:
+        acc = gelu(acc)
+    elif ACTIVATION == 4:
+        acc = squared_relu(acc)
+    elif ACTIVATION == 5:
+        acc = smelu(acc)
+    elif ACTIVATION == 6:
+        acc = star_relu(acc)
+
+    # write back result
+    out_ptrs = OUT + rm[:, None] * stride_om + rn[None, :]
+    tl.store(out_ptrs, acc, mask=mask_rm[:, None] & mask_rn[None, :])
+
+
+# Activation needs to be a triton kernel
+def fused_matmul(
+    x: torch.Tensor,
+    weight: torch.Tensor,
+    bias: Optional[torch.Tensor],
+    activation=0,
+    save_act_inputs: bool = False
+):
+    """
+    Compute e = activation(x @ weight + bias).
+    This wrapper kicks the `kernel_fma` Triton kernel
+    """
+
+    if not x.is_contiguous():
+        x = x.contiguous()
+
+    x_ = x if x.ndim == 2 else x.flatten(0, -2)
+
+    assert (
+        x_.shape[1] == weight.shape[1]
+    ), f"Incompatible dimensions in between inputs and weight, {x_.shape} - {weight.shape}"
+    assert bias is None or bias.is_contiguous()
+    assert (
+        bias is None or bias.shape[0] == weight.shape[0]
+    ), "Incompatible dimensions in between weight and bias"
+    assert weight.is_contiguous()
+
+    M, K = x_.shape
+    N, K = weight.shape
+
+    outputs = torch.empty((M, N), device=x.device, dtype=x.dtype)
+    act_inputs = torch.empty_like(outputs) if save_act_inputs else x  # will not be used in that case
+
+    # 1D launch kernel where each block gets its own program.
+    grid = lambda META: (triton.cdiv(M, META["BLOCK_M"]) * triton.cdiv(N, META["BLOCK_N"]),) # noqa
+
+    # fmt: off
+    kernel_fma[grid](
+        outputs, act_inputs, x_, weight,            # data ptrs
+        bias if bias is not None else x,            # auto skip bias if not present
+        M, N, K,                                    # shapes
+        outputs.stride(0), x_.stride(0),            # strides
+        weight.stride(0),
+        ACTIVATION=activation,                      # optional fused activation
+        BIAS=bias is not None,                      # optional fused bias
+        GROUP_M=8,                                  # speed optimization: group the programs
+        SAVE_ACT_INPUTS=save_act_inputs,
+        is_fp16=x_.dtype == torch.float16
+    )
+    # fmt: on
+
+    outputs = outputs if x.ndim == 2 else outputs.reshape(*x.shape[:-1], N)
+
+    return outputs, act_inputs if save_act_inputs else None
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/k_layer_norm.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/k_layer_norm.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc1c804445ec16ea4ec9691c2cd8f46a56540811
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/k_layer_norm.py
@@ -0,0 +1,179 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+# CREDITS: This comes almost as-is from the Triton layer norm tutorial
+# https://github.com/openai/triton/blob/master/python/tutorials/05-layer-norm.py
+
+
+import triton
+import triton.language as tl
+
+
+# fmt: off
+@triton.jit
+def layer_norm_fw(X, Y, W, B, M, V, stride, N, eps, affine: tl.constexpr, BLOCK_SIZE_N: tl.constexpr):
+    # fmt: on
+    """
+    Fused layernorm kernel over a 3d tensor.
+    The layer norm is applied over the last dimension.
+
+    Compute
+        y = (x - E(x))/(sqrt(var(x) + epsilon)) * gamma + beta
+    """
+
+    row = tl.program_id(0)
+    cols = tl.arange(0, BLOCK_SIZE_N)
+    mask = cols < N
+
+    # Move to this row
+    x_ptrs = X + row * stride + cols
+    x = tl.load(x_ptrs, mask=mask, other=0.0).to(tl.float32)
+
+    # Compute mean and variance
+    mean = tl.sum(x, axis=0) / N
+    x_zm = tl.where(mask, x - mean, 0.0)
+    tl.store(M + row, mean)
+
+    x_var = tl.sum(x_zm * x_zm, axis=0) / N
+    rstd = 1.0 / tl.sqrt(x_var + eps)
+
+    # Normalize, optionally affine
+    y = x_zm * rstd
+    tl.store(V + row, rstd)
+
+    mask = cols < N
+    if affine:
+        w = tl.load(W + cols, mask=mask, other=1.0)
+        b = tl.load(B + cols, mask=mask, other=0.0)
+        y = y * w + b
+
+    y_ptrs = Y + row * stride + cols
+    tl.store(y_ptrs, y, mask=mask)
+
+
+# Backward pass (DX + partial DW + partial DB)
+# fmt: off
+@triton.jit
+def layer_norm_bwd_dx_fused(
+    DX, DY, DW, DB,
+    X, W, M, V,
+    Lock, stride, N,
+    # META-parameters
+    affine: tl.constexpr,
+    GROUP_SIZE_M: tl.constexpr,
+    BLOCK_SIZE_N: tl.constexpr,
+):
+    # fmt: on
+
+    # position of elements processed by this program
+    row = tl.program_id(0)
+    cols = tl.arange(0, BLOCK_SIZE_N)
+    mask = cols < N
+
+    # offset data pointers to start at the row of interest
+    x_ptrs = X + row * stride + cols
+    dy_ptrs = DY + row * stride + cols
+
+    # load data to SRAM
+    x = tl.load(x_ptrs, mask=mask, other=0)
+    dy = tl.load(dy_ptrs, mask=mask, other=0)
+    mean = tl.load(M + row)
+    rstd = tl.load(V + row)
+
+    # compute dx
+    xhat = (x - mean) * rstd
+
+    if affine:
+        w = tl.load(W + cols, mask=mask, other=0)
+        wdy = w * dy
+    else:
+        wdy = dy
+
+    xhat = tl.where(mask, xhat, 0.)
+    wdy = tl.where(mask, wdy, 0.)
+    mean1 = tl.sum(xhat * wdy, axis=0) / N
+    mean2 = tl.sum(wdy, axis=0) / N
+    dx = (wdy - (xhat * mean1 + mean2)) * rstd
+
+    # write-back dx
+    cols = tl.arange(0, BLOCK_SIZE_N)
+    mask = cols < N  # re-materialize the mask to save registers
+    dx_ptrs = DX + row * stride + cols
+    tl.store(dx_ptrs, dx, mask=mask)
+
+    if affine:
+        # accumulate partial sums for dw/db
+        partial_dw = (dy * xhat).to(w.dtype)
+        partial_db = dy.to(w.dtype)
+
+        # offset locks and weight/bias gradient pointer
+        # each kernel instance accumulates partial sums for
+        # DW and DB into one of GROUP_SIZE_M independent buffers
+        # these buffers stay in the L2, which allow this kernel
+        # to be fast
+        lock_id = row % GROUP_SIZE_M
+        Lock += lock_id
+        Count = Lock + GROUP_SIZE_M
+
+        # - wait for a lock on the accumulated dw/db
+        while tl.atomic_cas(Lock, 0, 1) == 1:
+            pass
+        count = tl.load(Count)
+
+        # - we got the lock, accumulate this kernel's results with
+        # the stored values.
+        dw_ptrs = DW + lock_id * N + cols
+        db_ptrs = DB + lock_id * N + cols
+
+        if count == 0:
+            # first store doesn't accumulate
+            tl.atomic_xchg(Count, 1)
+        else:
+            partial_dw += tl.load(dw_ptrs, mask=mask, other=0.)
+            partial_db += tl.load(db_ptrs, mask=mask, other=0.)
+
+        tl.store(dw_ptrs, partial_dw, mask=mask)
+        tl.store(db_ptrs, partial_db, mask=mask)
+
+        # release lock
+        tl.atomic_xchg(Lock, 0)
+
+
+# Backward pass (total DW + total DB)
+# fmt: off
+@triton.jit
+def layer_norm_bwd_dwdb(
+    DW, DB, FINAL_DW, FINAL_DB,
+    M, N,
+    BLOCK_SIZE_M: tl.constexpr,
+    BLOCK_SIZE_N: tl.constexpr
+):
+    # fmt: on
+
+    pid = tl.program_id(0)
+
+    cols = pid * BLOCK_SIZE_N + tl.arange(0, BLOCK_SIZE_N)
+    mask_cols = cols < N
+
+    dw = tl.zeros((BLOCK_SIZE_M, BLOCK_SIZE_N), dtype=tl.float32)
+    db = tl.zeros((BLOCK_SIZE_M, BLOCK_SIZE_N), dtype=tl.float32)
+
+    for i in range(0, M, BLOCK_SIZE_M):
+        rows = i + tl.arange(0, BLOCK_SIZE_M)
+        offs = rows[:, None] * N + cols[None, :]
+        mask_rm = rows < M
+
+        dw += tl.load(DW + offs, mask=mask_rm[:, None] & mask_cols[None, :], other=0.0)
+        db += tl.load(DB + offs, mask=mask_rm[:, None] & mask_cols[None, :], other=0.0)
+
+    sum_dw = tl.sum(dw, axis=0)
+    sum_db = tl.sum(db, axis=0)
+
+    cols = pid * BLOCK_SIZE_N + tl.arange(0, BLOCK_SIZE_N)
+    mask_cols = cols < N
+
+    tl.store(FINAL_DW + cols, sum_dw, mask=mask_cols)
+    tl.store(FINAL_DB + cols, sum_db, mask=mask_cols)
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/k_softmax.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/k_softmax.py
new file mode 100644
index 0000000000000000000000000000000000000000..4dc99de1739e3351799bc463a44d92f9351ec22e
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/k_softmax.py
@@ -0,0 +1,175 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+import triton
+import triton.language as tl
+
+# CREDITS: This is adapted from the vanilla Triton example. See https://openai.com/blog/triton/
+# and https://triton-lang.org/getting-started/tutorials/02-fused-softmax.html
+
+
+def get_depth(args):
+    return triton.next_power_of_2(args["K"])
+
+
+# autotune: Triton will test out these configurations, and automatically pick the fastest one.
+# heuristic: add arguments to the kernel call automatically given some heuristics. These arguments are passed in "meta"
+# fmt: off
+@triton.autotune(
+    configs=[
+        triton.Config({}, num_warps=1),
+        triton.Config({}, num_warps=2),
+        triton.Config({}, num_warps=4),
+        triton.Config({}, num_warps=8),
+        triton.Config({}, num_warps=16),
+        triton.Config({}, num_warps=32),
+    ],
+    key=["K"],
+)
+@triton.heuristics(values={"depth": get_depth})
+@triton.jit
+def _softmax(
+    Y, X, M,
+    stride_ym, stride_yn,
+    stride_xm, stride_xn,
+    stride_mn,
+    K,
+    # Meta-params
+    depth: tl.constexpr,
+    causal: tl.constexpr,
+    use_mask: tl.constexpr,
+    log: tl.constexpr,
+):
+    # fmt: om
+
+    """
+    Fused softmax kernel over a 3d tensor.
+    The softmax is applied over the last dimension, meaning that this is equivalent to torch.softmax(tensor, dim=-1)
+
+    Note, if the last dimension is large, say 128K elements, the kernel compile time can shot up to many minutes when
+    the kernel is run for the first time.
+    """
+
+    m = tl.program_id(0)
+    n = tl.program_id(1)
+
+    # col indices
+    k = tl.arange(0, depth)
+
+    # the memory address of all the elements that we want to load can be computed as follows
+    x_ptrs = X + m * stride_xm + n * stride_xn + k
+
+    # load input data; pad out-of-bounds elements with 0
+    io_mask = k < K
+
+    # Causal - 1: skip on the loads directly
+    if causal:
+        io_mask = io_mask & (k <= n)
+
+    x = tl.load(x_ptrs, mask=io_mask, other=float("-inf")).to(tl.float32)
+
+    # Causal - 2: enforce correctness over a couple of misloaded values
+    if causal:
+        off = float("-inf")
+        off = off.to(x.dtype)  # type: ignore
+        x = tl.where(k > n, off, x)
+
+    if use_mask:
+        mask_ptrs = M + n * stride_mn + k
+        add_mask = tl.load(mask_ptrs, io_mask, other=float("-inf")).to(tl.float32)
+        x += add_mask
+
+    # compute numerically-stable softmax
+    z = x - tl.max(x, axis=0)
+    num = tl.exp(z)
+    denom = tl.sum(num, axis=0)
+
+    if log:
+        y = z - tl.log(denom)
+    else:
+        y = num / denom
+
+    # write back to Y.
+    # we only write once, hence the "fused" softmax naming
+    y_ptrs = Y + m * stride_ym + n * stride_yn + k
+
+    # technically we could write only the lower triangular matrix in the causal case
+    # but this is deemed to error prone
+    tl.store(y_ptrs, y, mask=k < K)
+
+
+# fmt: off
+@triton.autotune(
+    configs=[
+        triton.Config({}, num_warps=1),
+        triton.Config({}, num_warps=2),
+        triton.Config({}, num_warps=4),
+        triton.Config({}, num_warps=8),
+        triton.Config({}, num_warps=16),
+    ],
+    key=["K"],
+)
+@triton.jit
+def _softmax_backward(
+    GradIn, GradOut, Out,
+    stride_bm, stride_bn,
+    stride_gm, stride_gn,
+    stride_om, stride_on,
+    K,
+    # meta-params
+    depth: tl.constexpr,
+    causal: tl.constexpr,
+    log: tl.constexpr,
+):
+    # fmt: on
+
+    """
+    Compute the softmax gradients.
+    ..Note: Not autotuning for now because this would lead to broken accumulated gradients
+    """
+
+    m = tl.program_id(0)
+    n = tl.program_id(1)
+
+    # col indices
+    k = tl.arange(0, depth)
+
+    # the memory address of all the elements that we want to load can be computed as follows
+    grad_out_ptrs = GradOut + m * stride_gm + n * stride_gn + k
+    out_ptrs = Out + m * stride_om + n * stride_on + k
+
+    # load input data; pad out-of-bounds elements with 0
+    io_mask = k < K
+
+    # Causal - 1: skip on the loads directly
+    if causal:
+        io_mask = io_mask & (k <= n)
+
+    g = tl.load(grad_out_ptrs, mask=io_mask, other=float(0)).to(tl.float32)
+    o = tl.load(out_ptrs, mask=io_mask, other=float(0)).to(tl.float32)
+
+    # Causal - 2: enforce correctness over a couple of misloaded values
+    if causal:
+        zero = float(0)
+        zero = zero.to(g.dtype)  # type: ignore
+        g = tl.where(k > n, zero, g)
+        o = tl.where(k > n, zero, o)
+
+    if log:
+        s = tl.sum(g, 0)
+        grad_in = g - tl.exp(o) * s
+    else:
+        # Step 1: Compute the intermediate sum used for the gradient
+        s = tl.sum(g * o, 0)
+
+        # Step 2: Compute the gradients
+        grad_in = o * (g - s)
+
+    # write back to the input gradients
+    # technically we could write only the lower triangular matrix in the causal case
+    # but this is deemed to error prone
+    grad_in_ptrs = GradIn + m * stride_bm + n * stride_bn + k
+    tl.store(grad_in_ptrs, grad_in, mask=k < K)
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/layer_norm.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/layer_norm.py
new file mode 100644
index 0000000000000000000000000000000000000000..cec4cc9b74a2c28a90b3336124255a4337fc8f82
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/layer_norm.py
@@ -0,0 +1,236 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+# CREDITS: the underlying kernel comes straight from the Triton tutorials
+# see https://github.com/openai/triton/blob/master/python/tutorials/05-layer-norm.py
+
+import logging
+from typing import Optional
+
+import torch
+import torch.nn as nn
+import triton
+from torch.cuda.amp import custom_bwd, custom_fwd
+
+from xformers.triton.k_layer_norm import (
+    layer_norm_bwd_dwdb,
+    layer_norm_bwd_dx_fused,
+    layer_norm_fw,
+)
+
+logger = logging.getLogger("xformers")
+
+
+_triton_layernorm_fp16_enabled = False  # NOTE: PyTorch keeps layernorm as fp32
+_triton_registered_warnings = False
+
+
+class _LayerNorm(torch.autograd.Function):
+    @staticmethod
+    @custom_fwd(cast_inputs=torch.float16 if _triton_layernorm_fp16_enabled else None)
+    def forward(ctx, x, weight, bias, eps):
+        # catch eps being too small if the tensors are fp16
+        if x.dtype == torch.float16:
+            eps = max(eps, 1.6e-5)
+
+        # allocate output
+        y = torch.empty_like(x)
+
+        # reshape input data into 2D tensor
+        x_arg = x.reshape(-1, x.shape[-1])
+        M, N = x_arg.shape
+
+        # allocate mean and std, they'll be used in the backward pass
+        mean = torch.empty((M,), dtype=torch.float32, device="cuda")
+        rstd = torch.empty((M,), dtype=torch.float32, device="cuda")
+
+        # Less than 64KB per feature: enqueue fused kernel
+        MAX_FUSED_SIZE = 65536 // x.element_size()
+        BLOCK_SIZE_N = min(MAX_FUSED_SIZE, triton.next_power_of_2(N))
+        if N > BLOCK_SIZE_N:
+            raise RuntimeError("This layer norm doesn't support feature dim >= 64KB.")
+
+        if not x_arg.is_contiguous() or not y.is_contiguous():
+            global _triton_registered_warnings
+            if not _triton_registered_warnings:
+                logger.warning(
+                    "Non-contiguous input tensor found. Making it contiguous,"
+                    + " but could have perf or trainer implications"
+                )
+
+                _triton_registered_warnings = True
+
+            x_arg = x_arg.contiguous()
+            y = y.contiguous()
+
+        # heuristics for number of warps.
+        num_warps = min(max(BLOCK_SIZE_N // 256, 1), 16)
+
+        # enqueue kernel
+        # fmt: off
+        layer_norm_fw[(M,)](
+            x_arg, y, weight, bias, mean, rstd,
+            x_arg.stride(0),
+            N,
+            eps,
+            num_warps=num_warps,
+            BLOCK_SIZE_N=BLOCK_SIZE_N,
+            affine=weight is not None
+        )
+        # fmt: on
+
+        ctx.save_for_backward(x, mean, rstd, weight)
+        ctx.BLOCK_SIZE_N = BLOCK_SIZE_N
+        ctx.num_warps = num_warps
+
+        return y.reshape_as(x)
+
+    @staticmethod
+    @custom_bwd
+    def backward(
+        ctx, dy
+    ):  # pragma: no cover  # this is covered, but called directly from C++
+        x, mean, rstd, weight = ctx.saved_tensors
+
+        # flatten the batch dimension, if any.
+        # We're interested in 'samples' x norm_dimension
+        x = x.reshape(-1, x.size(-1))
+        M, N = x.size()
+
+        # heuristics for amount of parallel reduction stream for DG/DB
+        GROUP_SIZE_M = 32
+        if N <= 8192:
+            GROUP_SIZE_M = 64
+        if N <= 4096:
+            GROUP_SIZE_M = 96
+        if N <= 2048:
+            GROUP_SIZE_M = 128
+        if N <= 1024:
+            GROUP_SIZE_M = 256
+
+        if dy.dtype == torch.float32:
+            GROUP_SIZE_M = GROUP_SIZE_M // 2
+
+        # allocate output
+        locks = torch.zeros(2 * GROUP_SIZE_M, dtype=torch.int32, device="cuda")
+        t_args = {"dtype": x.dtype, "device": x.device}
+        _dw = torch.empty((GROUP_SIZE_M, x.size(-1)), **t_args)
+        _db = torch.empty_like(_dw)
+        dw = torch.empty((x.size(-1),), **t_args)
+        db = torch.empty_like(dw)
+        dy = dy.contiguous()
+        dx = torch.empty_like(dy)
+
+        # Check the tensor shapes and layouts
+        # we suppose in the kernel that they have the same size and are contiguous
+        assert (
+            dy.numel() == x.numel()
+        ), "Something is wrong in the backward graph, possibly because of an inplace operation after the layernorm"
+
+        # enqueue kernel using forward pass heuristics
+        # also compute partial sums for DW and DB
+        num_warps = min(max(ctx.BLOCK_SIZE_N // 256, 1), 16)
+
+        # fmt: off
+        layer_norm_bwd_dx_fused[(M,)](
+            dx, dy, _dw, _db, x,
+            weight if weight is not None else x,
+            mean, rstd,
+            locks,
+            x.stride(0),
+            N,
+            affine=weight is not None,
+            GROUP_SIZE_M=GROUP_SIZE_M,
+            BLOCK_SIZE_N=ctx.BLOCK_SIZE_N,
+            num_warps=num_warps
+        )
+        # fmt: on
+
+        def grid(meta):
+            return [triton.cdiv(N, meta["BLOCK_SIZE_N"])]
+
+        # accumulate partial sums in separate kernel
+        # fmt: off
+        layer_norm_bwd_dwdb[grid](
+            _dw, _db, dw, db,
+            GROUP_SIZE_M,
+            N,
+            BLOCK_SIZE_M=32,
+            BLOCK_SIZE_N=64
+        )
+        # fmt: on
+
+        dx = dx.reshape_as(dy)
+        return dx, dw, db, None
+
+
+class FusedLayerNorm(nn.Module):
+    """
+    Handle a layer normalization, like torch.nn.LayerNorm_.
+
+    This implementation should be measurably faster than the default PyTorch layernorm (as of PyTorch 1.9),
+    both for training and inference worloads.
+
+    .. NOTE: Computations under Torch AMP are kept as float32 by default, one can change this to be float16
+        by setting the flag `xformers.triton.k_layer_norm._triton_layernorm_fp16_enabled = True`
+
+    .. _torch.nn.LayerNorm: https://pytorch.org/docs/stable/generated/torch.nn.LayerNorm.html
+
+    """
+
+    def __init__(self, normalized_shape, affine=True, eps=1e-06):
+        super().__init__()
+        if affine:
+            self.weight = nn.Parameter(torch.ones(normalized_shape))
+            self.bias = nn.Parameter(torch.zeros(normalized_shape))
+        else:
+            self.weight = self.bias = None
+        self.epsilon = eps
+
+    def forward(self, x):
+        return layer_norm(x, self.weight, self.bias, self.epsilon)
+
+    def init_weights(self, *args, **kwargs):
+        with torch.no_grad():
+            if self.weight is not None:
+                self.weight.fill_(1.0)
+
+            if self.bias is not None:
+                self.bias.fill_(0.0)
+
+
+def layer_norm(
+    x: torch.Tensor,
+    weight: Optional[torch.Tensor] = None,
+    bias: Optional[torch.Tensor] = None,
+    eps: float = 1e-06,
+) -> torch.Tensor:
+
+    global _triton_registered_warnings
+
+    r"""Applies normalization over a mini batch of inputs"""
+
+    try:
+        if (
+            not _triton_registered_warnings
+            and torch.cuda.is_available()
+            and x.is_cuda
+            and weight is not None
+            and bias is not None
+        ):
+            return _LayerNorm.apply(x, weight, bias, eps)
+    except RuntimeError as e:
+        # Catch cases where the current GPU does not have enough registers to hold a full tensor line
+        # fallback to PyTorch's implementation, which streams the tensor in and out
+        _triton_registered_warnings = True
+        logger.warning(
+            "Triton layernorm kernel register spillover or invalid image caught. "
+            "Deactivating this kernel, please file an issue in the xFormers repository"
+        )
+        logger.warning(e)
+
+    return torch.nn.functional.layer_norm(
+        x, [x.shape[-1]], weight=weight, bias=bias, eps=eps
+    )
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/softmax.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/softmax.py
new file mode 100644
index 0000000000000000000000000000000000000000..0de7be903f43f89828967214a7aa8474825c5252
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/softmax.py
@@ -0,0 +1,203 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+import logging
+from typing import Optional
+
+import torch
+import triton
+from torch.cuda.amp import custom_bwd, custom_fwd
+
+from xformers.triton.k_softmax import _softmax, _softmax_backward
+
+# CREDITS: This is adapted from the vanilla Triton example. See https://openai.com/blog/triton/
+# and https://triton-lang.org/getting-started/tutorials/02-fused-softmax.html
+
+
+logger = logging.getLogger("xformers")
+
+
+_triton_softmax_fp16_enabled = False  # NOTE: PyTorch keeps softmax as fp32
+_triton_registered_warnings = False
+
+
+# Helper to handle the SPMD launch grid and error cases
+class _softmax_triton(torch.autograd.Function):
+    @staticmethod
+    @custom_fwd(cast_inputs=torch.float16 if _triton_softmax_fp16_enabled else None)
+    def forward(ctx, x, mask, log_outputs, causal):
+        """
+        Fused softmax implementation, using the Triton programming model.
+        This only supports a reduction over the last dimension for now
+        """
+
+        # Handle 2D/3D tensors
+        x_ = x.unsqueeze(0) if x.ndim == 2 else x
+        x_ = x_.flatten(0, -3)
+
+        if not x_.is_contiguous():
+            x_ = x_.contiguous()
+
+        y = torch.empty_like(x_)
+        assert (
+            y.stride(2) == 1 and x_.stride(2) == 1
+        ), f"{x.shape} - {x_.shape} - {x_.stride()}"
+
+        # SPMD launch grid
+        grid_2d = (
+            x_.shape[0],
+            x_.shape[1],
+        )
+
+        # enqueue GPU kernel
+        use_mask = True
+        if mask is None:
+            #  placeholder, will not be used
+            mask = x_
+            use_mask = False
+        else:
+            # Make sure that the mask is binary
+            assert mask.dtype == x.dtype, "An additive mask is requested"
+
+        _softmax[grid_2d](
+            y,
+            x_,
+            mask,
+            y.stride(0),
+            y.stride(1),
+            x_.stride(0),
+            x_.stride(1),
+            mask.stride(0),
+            x_.shape[2],
+            log=log_outputs,
+            use_mask=use_mask,
+            causal=causal,
+        )
+
+        ctx.save_for_backward(y)
+        ctx.log_outputs = log_outputs
+        ctx.causal = causal
+        return y.reshape_as(x)
+
+    @staticmethod
+    @custom_bwd
+    def backward(
+        ctx, grad_out
+    ):  # pragma: no cover  # this is covered, but called directly from C++
+        (out,) = ctx.saved_tensors
+
+        # Handle 2D/3D tensors
+        grad_out_ = grad_out.unsqueeze(0) if grad_out.ndim == 2 else grad_out
+        grad_out_ = grad_out_.flatten(0, -3)
+
+        # SPMD launch grid
+        grid_2d = (
+            grad_out_.shape[0],
+            grad_out_.shape[1],
+        )
+
+        depth = triton.next_power_of_2(grad_out_.shape[2])
+        grad_in = torch.empty_like(
+            out
+        )  # torch.zeros is measurably slower, we'll zero out in the kernel
+
+        # Make sure that the tensor are contiguous
+        grad_in, grad_out, out = map(lambda x: x.contiguous(), [grad_in, grad_out, out])
+
+        # fmt: off
+        _softmax_backward[grid_2d](
+            grad_in, grad_out_, out,
+            grad_in.stride(0), grad_in.stride(1),
+            grad_out_.stride(0), grad_out_.stride(1),
+            out.stride(0), out.stride(1),
+            out.shape[2],
+            depth=depth,
+            log=ctx.log_outputs,
+            causal=ctx.causal
+        )
+        # fmt: on
+        return grad_in.reshape_as(grad_out), None, None, None
+
+
+def softmax(
+    x: torch.Tensor, mask: Optional[torch.Tensor] = None, causal: bool = False
+) -> torch.Tensor:
+    r"""Applies the Softmax function to an 3-dimensional input Tensor
+    rescaling them so that the elements of the n-dimensional output Tensor
+    lie in the range [0,1] and sum to 1.
+
+    Softmax is defined as:
+
+    .. math::
+        \text{Softmax}(x_{i}) = \frac{\exp(x_i)}{\sum_j \exp(x_j)}
+
+    .. warning: softmax is computed on the last dimension of the input tensor.
+
+
+    Args:
+        x: input tensor.
+        mask: optional mask, its application will be fused to the softmax computation if triton is used
+        causal: optional performance optimization, if triton is used and the attention is causal
+
+    Returns:
+        a Tensor of the same dimension and shape as the input with
+        values in the range [0, 1] and sum to 1
+    """
+    return _softmax_dispatch(x, log=False, mask=mask, causal=causal)
+
+
+def log_softmax(
+    x: torch.Tensor, mask: Optional[torch.Tensor] = None, causal: bool = False
+) -> torch.Tensor:
+    r"""Applies the :math:`\log(\text{Softmax}(x))` function to an 3-dimensional
+    input Tensor. The LogSoftmax formulation can be simplified as:
+
+    .. math::
+        \text{LogSoftmax}(x_{i}) = \log\left(\frac{\exp(x_i) }{ \sum_j \exp(x_j)} \right)
+
+    Args:
+        x: input tensor.
+
+    Returns:
+        a Tensor of the same dimension and shape as the input with
+        values in the range [-inf, 0)
+    """
+    return _softmax_dispatch(x, log=True, mask=mask, causal=causal)
+
+
+def _softmax_dispatch(
+    x: torch.Tensor, log: bool, mask: Optional[torch.Tensor], causal: bool = False
+) -> torch.Tensor:
+    # Triton is used if
+    # - CUDA
+    # - there's enough data to make it faster than pytorch. This could change over time, Triton is improving
+    # - there was no previous failure
+
+    global _triton_registered_warnings
+
+    try:
+        if torch.cuda.is_available() and x.is_cuda and not _triton_registered_warnings:
+            return _softmax_triton.apply(x, mask, log, causal)
+    except RuntimeError as e:
+        # Catch cases where the current GPU does not have enough registers to hold a full tensor line
+        # fallback to PyTorch's implementation, which streams the tensor in and out
+        _triton_registered_warnings = True
+        logger.warning(
+            "Triton softmax kernel register spillover or invalid image caught."
+            "Deactivating this kernel, please file an issue int the xFormers repository"
+        )
+        logger.warning(e)
+
+    if mask is not None:
+        x = x + mask
+
+    if causal:
+        x = x + torch.triu(torch.full_like(x, float("-inf")), diagonal=1)
+
+    if log:
+        return torch.log_softmax(x, dim=-1)
+    else:
+        return torch.softmax(x, dim=-1)
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/vararg_kernel.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/vararg_kernel.py
new file mode 100644
index 0000000000000000000000000000000000000000..f99436209a6722972ec2bf62f68addc046bd1c41
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/triton/vararg_kernel.py
@@ -0,0 +1,173 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+import ast
+import copy
+import functools
+import linecache
+import sys
+from typing import Any, Dict, List
+
+import triton
+
+
+class _ForLoopUnroller(ast.NodeTransformer):
+    def __init__(self, target, inline_variables, loop_iter):
+        self.loop_iter = loop_iter
+        self.target = target
+        self.inline_variables = inline_variables
+
+    def visit_Name(self, node):
+        if node.id != self.target:
+            return node
+        return ast.Name(str(self.loop_iter))
+
+    def visit_Subscript(self, node):
+        # Pattern-matching `value[slice]`
+        if (
+            isinstance(node.slice, ast.Name)
+            and node.slice.id == self.target
+            and isinstance(node.value, ast.Name)
+            and node.value.id in self.inline_variables
+        ):
+            return ast.Name(f"{node.value.id}{self.loop_iter}")
+        return node
+
+
+class _VisitorUnrollKernel(ast.NodeTransformer):
+    def __init__(self, N):
+        self.inline_variables = set()
+        self.N = N
+
+    def visit_AnnAssign(self, node):
+        # Pattern-matching:
+        # var_name: "VAR_ARGS_ARRAY"
+        if (
+            node.value is None
+            and node.simple == 1
+            and isinstance(node.target, ast.Name)
+            and isinstance(node.annotation, ast.Constant)
+            and node.annotation.value == "VAR_ARGS_ARRAY"
+        ):
+            self.inline_variables.add(node.target.id)
+            return []
+        if node.value is not None:
+            node.value = self.visit(node.value)
+        if node.annotation is not None:
+            node.annotation = self.visit(node.annotation)
+        if node.target is not None:
+            node.target = self.visit(node.target)
+        return node
+
+    def visit_arguments(self, node):
+        # Replace `args` annotated with `VAR_ARGS_ARRAY`
+        new_args = []
+        for arg in node.args:
+            if (
+                arg.annotation is not None
+                and isinstance(arg.annotation, ast.Constant)
+                and arg.annotation.value == "VAR_ARGS_ARRAY"
+            ):
+                self.inline_variables.add(arg.arg)
+                new_args += [ast.arg(f"{arg.arg}{i}") for i in range(self.N)]
+                continue
+            new_args.append(arg)
+        if node.vararg is not None:
+            self.inline_variables.add(node.vararg.arg)
+            new_args += [ast.arg(f"{node.vararg.arg}{i}") for i in range(self.N)]
+            node.vararg = None
+            new_args += node.kwonlyargs
+            node.kwonlyargs = []
+        node.args = new_args
+        return node
+
+    def visit_For(self, node):
+        if (
+            not isinstance(node.iter, ast.Call)
+            or node.iter.func.id != "range"
+            or len(node.iter.args) != 1
+            or not isinstance(node.iter.args[0], ast.Call)
+            or node.iter.args[0].func.id != "len"
+            or len(node.iter.args[0].args) != 1
+            or node.iter.args[0].args[0].id not in self.inline_variables
+        ):
+            node.body = [self.visit(x) for x in node.body]
+            return node
+        # We know we have to modify this loop
+        new_nodes = []
+        for i in range(self.N):
+            unroller = _ForLoopUnroller(
+                target=node.target.id,
+                inline_variables=self.inline_variables,
+                loop_iter=i,
+            )
+            for body in node.body:
+                body = copy.deepcopy(body)
+                new_node = ast.fix_missing_locations(unroller.visit(body))
+                new_node = self.visit(new_node)
+                new_nodes.append(new_node)
+        return new_nodes
+
+
+# Hackfix to get access to get source-code for
+# `exec`-created functions - see https://stackoverflow.com/a/69668999
+_getlines_orig = None
+_FILENAME_TO_SRC: Dict[str, str] = {}
+
+
+def _monkey_patched_getlines(filename, module_globals=None):
+    if filename in _FILENAME_TO_SRC:
+        return _FILENAME_TO_SRC[filename]
+    else:
+        return _getlines_orig(filename, module_globals)  # type: ignore
+
+
+@functools.lru_cache(None)
+def unroll_varargs(kernel, N: int):
+    """
+    Specializes a triton kernel with variable number of inputs
+    to a specific number of inputs `N`.
+    NOTE: Because it's quite costly to call `triton.jit`,
+    we cache the returned value with `lru_cache`
+    """
+    global _FILENAME_TO_SRC, _getlines_orig
+
+    k = triton.JITFunction(kernel.fn)
+    parsed = ast.parse(k.src)
+    nodeVisitor = _VisitorUnrollKernel(N=N)
+    parsed = nodeVisitor.visit(parsed)
+    parsed = ast.fix_missing_locations(parsed)
+
+    # NOTE: `ast.unparse` requires python 3.9+
+    if (sys.version_info.major, sys.version_info.minor) <= (3, 8):
+        raise RuntimeError("Error: This functionality requires python 3.9 or above")
+    new_src = ast.unparse(parsed)  # type: ignore
+
+    # Now we want to `eval` the function, but we need all this
+    # boilerplate code to make sure triton can run `inspect.getsource`
+
+    fn_filename = f"<unroll_varargs-{kernel.fn.__name__}-{N}>"
+
+    # Create function given source
+    code = compile(new_src, fn_filename, "exec")
+
+    _locals: Dict[str, Any] = {}
+    exec(code, kernel.fn.__globals__, _locals)
+    assert len(_locals) == 1, len(_locals)
+    fn = next(iter(_locals.values()))
+    # Patch `getlines` only the first time
+    if not _FILENAME_TO_SRC:
+        _getlines_orig = linecache.getlines
+        linecache.getlines = _monkey_patched_getlines
+    _FILENAME_TO_SRC[fn_filename] = new_src
+
+    jitted_fn = triton.jit(fn)
+    jitted_fn.src = new_src
+    return jitted_fn
+
+
+# Note: just import this to make mypy happy
+# when annotating variables with `VAR_ARGS_ARRAY`
+VAR_ARGS_ARRAY = List[Any]
diff --git a/evalkit_tf437/lib/python3.10/site-packages/xformers/version.py b/evalkit_tf437/lib/python3.10/site-packages/xformers/version.py
new file mode 100644
index 0000000000000000000000000000000000000000..90a804ba3c8e2c7d2c1980d9c24d49446d5541cf
--- /dev/null
+++ b/evalkit_tf437/lib/python3.10/site-packages/xformers/version.py
@@ -0,0 +1,2 @@
+# noqa: C801
+__version__ = "0.0.24"