   /// - Postcondition: `self.isSupersetOf(other)`
   mutating func unionInPlace(other: Self)
 
-  /// Remove all elements of `self` that are not also present in
+  /// Removes all elements of `self` that are not also present in
   /// `other`.
   ///
   /// - Equivalent to replacing `self` with `self.intersect(other)`
   /// - Postcondition: `self.isSubsetOf(other)`
   mutating func intersectInPlace(other: Self)
 
-  /// Replace `self` with a set containing all elements contained in
+  /// Replaces `self` with a set containing all elements contained in
   /// either `self` or `other`, but not both.
   ///
   /// - Equivalent to replacing `self` with `self.exclusiveOr(other)`
   mutating func exclusiveOrInPlace(other: Self)  
+
+  //===--- Requirements with default implementations ----------------------===//
+  /// Return true iff `self.intersect(other).isEmpty`.
+  func subtract(other: Self) -> Self
+  /// Return true iff every element of `self` is contained in `other`.
+  func isSubsetOf(other: Self) -> Bool
+  /// Return true iff `self.intersect(other).isEmpty`.
+  func isDisjointWith(other: Self) -> Bool
+  /// Return true iff every element of `other` is contained in `self`.
+  func isSupersetOf(other: Self) -> Bool
+  /// Return true iff `self.contains(e)` is `false` for all `e`.
+  var isEmpty: Bool { get }
+  
+  /// Creates the set containing all elements of `sequence`.
+  init<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)
+
+  /// Removes all elements of `other` from `self`.
+  ///
+  /// - Equivalent to replacing `self` with `self.subtract(other)`.
+  mutating func subtractInPlace(other: Self)
+
+  /// Returns `true` iff `a` subsumes `b`.
+  ///
+  /// - Equivalent to `([a] as Self).isSupersetOf([b])`
+  static func element(a: Element, subsumes b: Element) -> Bool
+
+  /// Returns `true` iff `a` is disjoint with `b`.
+  ///
+  /// Two elements are disjoint when neither one subsumes the other.
+  ///
+  /// - SeeAlso: `Self.element(_, subsumes:_)`
+  static func element(a: Element, isDisjointWith b: Element) -> Bool
+  
 }
 
 /// `SetAlgebraType` requirements for which default implementations

    for e in sequence { insert(e) }
  }

  /// The set containing all elements of the given `arrayLiteral`.
  ///
  /// This initializer allows an array literal containing
  /// `Self.Element` to represent an instance of the set, wherever it

    self.init(arrayLiteral)
  }

  /// Removes all elements of `other` from `self`.
  ///
  /// - Equivalent to replacing `self` with `self.subtract(other)`.
  final
