corrected check algo

experimental/AlgebraicShifting/src/PartialShift.jl

@@ -343,66 +343,68 @@
 ################################################################################
 # Las Vegas Partial Shifting
 
 function random_rothe_matrix(F::Field, p::PermGroupElem)
   char = characteristic(F)
   range = char == 0 ? 100 : char
   n = degree(parent(p))
   u = identity_matrix(F, n)
   for (i, j) in inversions(p)
     u[i, j] = F.(round.(Integer, range .* rand()) .- (range // 2))
   end
   return u * permutation_matrix(F, p)
 end
 
 function random_shift(F::Field, K::ComplexOrHypergraph, p::PermGroupElem;)
   n = n_vertices(K)
   exterior_shift(K, random_rothe_matrix(F, p))
 end
 
 random_shift(K::ComplexOrHypergraph, p::PermGroupElem) = random_shift(QQ, K, p)
 
 # returns true if the target is the partial shift of src with respect to p
 function check_shifted(F::Field, src::UniformHypergraph,
                        target::UniformHypergraph, p::PermGroupElem)
-  target_faces = faces(target)
+  target_faces = sort(faces(target))
   max_face = length(target_faces) == 1 ? target_faces[1] : max(target_faces...)
-  num_rows = length(target_faces)
+  # currently number of faces of src and target are the same
+  # this may change in the future
+  num_rows = length(faces(src)) 
   n = n_vertices(src)
   k = face_size(src)
   nCk = sort(subsets(n, k))
   max_face_index = findfirst(x -> x == max_face, nCk)
   # limits the columns by the max face of source
   cols = nCk[1:max_face_index - 1]
   r = rothe_matrix(F, p)
 
   if max_face_index > num_rows
     M = compound_matrix(r, src)[collect(1:num_rows), collect(1:length(cols))]
     Oscar.ModStdQt.ref_ff_rc!(M)
-    nCk[independent_columns(M)] != target_faces && return false
+    nCk[independent_columns(M)] != target_faces[1:end - 1] && return false
   end
   return true
 end
 
 function check_shifted(F::Field, src::SimplicialComplex,
                        target::SimplicialComplex, p::PermGroupElem)
   n = n_vertices(src)
   f_vec = f_vector(src)
   k = length(f_vec)
   while k > 1
     uhg_src = uniform_hypergraph(complex_faces(src, k - 1), n)
     uhg_target = uniform_hypergraph(complex_faces(target, k - 1), n)
     !check_shifted(F, uhg_src, uhg_target, p) && return false
     k -= 1
   end
   return true
 end
 
 function exterior_shift_lv(F::Field, K::ComplexOrHypergraph, p::PermGroupElem)
   sample_size = characteristic(F) == 0 ? 10 : 100
   shift = partialsort!([random_shift(F, K, p) for _ in 1:sample_size], 1;
                       lt=isless_lex)
   check_shifted(F, K, shift, p) && return shift
-  return exterior_shift_lv(F, K, p)
+  return nothing #exterior_shift_lv(F, K, p)
 end
 
 ###############################################################################

experimental/AlgebraicShifting/src/PartialShiftGraph.jl

@@ -1,3 +1,4 @@
+# TODO: change Vector -> Set
 const EdgeLabels = Dict{Tuple{Int, Int}, Vector{WeylGroupElem}}
 
 function isless_lex(S1::Set{Set{Int}}, S2::Set{Set{Int}})
@@ -181,6 +182,7 @@ function partial_shift_graph(F::Field, complexes::Vector{T},
                              parallel::Bool = false,
                              show_progress::Bool = true,
                              task_size::Int=100) where T <: ComplexOrHypergraph
+  # see TODO above about changing EdgeLabels type
   # Deal with trivial case
   if length(complexes) == 1
     @req is_shifted(complexes[1]) "The list of complexes should be closed under shifting by elements of W"