     }
     
     public var description: String {
-        return "(\(factors.map{ "\($0)" }.joined(separator: "⊗")))\(Format.sub(state.description))"
+        return "(" + factors.map{ "\($0)" }.joined(separator: "⊗") + ")" + Format.sub(state.description)
     }
     
     enum E: Equatable, Comparable {

public struct KhChainSummand: Equatable, CustomStringConvertible {
    public let link: Link
    public let state: LinkSpliceState
    public let basis: [KhTensorElement]
    public let shifted: Int
    
    public init(link L: Link, state: LinkSpliceState, shifted: Int = 0) {
        let spliced = L.spliced(by: state)
        let basis = KhChainSummand.generate(state: state, power: spliced.components)
        self.init(link: spliced, state: state, basis: basis, shifted: shifted)
    }
    
    internal init(link: Link, state: LinkSpliceState, basis: [KhTensorElement], shifted: Int) {
        self.link = link
        self.state = state
        self.basis = basis
        self.shifted = shifted
    }
    
    public func shift(_ n: Int) -> KhChainSummand {
        return KhChainSummand(link: link, state: state, basis: basis, shifted: shifted + n)
    }
    
    internal static func generate(state: LinkSpliceState, power n: Int) -> [KhTensorElement] {

        static func <(e1: E, e2: E) -> Bool {
            return e1.degree < e2.degree
        }
        
        static func μ(_ e1: E, _ e2: E) -> E? {
            switch (e1, e2) {
            case (.I, .I): return .I
            case (.I, .X), (.X, .I): return .X
            case (.X, .X): return nil
            }
        }
        
        static func Δ(_ e: E) -> [(E, E)] {
            switch e {
            case .I: return [(.I, .X), (.X, .I)]
            case .X: return [(.X, .X)]
            }
        }
    }
}
