From 5e738d441ddc7e820f79beb69d239060a32cd038 Mon Sep 17 00:00:00 2001 From: jgarnek Date: Wed, 5 Apr 2023 09:25:25 +0000 Subject: [PATCH] usuniete zbedne komunikaty --- sage/.run.term-0.term | 605 ++++++++++++++++++++++- sage/superelliptic_drw/regular_form.sage | 7 - 2 files changed, 604 insertions(+), 8 deletions(-) diff --git a/sage/.run.term-0.term b/sage/.run.term-0.term index 1510ec7..694a2f8 100644 --- a/sage/.run.term-0.term +++ b/sage/.run.term-0.term @@ -34265,4 +34265,607 @@ A.diffn().is_regular_on_U0() True [0] d[x] + [0] d[y] + V((2*a*x^21 + 2*x^15 + (a + 1)*x^13 + 2*a*x^12) dy) + dV(0) [?2004h[?25l[?7lsage: [?7h[?12l[?25h[?25l[?7l[?7h[?12l[?25h[?25l[?7lload('init.sage')[?7h[?12l[?25h[?25l[?7lf[1][?7h[?12l[?25h[?25l[?7l2[?7h[?12l[?25h[?25l[?7l[?7h[?12l[?25h[?25l[?7lF.cardinality()[?7h[?12l[?25h[?25l[?7lanth_root(p)[?7h[?12l[?25h[?25l[?7lomega.carier()[?7h[?12l[?25h[?25l[?7l = a*omega[?7h[?12l[?25h[?25l[?7l.cartier()[?7h[?12l[?25h[?25l[?7l = (C.x)^(-1)*C.dx[?7h[?12l[?25h[?25l[?7lload('init.sage')[?7h[?12l[?25h[?25l[?7lmult_by_p(fct.diffn()) == (fct^p).verschiebung().diffn()[?7h[?12l[?25h[?25l[?7lfct = C.y[?7h[?12l[?25h[?25l[?7lC =superelliptic(x^3 - x, m)[?7h[?12l[?25h[?25l[?7lfct= C.y[?7h[?12l[?25h[?25l[?7lsage: fct = C.y [?7h[?12l[?25h[?2004l[?2004h[?25l[?7lsage: [?7h[?12l[?25h[?25l[?7l[?7h[?12l[?25h[?25l[?7l[?7h[?12l[?25h[?25l[?7lfct = C.y[?7h[?12l[?25h[?25l[?7lload('init.sage')[?7h[?12l[?25h[?25l[?7lf[1][?7h[?12l[?25h[?25l[?7lload('init.sage')[?7h[?12l[?25h[?25l[?7lfct = C.y[?7h[?12l[?25h[?25l[?7l[?7h[?12l[?25h[?25l[?7l[?7h[?12l[?25h[?25l[?7l[?7h[?12l[?25h[?25l[?7l[?7h[?12l[?25h[?25l[?7l[?7h[?12l[?25h[?25l[?7lmult_by_p(fct.diffn()) == (fct^p).verschiebung().diffn()[?7h[?12l[?25h[?25l[?7lsage: mult_by_p(fct.diffn()) == (fct^p).verschiebung().diffn() -[?7h[?12l[?25h[?2004l \ No newline at end of file +[?7h[?12l[?25h[?2004l[?7hTrue +[?2004h[?25l[?7lsage: [?7h[?12l[?25h[?25l[?7l[?7h[?12l[?25h[?25l[?7lq[?7h[?12l[?25h[?25l[?7lu[?7h[?12l[?25h[?25l[?7li[?7h[?12l[?25h[?25l[?7lt[?7h[?12l[?25h[?25l[?7l([?7h[?12l[?25h[?25l[?7l()[?7h[?12l[?25h[?25l[?7lsage: quit() +[?7h[?12l[?25h[?2004l]0;~/Research/2021 De Rham/DeRhamComputation/sage~/Research/2021 De Rham/DeRhamComputation/sage$ cd .. +]0;~/Research/2021 De Rham/DeRhamComputation~/Research/2021 De Rham/DeRhamComputation$ git add -u +]0;~/Research/2021 De Rham/DeRhamComputation~/Research/2021 De Rham/DeRhamComputation$ git commit -m "naprawioney brak (1/p)-liniowosci cartiera)" +[master 1f66cae] naprawiony brak (1/p)-liniowosci cartiera + 6 files changed, 2428 insertions(+), 13 deletions(-) +]0;~/Research/2021 De Rham/DeRhamComputation~/Research/2021 De Rham/DeRhamComputation$ git push +Username for 'https://git.wmi.amu.edu.pl': jgarnek +Password for 'https://jgarnek@git.wmi.amu.edu.pl': +Enumerating objects: 23, done. +Counting objects: 4% (1/23) Counting objects: 8% (2/23) Counting objects: 13% (3/23) Counting objects: 17% (4/23) Counting objects: 21% (5/23) Counting objects: 26% (6/23) Counting objects: 30% (7/23) Counting objects: 34% (8/23) Counting objects: 39% (9/23) Counting objects: 43% (10/23) Counting objects: 47% (11/23) Counting objects: 52% (12/23) Counting objects: 56% (13/23) Counting objects: 60% (14/23) Counting objects: 65% (15/23) Counting objects: 69% (16/23) Counting objects: 73% (17/23) Counting objects: 78% (18/23) Counting objects: 82% (19/23) Counting objects: 86% (20/23) Counting objects: 91% (21/23) Counting objects: 95% (22/23) Counting objects: 100% (23/23) Counting objects: 100% (23/23), done. +Delta compression using up to 4 threads +Compressing objects: 8% (1/12) Compressing objects: 16% (2/12) Compressing objects: 25% (3/12) Compressing objects: 33% (4/12) Compressing objects: 41% (5/12) Compressing objects: 50% (6/12) Compressing objects: 58% (7/12) Compressing objects: 66% (8/12) Compressing objects: 75% (9/12) Compressing objects: 83% (10/12) Compressing objects: 91% (11/12) Compressing objects: 100% (12/12) Compressing objects: 100% (12/12), done. +Writing objects: 8% (1/12) Writing objects: 16% (2/12) Writing objects: 25% (3/12) Writing objects: 33% (4/12) Writing objects: 41% (5/12) Writing objects: 50% (6/12) Writing objects: 58% (7/12) Writing objects: 66% (8/12) Writing objects: 75% (9/12) Writing objects: 83% (10/12) Writing objects: 91% (11/12) Writing objects: 100% (12/12) Writing objects: 100% (12/12), 14.29 KiB | 232.00 KiB/s, done. +Total 12 (delta 11), reused 0 (delta 0) +remote: . Processing 1 references +remote: Processed 1 references in total +To https://git.wmi.amu.edu.pl/jgarnek/DeRhamComputation.git + a5c2ce2..1f66cae master -> master +]0;~/Research/2021 De Rham/DeRhamComputation~/Research/2021 De Rham/DeRhamComputation$ scd sage +]0;~/Research/2021 De Rham/DeRhamComputation/sage~/Research/2021 De Rham/DeRhamComputation/sage$ sage +┌────────────────────────────────────────────────────────────────────┐ +│ SageMath version 9.8, Release Date: 2023-02-11 │ +│ Create a "Sage Worksheet" file for the notebook interface. │ +│ Enhanced for CoCalc. │ +│ Using Python 3.11.1. Type "help()" for help. │ +└────────────────────────────────────────────────────────────────────┘ +]0;IPython: DeRhamComputation/sage[?2004h[?1l[?25l[?7lsage: [?7h[?12l[?25h[?25l[?7l[?7h[?12l[?25h[?25l[?7lload('init.sage')[?7h[?12l[?25h[?25l[?7lo[?7h[?12l[?25h[?25l[?7lad('init.sage')[?7h[?12l[?25h[?25l[?7lsage: load('init.sage') +[?7h[?12l[?25h[?2004lTrue +[0] d[x] + [0] d[y] + V((2*a*x^9 + 2*x^3 + (a + 1)*x + 2*a) dy) + dV(0) +True +[0] d[x] + [0] d[y] + V((2*a*x^12 + 2*x^6 + (a + 1)*x^4 + 2*a*x^3) dy) + dV(0) +True +[0] d[x] + [0] d[y] + V((2*a*x^15 + 2*x^9 + (a + 1)*x^7 + 2*a*x^6) dy) + dV(0) +True +^C--------------------------------------------------------------------------- +KeyboardInterrupt Traceback (most recent call last) +File :59, in __mul__(self, other) + +File :260, in reduction(C, g) + +File /ext/sage/9.8/src/sage/arith/misc.py:2021, in xgcd(a, b) + 2020 try: +-> 2021 return a.xgcd(b) + 2022 except AttributeError: + +File /ext/sage/9.8/src/sage/structure/element.pyx:4497, in sage.structure.element.coerce_binop.new_method() + 4496 if have_same_parent(self, other): +-> 4497 return method(self, other, *args, **kwargs) + 4498 else: + +File /ext/sage/9.8/src/sage/rings/polynomial/polynomial_element.pyx:8931, in sage.rings.polynomial.polynomial_element.Polynomial.xgcd() + 8930 if hasattr(self.base_ring(), '_xgcd_univariate_polynomial'): +-> 8931 return self.base_ring()._xgcd_univariate_polynomial(self, other) + 8932 else: + +File /ext/sage/9.8/src/sage/categories/fields.py:373, in Fields.ParentMethods._xgcd_univariate_polynomial(self, a, b) + 372 while v3: +--> 373 q, r = d.quo_rem(v3) + 374 (u, d, v1, v3) = (v1, v3, u - v1*q, r) + +File /ext/sage/9.8/src/sage/structure/element.pyx:4497, in sage.structure.element.coerce_binop.new_method() + 4496 if have_same_parent(self, other): +-> 4497 return method(self, other, *args, **kwargs) + 4498 else: + +File /ext/sage/9.8/src/sage/rings/polynomial/polynomial_element.pyx:11734, in sage.rings.polynomial.polynomial_element.Polynomial_generic_dense.quo_rem() + 11733 for k from m-n >= k >= 0: +> 11734 q = x[n+k-1] * inv + 11735 for j from n+k-2 >= j >= k: + +File /ext/sage/9.8/src/sage/structure/element.pyx:1513, in sage.structure.element.Element.__mul__() + 1512 if HAVE_SAME_PARENT(cl): +-> 1513 return (left)._mul_(right) + 1514 if BOTH_ARE_ELEMENT(cl): + +File /ext/sage/9.8/src/sage/rings/fraction_field_element.pyx:670, in sage.rings.fraction_field_element.FractionFieldElement._mul_() + 669 d2 = snum.gcd(rden) +--> 670 if not d1.is_unit(): + 671 rnum = rnum // d1 + +File /ext/sage/9.8/src/sage/rings/polynomial/polynomial_element.pyx:5544, in sage.rings.polynomial.polynomial_element.Polynomial.is_unit() + 5543 return self._parent._base.zero().is_unit() +-> 5544 return self.get_unsafe(0).is_unit() + 5545 + +File /ext/sage/9.8/src/sage/rings/polynomial/polynomial_zz_pex.pyx:180, in sage.rings.polynomial.polynomial_zz_pex.Polynomial_ZZ_pEX.get_unsafe() + 179 cdef ZZ_pE_c c_pE = ZZ_pEX_coeff(self.x, i) +--> 180 return self._parent._base(ZZ_pE_c_to_list(c_pE)) + 181 + +File /ext/sage/9.8/src/sage/structure/parent.pyx:896, in sage.structure.parent.Parent.__call__() + 895 if no_extra_args: +--> 896 return mor._call_(x) + 897 else: + +File /ext/sage/9.8/src/sage/structure/coerce_maps.pyx:156, in sage.structure.coerce_maps.DefaultConvertMap_unique._call_() + 155 try: +--> 156 return C._element_constructor(x) + 157 except Exception: + +File /ext/sage/9.8/src/sage/rings/finite_rings/finite_field_givaro.py:230, in FiniteField_givaro._element_constructor_(self, e) + 228 return self._cache.random_element() +--> 230 def _element_constructor_(self, e): + 231  """ + 232  Coerces several data types to ``self``. + 233 + (...) + 369  2*a4^3 + 2*a4^2 + 1 + 370  """ + +File src/cysignals/signals.pyx:310, in cysignals.signals.python_check_interrupt() + +KeyboardInterrupt: + +During handling of the above exception, another exception occurred: + +AttributeError Traceback (most recent call last) +Cell In [1], line 1 +----> 1 load('init.sage') + +File /ext/sage/9.8/src/sage/misc/persist.pyx:175, in sage.misc.persist.load() + 173 + 174 if sage.repl.load.is_loadable_filename(filename): +--> 175 sage.repl.load.load(filename, globals()) + 176 return + 177 + +File /ext/sage/9.8/src/sage/repl/load.py:272, in load(filename, globals, attach) + 270 add_attached_file(fpath) + 271 with open(fpath) as f: +--> 272 exec(preparse_file(f.read()) + "\n", globals) + 273 elif ext == '.spyx' or ext == '.pyx': + 274 if attach: + +File :32 + +File /ext/sage/9.8/src/sage/misc/persist.pyx:175, in sage.misc.persist.load() + 173 + 174 if sage.repl.load.is_loadable_filename(filename): +--> 175 sage.repl.load.load(filename, globals()) + 176 return + 177 + +File /ext/sage/9.8/src/sage/repl/load.py:272, in load(filename, globals, attach) + 270 add_attached_file(fpath) + 271 with open(fpath) as f: +--> 272 exec(preparse_file(f.read()) + "\n", globals) + 273 elif ext == '.spyx' or ext == '.pyx': + 274 if attach: + +File :30 + +File :82, in regular_drw_form(omega) + +File :99, in diffn(self, dy_w) + +File :73, in diffn(self, dy_w) + +File :177, in dy_w(C) + +File :149, in auxilliary_derivative(P) + +File :55, in __rmul__(self, other) + +File /ext/sage/9.8/src/sage/rings/integer.pyx:1961, in sage.rings.integer.Integer.__mul__() + 1959 return y + 1960 +-> 1961 return coercion_model.bin_op(left, right, operator.mul) + 1962 + 1963 cpdef _mul_(self, right): + +File /ext/sage/9.8/src/sage/structure/coerce.pyx:1242, in sage.structure.coerce.CoercionModel.bin_op() + 1240 mul_method = getattr(y, '__r%s__'%op_name, None) + 1241 if mul_method is not None: +-> 1242 res = mul_method(x) + 1243 if res is not None and res is not NotImplemented: + 1244 return res + +File :55, in __rmul__(self, other) + +File /ext/sage/9.8/src/sage/rings/integer.pyx:1961, in sage.rings.integer.Integer.__mul__() + 1959 return y + 1960 +-> 1961 return coercion_model.bin_op(left, right, operator.mul) + 1962 + 1963 cpdef _mul_(self, right): + +File /ext/sage/9.8/src/sage/structure/coerce.pyx:1242, in sage.structure.coerce.CoercionModel.bin_op() + 1240 mul_method = getattr(y, '__r%s__'%op_name, None) + 1241 if mul_method is not None: +-> 1242 res = mul_method(x) + 1243 if res is not None and res is not NotImplemented: + 1244 return res + +File :55, in __rmul__(self, other) + +File /ext/sage/9.8/src/sage/rings/integer.pyx:1961, in sage.rings.integer.Integer.__mul__() + 1959 return y + 1960 +-> 1961 return coercion_model.bin_op(left, right, operator.mul) + 1962 + 1963 cpdef _mul_(self, right): + +File /ext/sage/9.8/src/sage/structure/coerce.pyx:1242, in sage.structure.coerce.CoercionModel.bin_op() + 1240 mul_method = getattr(y, '__r%s__'%op_name, None) + 1241 if mul_method is not None: +-> 1242 res = mul_method(x) + 1243 if res is not None and res is not NotImplemented: + 1244 return res + +File :55, in __rmul__(self, other) + +File :84, in __add__(self, other) + +File :65, in __mul__(self, other) + +File :63, in __mul__(self, other) + +AttributeError: 'superelliptic_function' object has no attribute 'form' +[?2004h[?25l[?7lsage: [?7h[?12l[?25h[?25l[?7l[?7h[?12l[?25h[?25l[?7lsage: for b in C1.de_rham_basis(): +....:  print(mult_by_p(b.omega0).regular_form())[?7h[?12l[?25h[?25l[?7l....:  print(mult_by_p(b.omega0).regular_form()) +....: [?7h[?12l[?25h[?25l[?7lsage: for b in C1.de_rham_basis(): +....:  print(mult_by_p(b.omega0).regular_form()) +....:  +[?7h[?12l[?25h[?2004l^C--------------------------------------------------------------------------- +KeyboardInterrupt Traceback (most recent call last) +Cell In [2], line 1 +----> 1 for b in C1.de_rham_basis(): + 2 print(mult_by_p(b.omega0).regular_form()) + +File :123, in de_rham_basis(self) + +File :105, in basis_de_rham_degrees(self) + +File :5, in __init__(self, C, omega, fct) + +File :28, in __sub__(self, other) + +File :7, in __init__(self, C, g) + +File :296, in reduction_form(C, g) + +File /ext/sage/9.8/src/sage/structure/element.pyx:1515, in sage.structure.element.Element.__mul__() + 1513 return (left)._mul_(right) + 1514 if BOTH_ARE_ELEMENT(cl): +-> 1515 return coercion_model.bin_op(left, right, mul) + 1516 + 1517 cdef long value + +File /ext/sage/9.8/src/sage/structure/coerce.pyx:1200, in sage.structure.coerce.CoercionModel.bin_op() + 1198 # Now coerce to a common parent and do the operation there + 1199 try: +-> 1200 xy = self.canonical_coercion(x, y) + 1201 except TypeError: + 1202 self._record_exception() + +File /ext/sage/9.8/src/sage/structure/coerce.pyx:1315, in sage.structure.coerce.CoercionModel.canonical_coercion() + 1313 x_elt = x + 1314 if y_map is not None: +-> 1315 y_elt = (y_map)._call_(y) + 1316 else: + 1317 y_elt = y + +File /ext/sage/9.8/src/sage/structure/coerce_maps.pyx:432, in sage.structure.coerce_maps.CallableConvertMap._call_() + 430 y = self._func(C, x) + 431 else: +--> 432 y = self._func(x) + 433 except Exception: + 434 if print_warnings: + +File /ext/sage/9.8/src/sage/rings/fraction_field.py:324, in FractionField_generic._coerce_map_from_..wrapper(x) + 323 def wrapper(x): +--> 324 return self._element_class(self, x.numerator(), x.denominator()) + +File /ext/sage/9.8/src/sage/rings/fraction_field_element.pyx:1167, in sage.rings.fraction_field_element.FractionFieldElement_1poly_field.__init__() + 1165 1/2/x + 1166 """ +-> 1167 FractionFieldElement.__init__(self, parent, numerator, denominator, + 1168 coerce, reduce) + 1169 if not reduce: + +File /ext/sage/9.8/src/sage/rings/fraction_field_element.pyx:121, in sage.rings.fraction_field_element.FractionFieldElement.__init__() + 119 if reduce and parent.is_exact(): + 120 try: +--> 121 self.reduce() + 122 except ArithmeticError: + 123 pass + +File /ext/sage/9.8/src/sage/rings/fraction_field_element.pyx:1239, in sage.rings.fraction_field_element.FractionFieldElement_1poly_field.reduce() + 1237 if self._is_reduced: + 1238 return +-> 1239 super(self.__class__, self).reduce() + 1240 self.normalize_leading_coefficients() + 1241 + +File /ext/sage/9.8/src/sage/rings/fraction_field_element.pyx:164, in sage.rings.fraction_field_element.FractionFieldElement.reduce() + 162 return codomain.coerce(nnum/nden) + 163 +--> 164 cpdef reduce(self): + 165 """ + 166 Reduce this fraction. + +File /ext/sage/9.8/src/sage/rings/fraction_field_element.pyx:210, in sage.rings.fraction_field_element.FractionFieldElement.reduce() + 208 if not self.__denominator.is_one() and self.__denominator.is_unit(): + 209 try: +--> 210 inv = self.__denominator.inverse_of_unit() + 211 except Exception: + 212 pass + +File /ext/sage/9.8/src/sage/rings/polynomial/polynomial_element.pyx:1524, in sage.rings.polynomial.polynomial_element.Polynomial.inverse_of_unit() + 1522 else: + 1523 cst = self.get_unsafe(0) +-> 1524 inv = cst.inverse_of_unit() + 1525 return self._parent([inv]) + 1526 + +File /ext/sage/9.8/src/sage/categories/fields.py:817, in Fields.ElementMethods.inverse_of_unit(self) + 787 def inverse_of_unit(self): + 788  r""" + 789  Return the inverse of this element. + 790 + (...) + 815  +infinity + 816  """ +--> 817 return ~self + +File /ext/sage/9.8/src/sage/rings/fraction_field_element.pyx:934, in sage.rings.fraction_field_element.FractionFieldElement.__invert__() + 932 if self.is_zero(): + 933 raise ZeroDivisionError("Cannot invert 0") +--> 934 return self.__class__(self._parent, + 935 self.__denominator, self.__numerator, coerce=False, reduce=False) + 936 + +File /ext/sage/9.8/src/sage/rings/fraction_field_element.pyx:1170, in sage.rings.fraction_field_element.FractionFieldElement_1poly_field.__init__() + 1168 coerce, reduce) + 1169 if not reduce: +-> 1170 self.normalize_leading_coefficients() + 1171 + 1172 cdef normalize_leading_coefficients(self): + +File /ext/sage/9.8/src/sage/rings/fraction_field_element.pyx:1177, in sage.rings.fraction_field_element.FractionFieldElement_1poly_field.normalize_leading_coefficients() + 1175 """ + 1176 invlc = ~self.__denominator.leading_coefficient() +-> 1177 self.__denominator = self.__denominator.monic() + 1178 self.__numerator *= invlc + 1179 + +File /ext/sage/9.8/src/sage/rings/polynomial/polynomial_element.pyx:5724, in sage.rings.polynomial.polynomial_element.Polynomial.monic() + 5722 - Naqi Jaffery (2006-01-24): examples + 5723 """ +-> 5724 if self.is_monic(): + 5725 return self + 5726 a = ~self.leading_coefficient() + +File /ext/sage/9.8/src/sage/rings/polynomial/polynomial_element.pyx:5497, in sage.rings.polynomial.polynomial_element.Polynomial.is_monic() + 5495 - Naqi Jaffery (2006-01-24): examples + 5496 """ +-> 5497 return not self.is_zero() and self[self.degree()] == 1 + 5498 + 5499 def is_unit(self): + +File /ext/sage/9.8/src/sage/structure/element.pyx:1111, in sage.structure.element.Element.__richcmp__() + 1109 return (self)._richcmp_(other, op) + 1110 else: +-> 1111 return coercion_model.richcmp(self, other, op) + 1112 + 1113 cpdef _richcmp_(left, right, int op): + +File /ext/sage/9.8/src/sage/structure/coerce.pyx:1973, in sage.structure.coerce.CoercionModel.richcmp() + 1971 # Coerce to a common parent + 1972 try: +-> 1973 x, y = self.canonical_coercion(x, y) + 1974 except (TypeError, NotImplementedError): + 1975 pass + +File /ext/sage/9.8/src/sage/structure/coerce.pyx:1315, in sage.structure.coerce.CoercionModel.canonical_coercion() + 1313 x_elt = x + 1314 if y_map is not None: +-> 1315 y_elt = (y_map)._call_(y) + 1316 else: + 1317 y_elt = y + +File /ext/sage/9.8/src/sage/structure/coerce_maps.pyx:156, in sage.structure.coerce_maps.DefaultConvertMap_unique._call_() + 154 cdef Parent C = self._codomain + 155 try: +--> 156 return C._element_constructor(x) + 157 except Exception: + 158 if print_warnings: + +File /ext/sage/9.8/src/sage/rings/finite_rings/finite_field_givaro.py:230, in FiniteField_givaro._element_constructor_(self, e) + 212  """ + 213  Return a random element of ``self``. + 214 + (...) + 226  True + 227  """ + 228 return self._cache.random_element() +--> 230 def _element_constructor_(self, e): + 231  """ + 232  Coerces several data types to ``self``. + 233 + (...) + 369  2*a4^3 + 2*a4^2 + 1 + 370  """ + 371 return self._cache.element_from_data(e) + +File src/cysignals/signals.pyx:310, in cysignals.signals.python_check_interrupt() + +KeyboardInterrupt: +[?2004h[?25l[?7lsage: [?7h[?12l[?25h[?25l[?7l[?7h[?12l[?25h[?25l[?7lsage: for b in C1.de_rham_basis(): +....:  print(mult_by_p(b.omega0).regular_form())[?7h[?12l[?25h[?25l[?7l....:  print(mult_by_p(b.omega0).regular_form()) +....: [?7h[?12l[?25h[?25l[?7lsage: for b in C1.de_rham_basis(): +....:  print(mult_by_p(b.omega0).regular_form()) +....:  +[?7h[?12l[?25h[?2004lTrue +[0] d[x] + [0] d[y] + V((2*a*x^9 + 2*x^3 + (a + 1)*x + 2*a) dy) + dV(0) +True +^C--------------------------------------------------------------------------- +KeyboardInterrupt Traceback (most recent call last) +Cell In [3], line 2 + 1 for b in C1.de_rham_basis(): +----> 2 print(mult_by_p(b.omega0).regular_form()) + +File :82, in regular_drw_form(omega) + +File :73, in diffn(self, dy_w) + +File :177, in dy_w(C) + +File :149, in auxilliary_derivative(P) + +File :149, in auxilliary_derivative(P) + +File :149, in auxilliary_derivative(P) + +File :147, in auxilliary_derivative(P) + +File :35, in __sub__(self, other) + +File :32, in __add__(self, other) + +File :39, in __add__(self, other) + +File :260, in reduction(C, g) + +File /ext/sage/9.8/src/sage/arith/misc.py:2021, in xgcd(a, b) + 1933 r""" + 1934 Return a triple ``(g,s,t)`` such that `g = s\cdot a+t\cdot b = \gcd(a,b)`. + 1935 + (...) + 2018  (1, 7*a^2/b^2, (((-h)*a)/b^2)*y + 1/b) + 2019 """ + 2020 try: +-> 2021 return a.xgcd(b) + 2022 except AttributeError: + 2023 a = py_scalar_to_element(a) + +File /ext/sage/9.8/src/sage/structure/element.pyx:4497, in sage.structure.element.coerce_binop.new_method() + 4495 def new_method(self, other, *args, **kwargs): + 4496 if have_same_parent(self, other): +-> 4497 return method(self, other, *args, **kwargs) + 4498 else: + 4499 a, b = coercion_model.canonical_coercion(self, other) + +File /ext/sage/9.8/src/sage/rings/polynomial/polynomial_element.pyx:8931, in sage.rings.polynomial.polynomial_element.Polynomial.xgcd() + 8929 """ + 8930 if hasattr(self.base_ring(), '_xgcd_univariate_polynomial'): +-> 8931 return self.base_ring()._xgcd_univariate_polynomial(self, other) + 8932 else: + 8933 raise NotImplementedError("%s does not provide an xgcd implementation for univariate polynomials"%self.base_ring()) + +File /ext/sage/9.8/src/sage/categories/fields.py:378, in Fields.ParentMethods._xgcd_univariate_polynomial(self, a, b) + 376 if d: + 377 c = ~d.leading_coefficient() +--> 378 d, u, v = c*d, c*u, c*v + 379 return d, u, v + +File /ext/sage/9.8/src/sage/structure/element.pyx:1515, in sage.structure.element.Element.__mul__() + 1513 return (left)._mul_(right) + 1514 if BOTH_ARE_ELEMENT(cl): +-> 1515 return coercion_model.bin_op(left, right, mul) + 1516 + 1517 cdef long value + +File /ext/sage/9.8/src/sage/structure/coerce.pyx:1194, in sage.structure.coerce.CoercionModel.bin_op() + 1192 if action is not None: + 1193 if (action)._is_left: +-> 1194 return (action)._act_(x, y) + 1195 else: + 1196 return (action)._act_(y, x) + +File /ext/sage/9.8/src/sage/structure/coerce_actions.pyx:612, in sage.structure.coerce_actions.LeftModuleAction._act_() + 610 if self.extended_base is not None: + 611 a = self.extended_base(a) +--> 612 return (a)._rmul_(g) # g * a + 613 + 614 + +File /ext/sage/9.8/src/sage/rings/polynomial/polynomial_element.pyx:11518, in sage.rings.polynomial.polynomial_element.Polynomial_generic_dense._rmul_() + 11516 if c._parent is not (self.__coeffs[0])._parent: + 11517 c = (self.__coeffs[0])._parent.coerce(c) +> 11518 v = [c * a for a in self.__coeffs] + 11519 cdef Polynomial_generic_dense res = self._new_c(v, self._parent) + 11520 #if not v[len(v)-1]: + +File /ext/sage/9.8/src/sage/structure/element.pyx:1513, in sage.structure.element.Element.__mul__() + 1511 cdef int cl = classify_elements(left, right) + 1512 if HAVE_SAME_PARENT(cl): +-> 1513 return (left)._mul_(right) + 1514 if BOTH_ARE_ELEMENT(cl): + 1515 return coercion_model.bin_op(left, right, mul) + +File /ext/sage/9.8/src/sage/rings/fraction_field_element.pyx:686, in sage.rings.fraction_field_element.FractionFieldElement._mul_() + 684 except NotImplementedError: + 685 pass +--> 686 return self.__class__(self._parent, tnum, tden, + 687 coerce=False, reduce=False) + 688 except AttributeError: + +File /ext/sage/9.8/src/sage/rings/fraction_field_element.pyx:1170, in sage.rings.fraction_field_element.FractionFieldElement_1poly_field.__init__() + 1168 coerce, reduce) + 1169 if not reduce: +-> 1170 self.normalize_leading_coefficients() + 1171 + 1172 cdef normalize_leading_coefficients(self): + +File /ext/sage/9.8/src/sage/rings/fraction_field_element.pyx:1178, in sage.rings.fraction_field_element.FractionFieldElement_1poly_field.normalize_leading_coefficients() + 1176 invlc = ~self.__denominator.leading_coefficient() + 1177 self.__denominator = self.__denominator.monic() +-> 1178 self.__numerator *= invlc + 1179 + 1180 def is_integral(self): + +File /ext/sage/9.8/src/sage/structure/element.pyx:1515, in sage.structure.element.Element.__mul__() + 1513 return (left)._mul_(right) + 1514 if BOTH_ARE_ELEMENT(cl): +-> 1515 return coercion_model.bin_op(left, right, mul) + 1516 + 1517 cdef long value + +File /ext/sage/9.8/src/sage/structure/coerce.pyx:1196, in sage.structure.coerce.CoercionModel.bin_op() + 1194 return (action)._act_(x, y) + 1195 else: +-> 1196 return (action)._act_(y, x) + 1197 + 1198 # Now coerce to a common parent and do the operation there + +File /ext/sage/9.8/src/sage/structure/coerce_actions.pyx:645, in sage.structure.coerce_actions.RightModuleAction._act_() + 643 if self.extended_base is not None: + 644 a = self.extended_base(a) +--> 645 return (a)._lmul_(g) # a * g + 646 + 647 + +File /ext/sage/9.8/src/sage/rings/polynomial/polynomial_zz_pex.pyx:221, in sage.rings.polynomial.polynomial_zz_pex.Polynomial_ZZ_pEX._lmul_() + 219 r._parent = (self)._parent + 220 r._cparent = (self)._cparent +--> 221 d = self._parent._modulus.ZZ_pE(list(left.polynomial())) + 222 ZZ_pEX_mul_ZZ_pE(r.x, self.x, d.x) + 223 return r + +File /ext/sage/9.8/src/sage/libs/ntl/ntl_ZZ_pEContext.pyx:154, in sage.libs.ntl.ntl_ZZ_pEContext.ntl_ZZ_pEContext_class.ZZ_pE() + 152 """ + 153 from .ntl_ZZ_pE import ntl_ZZ_pE +--> 154 return ntl_ZZ_pE(v,modulus=self) + 155 + 156 def ZZ_pEX(self, v = None): + +File /ext/sage/9.8/src/sage/libs/ntl/ntl_ZZ_pE.pyx:117, in sage.libs.ntl.ntl_ZZ_pE.ntl_ZZ_pE.__init__() + 115 self.x = ZZ_pX_to_ZZ_pE((v).x) + 116 elif isinstance(v, (list, tuple)): +--> 117 tmp_zzpx = ntl_ZZ_pX(v, self.c.pc) + 118 self.c.restore_c() # allocating tmp_zzpx can change the current modulus trac #25790 + 119 self.x = ZZ_pX_to_ZZ_pE(tmp_zzpx.x) + +File /ext/sage/9.8/src/sage/libs/ntl/ntl_ZZ_pX.pyx:108, in sage.libs.ntl.ntl_ZZ_pX.ntl_ZZ_pX.__init__() + 106 for i, x in enumerate(v): + 107 if not isinstance(x, ntl_ZZ_p): +--> 108 cc = ntl_ZZ_p(x, self.c) + 109 self.c.restore_c() + 110 else: + +File /ext/sage/9.8/src/sage/libs/ntl/ntl_ZZ_p.pyx:131, in sage.libs.ntl.ntl_ZZ_p.ntl_ZZ_p.__init__() + 129 ZZ_p_div(self.x, ZZ_to_ZZ_p(num), ZZ_to_ZZ_p(den)) + 130 else: +--> 131 str_v = str(v) # can cause modulus to change trac #25790 + 132 self.c.restore_c() + 133 ccreadstr(self.x, str_v) + +File src/cysignals/signals.pyx:310, in cysignals.signals.python_check_interrupt() + +KeyboardInterrupt: +[?2004h[?25l[?7lsage: [?7h[?12l[?25h[?25l[?7l[?7h[?12l[?25h[?25l[?7lload('init.sage')[?7h[?12l[?25h[?25l[?7lo[?7h[?12l[?25h[?25l[?7lad('init.sage')[?7h[?12l[?25h[?25l[?7lsage: load('init.sage') +[?7h[?12l[?25h[?2004l[0] d[x] + [0] d[y] + V((2*a*x^9 + 2*x^3 + (a + 1)*x + 2*a) dy) + dV(0) +[0] d[x] + [0] d[y] + V((2*a*x^12 + 2*x^6 + (a + 1)*x^4 + 2*a*x^3) dy) + dV(0) +[0] d[x] + [0] d[y] + V((2*a*x^15 + 2*x^9 + (a + 1)*x^7 + 2*a*x^6) dy) + dV(0) +[0] d[x] + [0] d[y] + V((2*a*x^18 + 2*x^12 + (a + 1)*x^10 + 2*a*x^9) dy) + dV(0) +[0] d[x] + [0] d[y] + V((2*a*x^30 + 2*x^24 + (a + 1)*x^22 + 2*a*x^21 + (a + 1)*x^12 + a*x^6 + (a + 2)*x^4 + (a + 1)*x^3) dy) + dV(0) +[0] d[x] + [0] d[y] + V((a*x^27 + x^21 + (2*a + 2)*x^19 + a*x^18 + (2*a + 2)*x^9 + 2*a*x^3 + (2*a + 1)*x + 2*a + 2) dy) + dV(0) +[0] d[x] + [0] d[y] + V((0) dy) + dV(0) +[0] d[x] + [0] d[y] + V((2*a*x^21 + 2*x^15 + (a + 1)*x^13 + 2*a*x^12) dy) + dV(0) +[?2004h[?25l[?7lsage: [?7h[?12l[?25h[?25l[?7l[?7h[?12l[?25h[?25l[?7lq[?7h[?12l[?25h \ No newline at end of file diff --git a/sage/superelliptic_drw/regular_form.sage b/sage/superelliptic_drw/regular_form.sage index 60ac5f4..193fd29 100644 --- a/sage/superelliptic_drw/regular_form.sage +++ b/sage/superelliptic_drw/regular_form.sage @@ -73,22 +73,15 @@ class superelliptic_regular_drw_form: return "[" + str(self.dx) + "] d[x] + [" + str(self.dy) + "] d[y] + V(" + str(self.omega) + ") + dV(" + str(self.h2) + ")" def regular_drw_form(omega): - print(omega.frobenius().is_regular_on_U0()) C = omega.curve p = C.characteristic omega_aux = omega.r() omega_aux = omega_aux.regular_form() aux = omega - omega_aux.dx.teichmuller()*C.x.teichmuller().diffn() - omega_aux.dy.teichmuller()*C.y.teichmuller().diffn() - print("aux == omega", aux == omega) aux1 = aux.omega aux.omega, fct = decomposition_omega0_hpdh(aux.omega) - print('aux.omega, fct', aux.omega, fct, aux1.cartier() == fct.diffn(), aux1.verschiebung() == mult_by_p(fct.diffn())) - print('mult_by_p(fct.diffn()) == (fct^p).verschiebung().diffn()', mult_by_p(fct.diffn()) == (fct^p).verschiebung().diffn()) aux.h2 += fct^p - print(aux.omega.is_regular_on_U0(), aux.frobenius().is_regular_on_U0()) - print('aux - omega', aux - omega) aux.h2, A = decomposition_g0_pth_power(aux.h2) - print('A.diffn().is_regular_on_U0()', A.diffn().is_regular_on_U0()) aux.omega += (A.diffn()).inv_cartier() result = superelliptic_regular_drw_form(omega_aux.dx, omega_aux.dy, aux.omega.regular_form(), aux.h2) return result