fix meataxe

src/DecategorifiedFramework/multiplication_table.jl

@@ -121,7 +121,7 @@ function multiplication_table_with_progress(C::Category, indecs::Vector{<:Object
     displ = ["⋅" for _ ∈ 1:n, _ ∈ 1:n]
 
     for i ∈ 1:n, j ∈ (symmetric ? i : 1):n
-        m[i,j,:] = coefficients(indecs[i] ⊗ indecs[j])
+        m[i,j,:] = coefficients(indecs[i] ⊗ indecs[j], indecs)
         if symmetric m[j,i] = m[i,j] end
 
         displ[i,j] = pretty_print_decomposable(m[i,j,:], names)

src/TensorCategoryFramework/InternalModules/MeatAxe.jl

@@ -79,6 +79,10 @@ function meataxe(M::RightModuleObject, incl::Vector{T}, proj::Vector{T}) where T
     C = category(parent(M))
     A = algebra(parent(M))
 
+    if is_simple(object(M))
+        return true, M, id(M)
+    end
+
     local kernel_of_a, kernel_inclusion
     # Dummy for now 
 
@@ -87,7 +91,6 @@ function meataxe(M::RightModuleObject, incl::Vector{T}, proj::Vector{T}) where T
             id(object(M)) ⊗ i,
             right_action(M)
         )
-
         kernel_of_a, kernel_inclusion = kernel(action_of_a)
         if kernel_of_a != zero(C)
             break
@@ -106,10 +109,10 @@ function meataxe(M::RightModuleObject, incl::Vector{T}, proj::Vector{T}) where T
     end
 
     f = Hom(dual(kernel_of_a), dual(object(M)))[1]
-    N, inclusion = spin_submodule(left_module(M), f) 
+    N, inclusion = spin_submodule(transposed_module(M), f) 
 
     if !is_invertible(inclusion) && int_dim(End(N)) != 0
-        N = right_module(N)
+        N = transposed_module(N)
         return false, N, morphism(N,M,right_inverse(dual(inclusion)))
     end
 

src/TensorCategoryFramework/InternalModules/ModuleCategories.jl

@@ -1267,9 +1267,18 @@ end
 ----------------------------------------------------------=#
 
 function is_isomorphic(M::ModuleObject, N::ModuleObject)
+    if !is_isomorphic(object(M), object(N))[1]
+        return false, nothing
+    end
+    H = Hom(M,N)
+
+    for f ∈ H
+        if is_invertible(f)
+            return true, f
+        end
+    end
     if is_simple(M) && is_simple(N)
-        H = Hom(M,N)
-        return int_dim(H) ≥ 1 ? (true, basis(Hom(M,N))[1]) : (false,nothing)
+        return int_dim(H) ≥ 1 ? (true, basis(H)[1]) : (false,nothing)
     elseif int_dim(End(M)) != int_dim(End(N))
         return false, nothing
     else