updated compute controlled matrix

Author: stevehuang235

src/CharPolyFrob.jl

@@ -134,12 +134,13 @@ function apply_newton_identity(n, d, p, prec_vec, cp_coeffs, modulus)
                 sum = sum - e[k+1-i] * s[i+1]
             end  
         end 
+        #println("sum=$sum")
         if k%2 == 0
-            s[k+1] = sum - k * e[k+1]
-            #s[k+1] = -(sum + k * e[k+1])
+            #s[k+1] = sum - k * e[k+1]
+            s[k+1] = -(sum + k * e[k+1])
         else
-            s[k+1] = -1 * (sum - k * e[k+1])
-            #s[k+1] = sum + k * e[k+1]
+            #s[k+1] = -1 * (sum - k * e[k+1])
+            s[k+1] = sum + k * e[k+1]
         end 
 
 
@@ -153,12 +154,12 @@ function apply_newton_identity(n, d, p, prec_vec, cp_coeffs, modulus)
         #println(s[k+1])
 
         if k%2 == 0
-            e[k+1] = div(sum-s[k+1], k)
-            #e[k+1] = div(-s[k+1]-sum, k)
+            #e[k+1] = div(sum-s[k+1], k)
+            e[k+1] = div(-s[k+1]-sum, k)
             cp_coeffs[d+1-k] = e[k+1]
         else
-            e[k+1] = div(sum+s[k+1], k)
-            #e[k+1] = div(s[k+1]-sum, k)
+            #e[k+1] = div(sum+s[k+1], k)
+            e[k+1] = div(s[k+1]-sum, k)
             cp_coeffs[d+1-k] = -e[k+1]
         end
         #println("k=$k")
@@ -195,15 +196,18 @@ function compute_Lpolynomial(n, p, polygon, relative_precision, cp_coeffs, verbo
         Lpoly_coeffs[i] = mod(Lpoly_coeffs[i], modulus[i])
     end 
     (1 == verbose) && println("coefficients after moding by prec = $Lpoly_coeffs")
+    #println("coefficients after moding by prec = $Lpoly_coeffs")
 
     Lpoly_coeffs[d+1] = 1  # set leading coefficient to 1 
     sign = sign_fe(n, d, p, prec_vec, Lpoly_coeffs)  # determine the sign of the functional equation 
     (1 == verbose) && println("sign of functional equation = $sign")
     Lpoly_coeffs[1] = sign * p^(div(d*dimension, 2))
     #println(Lpoly_coeffs[1])
+    #println("prec_vec=$prec_vec")
     Lpoly_coeffs = DeRham.apply_symmetry(n,d,p,prec_vec,Lpoly_coeffs,modulus,sign)
     (1 == verbose) && println("coefficients after apply symmetry = $Lpoly_coeffs")
-    #println("modulus=$modulus")
+    #println("prec_vec=$prec_vec")
+    #println("coefficients after apply symmetry = $Lpoly_coeffs")
     Lpoly_coeffs = DeRham.apply_newton_identity(n,d,p,prec_vec,Lpoly_coeffs,modulus)
     (1 == verbose) && println("coeffficients after applying Newton's identity = $Lpoly_coeffs")
 

src/ControlledReduction.jl

@@ -420,7 +420,7 @@ function reducechain_costachunks(u,g,m,S,f,pseudoInverseMat,p,Ruvs,explookup,A,B
         nend = p
     end
 
-    matrices = computeRuv(V,S,f,pseudoInverseMat,Ruvs,explookup,params)
+    matrices = computeRuvS(V,S,f,pseudoInverseMat,Ruvs,explookup,params)
 
     #TODO: the following was changed to use reverse! so 
     #    it doesn't allocate as much, but I realized that
@@ -475,7 +475,7 @@ function reducechain_costachunks(u,g,m,S,f,pseudoInverseMat,p,Ruvs,explookup,A,B
         # there's some sort of parity issue between our code and Costa's
         #A,B = computeRPoly_LAOneVar(y,rev_tweak(J - (i+1)*V,d*n-n) - y,S,n,d,f,pseudoInverseMat,R,PR,termorder)
 
-        matrices1 = computeRuv(y,S,f,pseudoInverseMat,Ruvs,explookup,params)
+        matrices1 = computeRuvS(y,S,f,pseudoInverseMat,Ruvs,explookup,params)
         #println(matrices1)
         #error()
 

src/FindMonomialBasis.jl

@@ -76,6 +76,8 @@ function compute_controlled_matrix(f, l, S, R, PR, params)
     vars = gens(PR)
 
     len_S = length(S)
+    notS = setdiff(collect(0:n),S)
+    len_notS = length(notS)
 
     @assert(len_S >= 0 && len_S <= n+1)
 
@@ -98,20 +100,26 @@ function compute_controlled_matrix(f, l, S, R, PR, params)
 
     partials = [ derivative(f, i) for i in 1:n+1 ]
     if params.vars_reversed == true
-        partials = reverse(partials)
+        partials = reverse(partials)  # one needs to be quite careful with the ordering of partials 
+        notS = reverse(notS)
     end
 
     for i in 1:len_S
+        var = S[i]
         for monomial in eachindex(in_set_mons)
-            M[:, in_set_section * (i-1) + monomial] = polynomial_to_vector(in_set_mons[monomial] * partials[i], n+1, R, PR, params.termorder)
+            M[:, in_set_section * (i-1) + monomial] = polynomial_to_vector(in_set_mons[monomial] * partials[len_notS+1+var], n+1, R, PR, params.termorder)
+            #M[:, in_set_section * (i-1) + monomial] = polynomial_to_vector(in_set_mons[monomial] * partials[i], n+1, R, PR, params.termorder)
         end
     end
 
     for i in (len_S+1):n+1
+        var = notS[i-len_S]
         for monomial in eachindex(not_in_set_mons)
-            M[:, not_in_set_section * (i-1) + monomial] = polynomial_to_vector(not_in_set_mons[monomial] * vars[i] * partials[i], n+1, R, PR, params.termorder)
+            M[:, not_in_set_section * (i-1) + monomial] = polynomial_to_vector(not_in_set_mons[monomial] * vars[var+1] * partials[i-len_S], n+1, R, PR, params.termorder)
+            #M[:, not_in_set_section * (i-1) + monomial] = polynomial_to_vector(not_in_set_mons[monomial] * vars[i] * partials[i], n+1, R, PR, params.termorder)
         end
     end
+    println(rank(M))
     return M
 end
 

src/SmoothNondegenerate.jl

@@ -16,18 +16,19 @@ function find_Ssmooth_model(f, M, S_target, params)
     SLn = special_linear_group(n + 1, GF(q))
     d = total_degree(f)
     vars = gens(PR)
-    l = l = d * n - n + d - length(S_target)
+    l = d * n - n + d - length(S_target)
 
     bool = true 
+    f_transformed = f
     while bool
-        mat = rand(SLn)
-        new_vars = mat * vars
-        f_transformed = evaluate(f, new_vars)
         try 
             pseudo_inverse_mat_new = pseudo_inverse_controlled_lifted(f_transformed,S_target,l,M,params)
             bool = false
             return f_transformed, pseudo_inverse_mat_new
         catch e
+            mat = rand(SLn)
+            new_vars = matrix(mat) * vars
+            f_transformed = evaluate(f, new_vars)
         end 
     end 
 

src/ZetaFunction.jl

@@ -294,6 +294,7 @@ function zeta_function(f; S=[-1], verbose=false, givefrobmat=false, algorithm=:c
     (9 < verbose) && println("Basis of cohomology is $Basis")
 
     (hodge_polygon, r_m, N_m, M) = precision_information(f,Basis,verbose)
+    #print(find_Ssmooth_model(f, M, S, params))
     #hodge_polygon = hodgepolygon(Basis, n)
     #hodge_numbers = hodge_polygon.slopelengths
     #(9 < verbose) && println("Hodge numbers = $hodge_numbers")