         return summands[i].generator
     }
     
-    public func factorize(_ z: FreeModule<A, R>) -> [R] {
-        let n = basis.count
-        let v = transform * Matrix(rows: n, cols: 1, grid: z.factorize(by: basis))
-        
-        return summands.enumerated().map { (i, s) in
-            return s.isFree ? v[i, 0] : v[i, 0] % s.divisor
-        }
-    }
-    
-    public func elementIsZero(_ z: FreeModule<A, R>) -> Bool {
-        return factorize(z).forAll{ $0 == .zero }
-    }
-    
-    public func elementsAreEqual(_ z1: FreeModule<A, R>, _ z2: FreeModule<A, R>) -> Bool {
-        return elementIsZero(z1 - z2)
+    public var freePart: SimpleModuleStructure<A, R> {
+        let indices = (0 ..< summands.count).filter{ i in self[i].isFree }
+        return subSummands(indices: indices)
+    }
+    
+    public var torsionPart: SimpleModuleStructure<A, R> {
+        let indices = (0 ..< summands.count).filter{ i in !self[i].isFree }
+        return subSummands(indices: indices)
     }
     
     public func subSummands(_ indices: Int ...) -> SimpleModuleStructure<A, R> {

// See: https://en.wikipedia.org/wiki/Free_presentation
//      https://en.wikipedia.org/wiki/Structure_theorem_for_finitely_generated_modules_over_a_principal_ideal_domain#Invariant_factor_decomposition

public final class SimpleModuleStructure<A: BasisElementType, R: EuclideanRing>: ModuleStructure<R> {
    public let summands: [Summand]
    
    internal let basis: [A]

        super.init()
    }
    
    public subscript(i: Int) -> Summand {
        return summands[i]
    }
    
    public static var zeroModule: SimpleModuleStructure<A, R> {
