             : (bottomDegree ... topDegree).toArray()
     }
     
-    public func isZeroMap(_ i: Int, _ n: Int) -> Bool {
-        return sequence.isZeroMap(seqIndex(i, n))
+    public func isZeroMap(_ n: Int, _ i: Int) -> Bool {
+        return sequence.isZeroMap(seqIndex(n, i))
     }
     
-    public func isInjective(_ i: Int, _ n: Int) -> Bool {
-        return sequence.isInjective(seqIndex(i, n))
+    public func isInjective(_ n: Int, _ i: Int) -> Bool {
+        return sequence.isInjective(seqIndex(n, i))
     }
     
-    public func isSurjective(_ i: Int, _ n: Int) -> Bool {
-        return sequence.isSurjective(seqIndex(i, n))
+    public func isSurjective(_ n: Int, _ i: Int) -> Bool {
+        return sequence.isSurjective(seqIndex(n, i))
     }
     
-    public func isIsomorphic(_ i: Int, _ n: Int) -> Bool {
-        return sequence.isIsomorphic(seqIndex(i, n))
+    public func isIsomorphic(_ n: Int, _ i: Int) -> Bool {
+        return sequence.isIsomorphic(seqIndex(n, i))
     }
 
-    public mutating func fill(column i: Int, degree n: Int) {
+    public mutating func fill(_ n: Int, _ i: Int) {
         assert((0 ..< 3).contains(i))
 
-        let k = seqIndex(i, n)
+        let k = seqIndex(n, i)
         
         sequence[k] = h[i][n]
 

    }
    
    public var description: String {
        return h.map{ $0.description }.joined(separator: "\t->\t")
            + "\n--------------------\n"
            + degrees.map { n -> String in
                "\(n): \t" + (0 ..< 3).map { i in
                    let k = self.seqIndex(i, n)
                    return "\(sequence.objectDescription(k))\t\(sequence.arrowDescription(k))\t"
                }.joined()
              }.joined(separator: "\n")
            + "0"
    }
    
    public var detailDescription: String {
        func s(_ i: Int, _ n: Int) -> String {
            return self[i, n].map{ "\($0)" } ?? "?"
        }
        return "\(self.description)\n--------------------\n"
            + degrees.map { n -> String in
                "\(n): \t" + (0 ..< 3).map{ i in self[i, n].map{ "\($0)" } ?? "?" }.joined(separator: "\t-> ")
                }.joined(separator: "\t->\n")
            + "\t-> 0"
    }
}

    }
    
    @discardableResult
    public mutating func solve(_ n: Int, _ i: Int) -> Object? {
        sequence.solve(seqIndex(n, i))
        return self[n, i]
    }
    
    @discardableResult
    public mutating func solve(column i: Int) -> [Object?] {
        return (bottomDegree ... topDegree).map { n in
            self.solve(n, i)
        }
    }
    
