DeRhamComputation/as_covers/as_form_class.sage

class as_form:
    def __init__(self, C, g):
        self.curve = C
        n = C.height
        F = C.base_ring
        RxyzQ, Rxyz, x, y, z = C.fct_field
        self.form = RxyzQ(g)
        
    def __repr__(self):
        return "(" + str(self.form)+") * dx"
    
    def __eq__(self, other):
        return self.expansion_at_infty() == other.expansion_at_infty()
    
    def expansion_at_infty(self, place = 0):
        C = self.curve
        delta = C.nb_of_pts_at_infty
        F = C.base_ring
        x_series = C.x_series[place]
        y_series = C.y_series[place]
        z_series = C.z_series[place]
        dx_series = C.dx_series[place]
        n = C.height
        RxyzQ, Rxyz, x, y, z = C.fct_field
        prec = C.prec
        Rt.<t> = LaurentSeriesRing(F, default_prec=prec)
        g = self.form
        sub_list = {x : x_series, y : y_series} | {z[j] : z_series[j] for j in range(n)}
        return g.substitute(sub_list)*dx_series
    
    def expansion(self, pt = 0):
        '''Same code as expansion_at_infty.'''
        C = self.curve
        F = C.base_ring
        x_series = C.x_series[pt]
        y_series = C.y_series[pt]
        z_series = C.z_series[pt]
        dx_series = C.dx_series[pt]
        n = C.height
        RxyzQ, Rxyz, x, y, z = C.fct_field
        prec = C.prec
        Rt.<t> = LaurentSeriesRing(F, default_prec=prec)
        g = self.form
        sub_list = {x : x_series, y : y_series} | {z[j] : z_series[j] for j in range(n)}
        return g.substitute(sub_list)*dx_series
    
    def __add__(self, other):
        C = self.curve
        g1 = self.form
        g2 = other.form
        return as_form(C, g1 + g2)
    
    def __sub__(self, other):
        C = self.curve
        g1 = self.form
        g2 = other.form
        return as_form(C, g1 - g2)
    
    def __neg__(self):
        C = self.curve
        g = self.form
        return as_form(C, -g)
    
    def __rmul__(self, constant):
        C = self.curve
        omega = self.form
        return as_form(C, constant*omega)
    
    def reduce(self):
        RxyzQ, Rxyz, x, y, z = self.curve.fct_field
        m = self.curve.quotient.exponent
        aux = as_reduction(self.curve, RxyzQ(y^m*self.form))
        return as_form(self.curve, aux/y^m)

    def group_action(self, elt):
        C = self.curve
        n = C.height
        aux = as_function(C, self.form)
        aux = aux.group_action(elt)
        return as_form(C, aux.function)

    def coordinates(self, basis = 0):
        """Find coordinates of the given holomorphic form self in terms of the basis forms in a list holo."""
        self = self.reduce()
        print(self)
        C = self.curve
        if basis == 0:
            basis = C.holomorphic_differentials_basis()
        RxyzQ, Rxyz, x, y, z = C.fct_field
        # We need to have only polynomials to use monomial_coefficients in linear_representation_polynomials,
        # and sometimes basis elements have denominators. Thus we multiply by them.
        denom = LCM([denominator(omega.form) for omega in basis])
        basis = [denom*omega for omega in basis]
        self_with_no_denominator = denom*self
        print(denom, basis, self_with_no_denominator)
        return linear_representation_polynomials(Rxyz(self_with_no_denominator.form), [Rxyz(omega.form) for omega in basis])

    def trace(self, super=True):
        C = self.curve
        C_super = C.quotient
        n = C.height
        F = C.base_ring
        RxyzQ, Rxyz, x, y, z = C.fct_field
        result = as_form(C, 0)
        G = C.group.elts
        for a in G:
            result += self.group_action(a)
        result = result.form
        Rxy.<x, y> = PolynomialRing(F, 2)
        Qxy = FractionField(Rxy)
        result = as_reduction(C, result)
        if super:
            return superelliptic_form(C_super, Qxy(result))
        return as_form(C, Qxy(result))

    def residue(self, place=0):
        return self.expansion_at_infty(place = place).residue()

    def valuation(self, place=0):
        return self.expansion_at_infty(place = place).valuation()

    def serre_duality_pairing(self, fct):
        AS = self.curve
        return sum((fct*self).residue(place = _) for _ in range(AS.nb_of_pts_at_infty))

    def cartier(self):
        C = self.curve
        F = C.base_ring
        n = C.height
        ff = C.functions
        p = F.characteristic()
        C_super = C.quotient
        (RxyzQ, Rxyz, x, y, z) = C.fct_field
        fct = self.form
        Rxy.<x, y> = PolynomialRing(F, 2)
        RxyQ = FractionField(Rxy)
        x, y = Rxyz.gens()[0], Rxyz.gens()[1]
        z = Rxyz.gens()[2:]
        num = Rxyz(fct.numerator())
        den = Rxyz(fct.denominator())
        result = RxyzQ(0)
        #return (num, den, z, fct)
        if den in Rxy:
            sub_list = {x : x, y : y} | {z[j] : (z[j]^p - RxyzQ(ff[j].function)) for j in range(n)}
            num = RxyzQ(num.substitute(sub_list))
            den1 = Rxyz(num.denominator())
            num = Rxyz(num*den1^p)
            for monomial in Rxyz(num).monomials():
                degrees = [monomial.degree(z[i]) for i in range(n)]
                product_of_z = prod(z[i]^(degrees[i]) for i in range(n))
                monomial_divided_by_z = monomial/product_of_z
                product_of_z_no_p = prod(z[i]^(degrees[i]/p) for i in range(n))
                aux_form = superelliptic_form(C_super, RxyQ(monomial_divided_by_z/den))
                aux_form = aux_form.cartier()
                result += product_of_z_no_p * Rxyz(num).monomial_coefficient(monomial) * aux_form.form/den1
            return as_form(C, result)
        raise ValueError("Please present first your form as sum z^i omega_i, where omega_i are forms on quotient curve.")
        
    def is_regular_on_U0(self):
        AS = self.curve
        C = AS.quotient
        m = C.exponent
        RxyzQ, Rxyz, x, y, z = AS.fct_field
        if y^(m-1)*self.form in Rxyz:
            return True
        return False

def are_forms_linearly_dependent(set_of_forms):
    from sage.rings.polynomial.toy_variety import is_linearly_dependent
    C = set_of_forms[0].curve
    F = C.base_ring
    n = C.height
    RxyzQ, Rxyz, x, y, z = C.fct_field
    denominators = prod(denominator(omega.form) for omega in set_of_forms)
    return is_linearly_dependent([Rxyz(denominators*omega.form) for omega in set_of_forms])

def only_log_forms(C_AS):
    list1 = AS.at_most_poles_forms(0)
    list2 = AS.at_most_poles_forms(1)
    result = []
    for a in list2:
        if not(are_forms_linearly_dependent(list1 + result + [a])):
            result += [a]
    return result