From 780c1f03f2a387c7b1ccf9e6dfaf5744e13bdc5f Mon Sep 17 00:00:00 2001 From: jgarnek Date: Sat, 10 Feb 2024 12:41:04 +0000 Subject: [PATCH] as transform for unramified points fixed --- as_covers/as_form_class.sage | 43 ----------- as_covers/as_transform.sage | 45 +++++++++++ drafty/draft2.sage | 13 ++-- heisenberg_covers/heisenberg_covers.sage | 79 +++++++++++++++++++- heisenberg_covers/heisenberg_form_class.sage | 42 ----------- init.sage | 4 + quaternion_covers/quaternion_form_class.sage | 43 ----------- 7 files changed, 131 insertions(+), 138 deletions(-) create mode 100644 as_covers/as_transform.sage diff --git a/as_covers/as_form_class.sage b/as_covers/as_form_class.sage index fab6a99..bcf2962 100644 --- a/as_covers/as_form_class.sage +++ b/as_covers/as_form_class.sage @@ -175,49 +175,6 @@ class as_form: if y^(m-1)*self.form in Rxyz: return True return False - -def artin_schreier_transform(power_series, prec = 10): - """Given a power_series, find correction such that power_series - (correction)^p +correction has valuation - -jump non divisible by p. Also, express t (the variable) in terms of the uniformizer at infty on the curve - z^p - z = power_series, where z = 1/t_new^(jump) and express z in terms of the new uniformizer.""" - correction = 0 - F = power_series.parent().base() - p = F.characteristic() - Rt. = LaurentSeriesRing(F, default_prec=prec) - RtQ = FractionField(Rt) - power_series = RtQ(power_series) - if power_series.valuation() == +Infinity: - raise ValueError("Precision is too low.") - if power_series.valuation() >= 0: - # THIS IS WRONG - THERE ARE SEVERAL PLACES OVER THIS PLACE, AND IT DEPENDS - aux = t^p - t - z = new_reverse(aux, prec = prec) - z = z(t = power_series) - return(0, 0, t, z) - - while(power_series.valuation() % p == 0 and power_series.valuation() < 0): - M = -power_series.valuation()/p - coeff = power_series.list()[0] #wspolczynnik a_(-p) w f_AS - correction += coeff.nth_root(p)*t^(-M) - power_series = power_series - (coeff*t^(-p*M) - coeff.nth_root(p)*t^(-M)) - jump = max(-(power_series.valuation()), 0) - try: - if jump != 0: - T = nth_root2((power_series)^(-1), jump, prec=prec) #T is defined by power_series = 1/T^m - except: - print("no ", str(jump), "-th root; divide by", power_series.list()[0]) - return (jump, power_series.list()[0]) - if jump != 0: - T_rev = new_reverse(T, prec = prec) - t_old = T_rev(t^p/nth_root2(1 - t^((p-1)*jump), jump, prec=prec)) - z = 1/t^(jump) + Rt(correction)(t = t_old) - return(jump, correction, t_old, z) - if jump == 0: - aux = t^p - t - z = new_reverse(aux, prec = prec) - z = z(t = power_series) - return(0, correction, t, z) - def are_forms_linearly_dependent(set_of_forms): from sage.rings.polynomial.toy_variety import is_linearly_dependent diff --git a/as_covers/as_transform.sage b/as_covers/as_transform.sage new file mode 100644 index 0000000..6aec5d9 --- /dev/null +++ b/as_covers/as_transform.sage @@ -0,0 +1,45 @@ +def artin_schreier_transform(power_series, prec = 10): + """Given a power_series, find correction such that power_series - (correction)^p +correction has valuation + -jump non divisible by p. Also, express t (the variable) in terms of the uniformizer at infty on the curve + z^p - z = power_series, where z = 1/t_new^(jump) and express z in terms of the new uniformizer.""" + print('as transform for ', power_series) + correction = 0 + F = power_series.parent().base() + p = F.characteristic() + Rt. = LaurentSeriesRing(F, default_prec=prec) + RtQ = FractionField(Rt) + power_series = RtQ(power_series) + if power_series.valuation() == +Infinity: + raise ValueError("Precision is too low.") + if power_series.valuation() >= 0: + # THIS IS WRONG - THERE ARE SEVERAL PLACES OVER THIS PLACE, AND IT DEPENDS + aux = t^p - t + z = new_reverse(aux, prec = prec) + z = z(t = power_series) + print("a") + return(0, 0, t, z) + + while(power_series.valuation() % p == 0 and power_series.valuation() < 0): + M = -power_series.valuation()/p + coeff = power_series.list()[0] #wspolczynnik a_(-p) w f_AS + correction += coeff.nth_root(p)*t^(-M) + power_series = power_series - (coeff*t^(-p*M) - coeff.nth_root(p)*t^(-M)) + jump = max(-(power_series.valuation()), 0) + try: + if jump != 0: + T = nth_root2((power_series)^(-1), jump, prec=prec) #T is defined by power_series = 1/T^m + except: + print("no ", str(jump), "-th root; divide by", power_series.list()[0]) + return (jump, power_series.list()[0]) + if jump != 0: + T_rev = new_reverse(T, prec = prec) + t_old = T_rev(t^p/nth_root2(1 - t^((p-1)*jump), jump, prec=prec)) + z = 1/t^(jump) + Rt(correction)(t = t_old) + return(jump, correction, t_old, z) + if jump == 0: + aux = t^p - t + z = new_reverse(aux, prec = prec) + z = z(t = power_series) + z = z + correction + print('corr', correction, 'ps', power_series, 'z', z) + return(0, correction, t, z) \ No newline at end of file diff --git a/drafty/draft2.sage b/drafty/draft2.sage index 3c88ca9..e3f61fa 100644 --- a/drafty/draft2.sage +++ b/drafty/draft2.sage @@ -1,12 +1,13 @@ p = 3 -F = GF(3^2, 'a') +F = GF(3) +#F. = GF(3^2) Rx. = PolynomialRing(F) P1 = superelliptic(x^2 + 1, 2) fct1 = (P1.x)^2 -fct2 = fct1 + (P1.x)/(P1.y - P1.x) -fct3 = (P1.x)^4 -C = heisenberg_cover(P1, [1/2*fct1, fct2, fct3], prec=500) -print(C) -B = C.holomorphic_differentials_basis() +fct2 = (fct1 + P1.one/(P1.y - P1.x)) +fct3 = 0*P1.x +C = heisenberg_cover(P1, [fct1, fct2, fct3], prec=200) +print(C, '\n', C.genus(), '\n', C.jumps) +#B = C.holomorphic_differentials_basis() #print("Computed basis") #a1, b1, c1 = heisenberg_group_action_matrices_holo(C, basis = B) \ No newline at end of file diff --git a/heisenberg_covers/heisenberg_covers.sage b/heisenberg_covers/heisenberg_covers.sage index 9782212..ef58250 100644 --- a/heisenberg_covers/heisenberg_covers.sage +++ b/heisenberg_covers/heisenberg_covers.sage @@ -194,9 +194,11 @@ class heisenberg_cover: forms = holomorphic_combinations_fcts(S, pole_order) - for i in range(1, delta): - forms = [(omega, omega.expansion_at_infty(place = i)) for omega in forms] - forms = holomorphic_combinations_fcts(forms, pole_order) + for i in range(delta): + for g in [(0, i, 0) for i in range(p)]: + if i!=0 or g != (0, 0, 0): + forms = [(omega, omega.expansion_at_infty(place = i)) for omega in forms] + forms = holomorphic_combinations_fcts(forms, pole_order) return forms @@ -217,7 +219,7 @@ class heisenberg_cover: return result def at_most_poles_forms(self, pole_order, threshold = 8): - """Find forms with pole order in all the points at infty equat at most to pole_order. Threshold gives a bound on powers of x in the form. + """Find forms with pole order in all the points at infty equal at most to pole_order. Threshold gives a bound on powers of x in the form. If you suspect that you haven't found all the functions, you may increase it.""" from itertools import product x_series = self.x_series @@ -405,6 +407,75 @@ class heisenberg_cover: result += [heisenberg_cech(self, omega, f)] return result + def stabilizer(self, place = 0): + result = [] + for g in self.group: + flag = 1 + for i in range(self.height): + if self.z[i].valuation(place = place) > 0: + fct = self.z[i] + elif self.z[i].valuation(place = place) < 0: + fct = self.one/self.z[i] + if fct.group_action(g).valuation(place = place) <= 0: + flag = 0 + if flag: + result += [g] + return result + + def stabilizer_coset_reps(self, place = 0): + result = [(0, 0, 0)] + p = self.characteristic + H = self.stabilizer(place = place) + for g in self.group: + flag = 1 + for v in result: + if heisenberg_mult(g, heisenberg_inv(v, p), p) in H: + flag = 0 + if flag: + result += [g] + return result + +############## +def at_most_poles2(self, pole_orders, threshold = 8): + """ Find fcts with pole order in infty's at most pole_order from the given dictionary. The keys of the dictionary are pairs (place_at_infty, group element). The items are the poles orders at those places. + Threshold gives a bound on powers of x in the function. If you suspect that you haven't found all the functions, you may increase it.""" + from itertools import product + x_series = self.x_series + y_series = self.y_series + z_series = self.z_series + delta = self.nb_of_pts_at_infty + p = self.characteristic + n = self.height + prec = self.prec + C = self.quotient + F = self.base_ring + m = C.exponent + r = C.polynomial.degree() + RxyzQ, Rxyz, x, y, z = self.fct_field + F = C.base_ring + Rt. = LaurentSeriesRing(F, default_prec=prec) + #Tworzymy zbiór S form z^i x^j y^k dx/y o waluacji >= waluacja z^(p-1)*dx/y + S = [] + RQxyz = FractionField(Rxyz) + pr = [list(GF(p)) for _ in range(n)] + for i in range(0, threshold*r): + for j in range(0, m): + for k in product(*pr): + eta = heisenberg_function(self, x^i * prod(z[i1]^(k[i1]) for i1 in range(n))*y^j) + eta_exp = eta.expansion_at_infty() + S += [(eta, eta_exp)] + + forms = holomorphic_combinations_fcts(S, pole_orders[(0, (0, 0, 0))]) + + for i in range(delta): + for g in self.stabilizer_coset_reps(place = i): + if i!=0 or g != (0, 0, 0): + forms = [(omega, omega.expansion_at_infty(place = i)) for omega in forms] + forms = holomorphic_combinations_fcts(forms, pole_orders[(i, g)]) + return forms +############## + + def heisenberg_holomorphic_combinations(S): """Given a list S of pairs (form, corresponding Laurent series at some pt), find their combinations holomorphic at that pt.""" C_AS = S[0][0].curve diff --git a/heisenberg_covers/heisenberg_form_class.sage b/heisenberg_covers/heisenberg_form_class.sage index 9d2bb12..8448b36 100644 --- a/heisenberg_covers/heisenberg_form_class.sage +++ b/heisenberg_covers/heisenberg_form_class.sage @@ -200,48 +200,6 @@ class heisenberg_form: if y^(m-1)*self.form in Rxyz: return True return False - -def artin_schreier_transform(power_series, prec = 10): - """Given a power_series, find correction such that power_series - (correction)^p +correction has valuation - -jump non divisible by p. Also, express t (the variable) in terms of the uniformizer at infty on the curve - z^p - z = power_series, where z = 1/t_new^(jump) and express z in terms of the new uniformizer.""" - correction = 0 - F = power_series.parent().base() - p = F.characteristic() - Rt. = LaurentSeriesRing(F, default_prec=prec) - RtQ = FractionField(Rt) - power_series = RtQ(power_series) - if power_series.valuation() == +Infinity: - raise ValueError("Precision is too low.") - if power_series.valuation() >= 0: - # THIS IS WRONG - THERE ARE SEVERAL PLACES OVER THIS PLACE, AND IT DEPENDS - aux = t^p - t - z = new_reverse(aux, prec = prec) - z = z(t = power_series) - return(0, 0, t, z) - - while(power_series.valuation() % p == 0 and power_series.valuation() < 0): - M = -power_series.valuation()/p - coeff = power_series.list()[0] #wspolczynnik a_(-p) w f_AS - correction += coeff.nth_root(p)*t^(-M) - power_series = power_series - (coeff*t^(-p*M) - coeff.nth_root(p)*t^(-M)) - jump = max(-(power_series.valuation()), 0) - try: - if jump != 0: - T = nth_root2((power_series)^(-1), jump, prec=prec) #T is defined by power_series = 1/T^m - except: - print("no ", str(jump), "-th root; divide by", power_series.list()[0]) - return (jump, power_series.list()[0]) - if jump != 0: - T_rev = new_reverse(T, prec = prec) - t_old = T_rev(t^p/nth_root2(1 - t^((p-1)*jump), jump, prec=prec)) - z = 1/t^(jump) + Rt(correction)(t = t_old) - return(jump, correction, t_old, z) - if jump == 0: - aux = t^p - t - z = new_reverse(aux, prec = prec) - z = z(t = power_series) - return(0, correction, t, z) def are_forms_linearly_dependent(set_of_forms): from sage.rings.polynomial.toy_variety import is_linearly_dependent diff --git a/init.sage b/init.sage index 0c84f76..7858480 100644 --- a/init.sage +++ b/init.sage @@ -3,6 +3,7 @@ load('superelliptic/superelliptic_function_class.sage') load('superelliptic/superelliptic_form_class.sage') load('superelliptic/superelliptic_cech_class.sage') load('superelliptic/frobenius_kernel.sage') +load('as_covers/as_transform.sage') load('as_covers/as_cover_class.sage') load('as_covers/as_function_class.sage') load('as_covers/as_form_class.sage') @@ -43,6 +44,9 @@ load('heisenberg_covers/heisenberg_form_class.sage') load('heisenberg_covers/heisenberg_polyforms.sage') load('heisenberg_covers/heisenberg_reduction.sage') load('heisenberg_covers/heisenberg_group_action_matrices.sage') +load('heisenberg_covers/dual_element.sage') +load('heisenberg_covers/ith_magical_component.sage') +load('heisenberg_covers/heisenberg_group.sage') ############## ############## def init(lista, tests = False, init=True): diff --git a/quaternion_covers/quaternion_form_class.sage b/quaternion_covers/quaternion_form_class.sage index 8881442..1ccccca 100644 --- a/quaternion_covers/quaternion_form_class.sage +++ b/quaternion_covers/quaternion_form_class.sage @@ -194,49 +194,6 @@ class quaternion_form: if y^(m-1)*self.form in Rxyz: return True return False - -def artin_schreier_transform(power_series, prec = 10): - """Given a power_series, find correction such that power_series - (correction)^p +correction has valuation - -jump non divisible by p. Also, express t (the variable) in terms of the uniformizer at infty on the curve - z^p - z = power_series, where z = 1/t_new^(jump) and express z in terms of the new uniformizer.""" - correction = 0 - F = power_series.parent().base() - p = F.characteristic() - Rt. = LaurentSeriesRing(F, default_prec=prec) - RtQ = FractionField(Rt) - power_series = RtQ(power_series) - if power_series.valuation() == +Infinity: - raise ValueError("Precision is too low.") - if power_series.valuation() >= 0: - # THIS IS WRONG - THERE ARE SEVERAL PLACES OVER THIS PLACE, AND IT DEPENDS - aux = t^p - t - z = new_reverse(aux, prec = prec) - z = z(t = power_series) - return(0, 0, t, z) - - while(power_series.valuation() % p == 0 and power_series.valuation() < 0): - M = -power_series.valuation()/p - coeff = power_series.list()[0] #wspolczynnik a_(-p) w f_AS - correction += coeff.nth_root(p)*t^(-M) - power_series = power_series - (coeff*t^(-p*M) - coeff.nth_root(p)*t^(-M)) - jump = max(-(power_series.valuation()), 0) - try: - if jump != 0: - T = nth_root2((power_series)^(-1), jump, prec=prec) #T is defined by power_series = 1/T^m - except: - print("no ", str(jump), "-th root; divide by", power_series.list()[0]) - return (jump, power_series.list()[0]) - if jump != 0: - T_rev = new_reverse(T, prec = prec) - t_old = T_rev(t^p/nth_root2(1 - t^((p-1)*jump), jump, prec=prec)) - z = 1/t^(jump) + Rt(correction)(t = t_old) - return(jump, correction, t_old, z) - if jump == 0: - aux = t^p - t - z = new_reverse(aux, prec = prec) - z = z(t = power_series) - return(0, correction, t, z) - def are_forms_linearly_dependent(set_of_forms): from sage.rings.polynomial.toy_variety import is_linearly_dependent