lots

Code/paulhus.m

@@ -0,0 +1,93 @@
+intrinsic IsCaseSpherical(sig::SeqEnum[RngIntElt]) -> BoolElt
+  {}
+  a,b,c := Explode(Sort(sig));
+  if (a eq b and a eq 2) or (a eq 2 and b eq 3 and c eq 3) or (a eq 2 and b eq 3 and c eq 4) or (a eq 2 and b eq 3 and c eq 5) then
+    return true;
+  else
+    return false;
+  end if;
+end intrinsic;
+
+intrinsic IsCaseAAA(sig::SeqEnum[RngIntElt]) -> BoolElt
+  {}
+  if IsCaseSpherical(sig) then
+    return false;
+  else
+    a,b,c := Explode(sig);
+    if a eq b and b eq c then
+      return true;
+    else
+      return false;
+    end if;
+  end if;
+end intrinsic;
+
+intrinsic IsCaseAAC(sig::SeqEnum[RngIntElt]) -> BoolElt
+  {}
+  a,b,c := Explode(Sort(sig));
+  if b eq 4 and c eq 4 then
+    return false;
+  end if;
+  if IsCaseSpherical(sig) then
+    return false;
+  else
+    a,b,c := Explode(sig);
+    if a eq b or a eq c or b eq c then
+      return true;
+    else
+      return false;
+    end if;
+  end if;
+end intrinsic;
+
+intrinsic IsCase2B2B(sig::SeqEnum[RngIntElt]) -> BoolElt
+  {}
+  if IsCaseSpherical(sig) then
+    return false;
+  else
+    a,b,c := Explode(Sort(sig));
+    if a eq 2 and c eq 2*b then
+      return true;
+    else
+      return false;
+    end if;
+  end if;
+end intrinsic;
+
+intrinsic IsMaximal(sig::SeqEnum[RngIntElt]) -> BoolElt
+  {}
+  if (not IsCaseAAA(sig)) and (not IsCaseAAC(sig)) and (not IsCase2B2B(sig)) then
+    return true;
+  else
+    return false;
+  end if;
+end intrinsic;
+
+intrinsic MaximalSignature(sig::SeqEnum[RngIntElt]) -> SeqEnum[RngIntElt]
+  {}
+  a,b,c := Explode(sig);
+  if IsCaseAAA(sig) then
+    return MaximalSignature([3,3,a]);
+  elif IsCaseAAC(sig) then
+    if a eq b then
+      one := c;
+      two := a;
+    elif a eq c then
+      one := b;
+      two := a;
+    elif b eq c then
+      one := a;
+      two := b;
+    else
+      error "how?";
+    end if;
+    return MaximalSignature([2, two, 2*one]);
+  elif IsCase2B2B(sig) then
+    assert IsCase2B2B(Sort(sig));
+    a,b,c := Explode(Sort(sig));
+    assert c eq 2*b and a eq 2;
+    return MaximalSignature([2, 3, 2*b]);
+  else
+    return Sort(sig);
+  end if;
+end intrinsic;

Code/robust_sanity_check.m

@@ -0,0 +1,169 @@
+/*
+intrinsic NaivePlaneProjection(X::Crv, phi::FldFunFracSchElt) -> Any
+  {}
+  Z, mp := EmbedPlaneCurveInP3(X);
+  X := Z;
+  phi := Pullback(mp, phi);
+  X, phi := PlaneProjection(X, phi);
+  return X, phi;
+end intrinsic;
+*/
+
+intrinsic Specialize(X::Crv, a::FldRatElt) -> RngUPolElt
+  {}
+  eqns := DefiningEquations(X);
+  K := BaseField(X);
+  a := K!a;
+  P := Parent(eqns[1]);
+  rk := Rank(P);
+  eqns_eval := eval Sprintf("return [Evaluate(f, [a, %o]) : f in eqns];", HomText("X", 2, rk));
+  I := ideal<P|eqns_eval>;
+  I := EliminationIdeal(I, {P.rk});
+  basis := Basis(I);
+  assert #basis eq 1;
+  h := hom<P->PolynomialRing(K)|[0,0,0,PolynomialRing(K).1]>;
+  return h(basis[1]);
+end intrinsic;
+
+intrinsic SpecializeWrapper(X::Crv) -> Any
+  {}
+  assert IsAffine(X);
+  d := 2*Dimension(Ambient(X));
+  L1 := Specialize(X, 3/5);
+  L2 := Specialize(X, 3/4);
+  L3 := Specialize(X, 3/7);
+  L1 := SplittingField(L1);
+  L2 := SplittingField(L2);
+  L3 := SplittingField(L3);
+  n1 := Degree(L1)/d;
+  n2 := Degree(L2)/d;
+  n3 := Degree(L3)/d;
+  assert n1 eq n2;
+  assert n3 eq n2;
+  n := Integers()!n1;
+  subs1 := Subfields(L1, n);
+  subs2 := Subfields(L2, n);
+  subs3 := Subfields(L3, n);
+  l1 := [Discriminant(sub[1]) : sub in subs1];
+  l2 := [Discriminant(sub[1]) : sub in subs2];
+  l3 := [Discriminant(sub[1]) : sub in subs3];
+  return (l1 meet l2) meet l3;
+end intrinsic;
+
+
+/*
+  > %P;
+  load "oli.m";
+  SetDebugOnError(true);
+  // automorphisms up to degree 4
+    // degree2
+    t := PassportObjects(Passports(2)[2])[1];
+    t := TwoGroupBelyiMap(t);
+    t := Degree2TwoGroupAutomorphisms(t);
+    // degree4
+    s := ParentObjects(t)[2];
+    s := TwoGroupBelyiMap(s, t);
+    s := TwoGroupAutomorphisms(s,t);
+    // degree8
+    t := s;
+    s := ParentObjects(t)[1];
+    s := TwoGroupBelyiMap(s, t);
+    f := GetTwoGroupExtractFunction(s);
+    iota := GetTwoGroupAutomorphisms(t)[3];
+    X := GetTwoGroupBelyiCurve(s);
+  //
+  iota(f);
+  IsSquare(iota(f));
+  f;
+  Parent(iota(f));
+  Support(Divisor(iota(f));
+  Support(Divisor(iota(f)));
+  f;
+  X;
+  KX := FunctionField(X);
+  KX<[x]> := FunctionField(X);
+  x[3]/x[2];
+  iota;
+  GetTwoGroupCurveAutomorphisms(s)[3];
+  GetTwoGroupCurveAutomorphisms(t)[3];
+  iota := hom<KX->KX|[x[1],-x[2],(nu*x[2]*x[3] - nu*x[3])/(x[2] + 1),x[4]]>;
+  K<nu> := BaseField(X);
+  iota := hom<KX->KX|[x[1],-x[2],(nu*x[2]*x[3] - nu*x[3])/(x[2] + 1),x[4]]>;
+  f;
+  iota(x[3]/x[2]);
+  Support(Divisor($1));
+  1/x[2]*x[3];
+  iota^2;
+  IsIdentity(iota);
+  [iota^2(x[i]) : i in [1..4]];
+  [(iota^2)(x[i]) : i in [1..4]];
+  [(iota^3)(x[i]) : i in [1..4]];
+  [(iota^4)(x[i]) : i in [1..4]];
+  x[1];
+  [(iota^4)(x[i]) eq x[i]: i in [1..4]];
+  [(iota^4)(x[2]) eq x[i]: i in [1..4]];
+  IdentifyGroup(MonodromyGroup(s));
+  [(iota^2)(x[2]) eq x[i]: i in [1..4]];
+  [(iota^2)(x[i]) eq x[i]: i in [1..4]];
+  X_QQ;
+  Specialization;
+  Type(Rationals());
+  RngUPolElt;
+*/
+
+/*
+  > %P;
+  X_QQ;
+  equations := DefiningEquations(X_QQ);
+  equations;
+  [Evaluate(f,[3/5,x[2],x[3],x[4]]) : f in equations];
+  X_QQ<[x]> := X_QQ;
+  [Evaluate(f,[3/5,x[2],x[3],x[4]]) : f in equations];
+  evaluated := [Evaluate(f,[3/5,x[2],x[3],x[4]]) : f in equations];
+  I := ideal<Parent(evaluated)[1]|evaluated>;
+  I := ideal<Parent(evaluated[1])|evaluated>;
+  I;
+  EliminationIdeal(I);
+  EliminationIdeal;
+  EliminationIdeal(I,{x[4]});
+  f := Polynomial([-3/5, 0,0,0,-6,0,1]);
+  f;
+  f := Polynomial([-3/5, 0,0,0,-6,0,0,01]);
+  f;
+  f := Polynomial([-3/5, 0,0,0,-6,0,0,0,1]);
+  Factorization(f);
+  GaloisGroup(f);
+  G := GaloisGroup(f);
+  MonodromyGroup(s_QQ);
+  H := MonodromyGroup(s_QQ);
+  K := NumberField(f);
+  K;
+  SplittingField(K);
+  L := SplittingField(K);
+  Subfields(L);
+  subs := Subfields(L);
+#subs;
+  [Degree(F), Discriminant(Integers(F)) : F in subs];
+  [<Degree(F), Discriminant(Integers(F))> : F in subs];
+  subs[1];
+  subs[1][1];
+  [<Degree(F[1]), Discriminant(Integers(F[1]))> : F in subs];
+  Subfields;
+  subs := Subfields(L : Degree:=4);
+  subs;
+  subs := [K in subs : Degree(K) eq 4];
+  subs4 := [];
+  for K in subs do
+  if Degree(K) eq 4 then
+  Append(~subs4, K);
+  end ir;
+  subs4 := [];
+  for sub in subs do
+  K := sub[1];
+  if Degree(K) eq 4 then
+  Append(~subs4, K);
+  end if;
+  end for;
+  [<Degree(F[1]), Discriminant(Integers(F[1]))> : F in subs4];
+  [<Degree(F), Discriminant(Integers(F))> : F in subs4];
+*/

Code/solvable_db_obj.m

@@ -37,6 +37,15 @@
   // Belyi map attributes
     SolvableDBBelyiCurve, // X
     SolvableDBBelyiMap, // phi
+  // temporary attributs (for now) to compute action on differentials
+    IsTwoGroupBelyiMapComputed, // BoolElt
+    TwoGroupBelyiCurveList, // List[Crv]
+    TwoGroupBelyiMapList, // List[FldFunFracSchElt]
+    TwoGroupExtractList, // List[FldFunFracSchElt] (below)
+    TwoGroupAutomorphisms, // SeqEnum[functionfield hom]
+    TwoGroupCurveAutomorphisms, // SeqEnum[curve map]
+    TwoGroupAutoTextList, // SeqEnum[SeqEnum[MonStgElt]]
+    TwoGroupCyclotomicPower, // k where zeta_2^k is base field
   // temporary attributes (not saved to database)
     SolvableDBResidueField0,
     SolvableDBResidueField1,

Code/spec

@@ -19,4 +19,8 @@
   query.m
   point_counting.m
   refined.m
+  proof.m
+  action_on_differentials.m
+  paulhus.m
+	robust_sanity_check.m
 }

auts_by_hand.m

@@ -0,0 +1,51 @@
+load "oli.m";
+
+SetDebugOnError(true);
+
+downstairs := 2;
+upstairs := 2;
+
+// degree2
+t := PassportObjects(Passports(2)[downstairs])[1];
+t := TwoGroupBelyiMap(t);
+t := Degree2TwoGroupAutomorphisms(t);
+
+// degree4
+s := ParentObjects(t)[upstairs];
+s := TwoGroupBelyiMap(s, t);
+s := TwoGroupAutomorphisms(s,t);
+
+// degree8
+t := s;
+s := ParentObjects(t)[1];
+s := TwoGroupBelyiMap(s, t);
+/* K := CyclotomicField(4); */
+/* s := TwoGroupBaseChange(s, K); */
+/* t := TwoGroupBaseChange(t, K); */
+/* s, t := TwoGroupRelateObjects(s, t); */
+/* aut := GetTwoGroupCurveAutomorphisms(t)[3]; */
+/* iota := GetTwoGroupAutomorphisms(t)[3]; */
+/* f := GetTwoGroupExtractFunction(s); */
+
+/* s := TwoGroupAutomorphisms(s, t); */
+
+
+/* K<nu> := CyclotomicField(2^2); */
+/* K := Rationals(); */
+
+/* // curve downstairs */
+/* P1<[x]> := PolynomialRing(K, 2); */
+/* X1<[x]> := Curve(AffineSpace(P1), ideal<P1|x[1] + x[2]^2 - 1>); */
+/* curve_aut1 := map<X1->X1|[x[1], -x[2]]>; */
+/* KX1<[x]> := FunctionField(X1); */
+/* aut1 := hom<KX1->KX1|[x[1], -x[2]]>; */
+/* f1 := KX1!((x[2]-1)/(x[2]^2+x[2])); */
+
+/* // curve upstairs */
+/* P2<[x]> := PolynomialRing(K, 3); */
+/* X2<[x]> := Curve(AffineSpace(P2), ideal<P2|[x[1] + x[2]^2 - 1, x[1]*x[3]^2 - x[2]*x[3]^2 - x[3]^2 + x[2] - 1]>); */
+
+/* // lift auto */
+/* _, s := IsSquare(aut1(f1)/f1); */
+/* s_text := Sprintf("%o", s); */
+/* m := eval Sprintf("return map<X2->X2|[x[1], -x[2], (%o)*x[3]]>;", s_text); */

by_day.m

@@ -0,0 +1,43 @@
+load "oli.m";
+
+K := CyclicGroup(2);
+H := DirectProduct(CyclicGroup(2), CyclicGroup(2));
+AutH := AutomorphismGroup(H);
+
+phi := hom< K->AutH | [hom<H->H | [H.1^-1]>]>;
+
+G := SemidirectProduct(H, K, phi);
+
+#G;
+ConjugacyClasses(G);
+
+exit;
+
+/*
+   s := PassportObjects(LaxPassports(8)[6][1])[1];
+   t := ChildObject(s);
+
+   Gp := MonodromyGroup(t);
+   G := MonodromyGroup(s);
+   AutGp := AutomorphismGroup(Gp);
+   AutG := AutomorphismGroup(G);
+
+   mpG, RepAutG, setG := PermutationRepresentation(AutG);
+   mpGp, RepAutGp, setGp := PermutationRepresentation(AutGp);
+   assert #Kernel(mpG) eq 1;
+   assert #Kernel(mpGp) eq 1;
+   AutGIndexed := [g @@ mpG : g in RepAutG];
+   AutGpIndexed := [g @@ mpGp : g in RepAutGp];
+
+   CsG := ConjugacyClasses(G);
+   CsGp := ConjugacyClasses(Gp);
+
+   sigmap := Passport(t)[1];
+   exts := Extensions(sigmap);
+   ext := exts[8];
+   iota := ext[2];
+   pi := ext[3];
+   assert Codomain(iota) eq Domain(pi);
+   assert Domain(pi) eq G;
+   assert Codomain(pi) eq Gp;
+*/

by_day.sage

@@ -1,5 +1,5 @@
 from sage.schemes.riemann_surfaces.riemann_surface import RiemannSurface
 A.<x,y> = AffineSpace(QQ, 2)
-C = Curve([x^9 + 3*x^8 + 3*x^7*y^2 - 4*x^7*y + 4*x^7 + 6*x^6*y^3 - 13*x^6*y^2 - 18*x^6*y + 5*x^6 - 4*x^5*y^4 + 8*x^5*y^3 - 23*x^5*y^2 - 16*x^5*y + 7*x^5 + x^4*y^6 - 10*x^4*y^5 + 21*x^4*y^4 - 2*x^4*y^3 - 11*x^4*y^2 - 10*x^4*y + 6*x^4 - 5*x^3*y^6 + 20*x^3*y^5 - 10*x^3*y^4 + 8*x^3*y^3 - 14*x^3*y^2 - 12*x^3*y + 4*x^3 - 2*x^2*y^8 + 2*x^2*y^7 + 8*x^2*y^6 + 20*x^2*y^5 + 26*x^2*y^4 + 24*x^2*y^3 + 12*x^2*y^2 + 8*x^2*y + 4*x^2 + 5*x*y^8 + 20*x*y^7 + 30*x*y^6 + 36*x*y^5 + 28*x*y^4 + 24*x*y^3 + 8*x*y^2 + y^10 + 6*y^9 + 16*y^8 + 24*y^7 + 24*y^6 + 16*y^5 + 4*y^4], A)
+C = Curve([x^2 - x*y^4 - x - y^4], A)
 S = RiemannSurface(C.defining_polynomial(), prec = 20)