cantor 1.2.0

data/lib/cantor/universal_set.rb

@@ -0,0 +1,102 @@
+module Cantor
+
+  # @private
+  UniversalSet = Class.new(RelativeComplement) do
+
+    def initialize
+    end
+
+    # @return [UniversalSet]
+    def build
+      self
+    end
+
+    # @return true
+    def include?(object)
+      true
+    end
+
+    # @return false
+    def finite?
+      false
+    end
+
+    # @return Infinity
+    def size
+      1.0 / 0.0
+    end
+
+    # @return false
+    def empty?
+      false
+    end
+
+    # @return [AbstractSet]
+    def replace(other)
+      Cantor.build(other)
+    end
+
+    # @group Set Operations
+    #########################################################################
+
+    # @return NullSet
+    def complement
+      # ¬U = ∅
+      NullSet.build
+    end
+
+    # @return [AbstractSet]
+    def intersection(other)
+      # U & A = A
+      Cantor.build(other)
+    end
+
+    # @return [AbstractSet]
+    def union(other)
+      # U ∪ A = U
+      self
+    end
+
+    # @return [AbstractSet]
+    def symmetric_difference(other)
+      # U ⊖ A = (U ∖ A) ∪ (A ∖ U) = (¬A) ∪ (∅) = ¬A
+      Cantor.complement(other)
+    end
+
+    # @return [AbstractSet]
+    def difference(other)
+      # U ∖ A = ¬A
+      Cantor.complement(other)
+    end
+
+    # @group Set Ordering
+    #########################################################################
+
+    # @return [Boolean]
+    def proper_subset?(other)
+      false
+    end
+
+    # @return [Boolean]
+    def proper_superset?(other)
+      not other.eql?(self)
+    end
+
+    # @return [Boolean]
+    def ==(other)
+      eql?(other)
+    end
+
+    # @group Pretty Printing
+    #########################################################################
+
+    # @return [String]
+    def inspect
+      "UniversalSet"
+    end
+
+    # @endgroup
+    #########################################################################
+  end.new
+
+end

data/spec/examples/absolute_set.example

@@ -0,0 +1,1513 @@
+# encoding: UTF-8
+require "spec_helper"
+
+describe Cantor::AbsoluteSet do
+
+  def mksubset(universe)
+    universe.copy(:mask => rand(2**universe.size))
+  end
+
+  def mksingleton(universe)
+    universe.copy(:mask => (2**(rand(universe.size) + 1) >> 1))
+  end
+
+  def self.items;    %w(a b c d e f g h i j k l m n o p q r s t u v w x y z) end
+  def self.universe; Cantor.absolute(items)                                  end
+  def self.single;   universe.copy(:mask => 0b00000000000000000000000001)    end
+  def self.subset;   universe.copy(:mask => 0b10101010101010101010101010)    end
+  def self.null;     universe.copy(:mask => 0b00000000000000000000000000)    end
+
+  let(:items)    { %w(a b c d e f g h i j k l m n o p q r s t u v w x y z) }
+  let(:universe) { Cantor.absolute(items)                                  }
+  let(:single)   { universe.copy(:mask => 0b00000000000000000000000001)    }
+  let(:subset)   { universe.copy(:mask => 0b10101010101010101010101010)    }
+  let(:null)     { universe.copy(:mask => 0b00000000000000000000000000)    }
+
+  def self.property(*args)
+    # TODO: Use Propr
+    @p ||= Class.new do
+      def check(*args)
+        self
+      end
+    end.new
+  end
+
+  describe "#to_a" do
+    property("|A| == |A.to_a|"){|xs| xs.size == xs.to_a.size }.
+      check(null).
+      check(single).
+      check(subset).
+      check(universe)
+
+    property("x ∉ A => x ∉ A.to_a") do |a, to_a|
+      universe.all? do |x|
+        a.include?(x) or not to_a.include?(x)
+      end
+    end.check { bind(mksubset(universe)) { unit([a, a.to_a]) }}
+
+    property("x ∈ A => x ∈ A.to_a") do |a, to_a|
+      universe.all? do |x|
+        not a.include?(x) or to_a.include?(x)
+      end
+    end.check { bind(mksubset(universe)) { unit([a, a.to_a]) }}
+  end
+
+  describe "#first" do
+    property("{x}.first = x"){|a,x| a.first == x }.
+      check{ bind(mkelement(universe)){|x| unit([universe & [x], x]) }}
+
+    property("A.first ∈ A"){|a| guard(!a.empty?); a.include?(a.first) }.
+      check{|a| mksubset(universe) }
+  end
+
+  describe "#map(&block)" do
+    property("A.map{|a| a } = A"){|s| s.map{|a| a }.should == a }.
+      check(null).
+      check(single).
+      check(subset).
+      check(universe).
+      check{ mksubset(universe) }
+
+    specify "A.map{|a| b } raises an error, given b ∉ U and A ≠ ∅" do
+      expect { single.map{|a| "A" }}.to \
+        raise_error(/universe does not contain element/)
+
+      expect { subset.map{|a| "A" }}.to \
+        raise_error(/universe does not contain element/)
+
+      expect { universe.map{|a| "A" }}.to \
+        raise_error(/universe does not contain element/)
+    end
+
+    property("A.map{|a| b } = {b}, given b ∈ U, A ≠ ∅") do |xs, x|
+      xs.map{|a| x } == [x]
+    end.
+      check(single, "a").
+      check(subset, subset.first).
+      check(universe, "z").
+      check{ bind(mksubset(universe)){|xs| bind(mkelement(xs)) {|x| unit [xs, x] }}}
+  end
+
+  describe "#select(&block)" do
+    property("A.select{|a| true } = A"){|xs| xs.select{|a| true } == xs }.
+      check(null).
+      check(single).
+      check(subset).
+      check(universe).
+      check{ mksubset(universe) }
+
+    property("A.select{|a| false } = ∅"){|xs| xs.select{|a| false } == null }.
+      check(null).
+      check(single).
+      check(subset).
+      check(universe).
+      check{ mksubset(universe) }
+
+    property("A.select{|a| a == b } = {b}, given b ∈ U, A ≠ ∅") do |xs, x|
+      guard(!xs.empty?)
+      xs.select{|a| a == x } == [x]
+    end.
+      check(single).
+      check(subset).
+      check(universe).
+      check{ bind(mksubset(universe)){|xs| bind(mkelement(xs)){|x| unit [xs, x] }}}
+  end
+
+  describe "#reject(&block)" do
+    property("A.reject{|a| false } = A") do |xs|
+      xs.reject{|a| false } == xs
+    end.
+      check(null).
+      check(single).
+      check(subset).
+      check(universe).
+      check{ mksubset(universe) }
+
+    property("A.reject{|a| true } = ∅") do
+      subset.reject{|a| true }.should == null
+    end.
+      check(null).
+      check(single).
+      check(subset).
+      check(universe).
+      check{ mksubset(universe) }
+
+    specify "A.reject{|a| a != b } = {b}, given b ∈ U, A ≠ ∅" do
+    end
+
+    property("A.reject{|a| a != b } = {b}, given b ∈ U, A ≠ ∅") do |xs, x|
+      guard(!xs.empty?)
+      xs.reject{|a| a != e } == [e]
+    end.
+      check(single).
+      check(subset).
+      check(universe).
+      check{ bind(mksubset(universe)){|xs| bind(mkelement(xs)){|x| unit [xs, x] }}}
+  end
+
+  describe "#include?(element)" do
+    specify "x ∉ ∅, for all x" do
+      null.should_not include("a")
+      null.should_not include("A")
+    end
+
+    specify "x ∉ A, for all x ∉ U" do
+      single.should_not include("A")
+      subset.should_not include("A")
+      universe.should_not include("A")
+    end
+
+    specify "x ∈ {x}, for all x" do
+      single.should include("a")
+    end
+
+    property("x ∈ {x}, for all x") do
+      mksingleton(universe)
+    end.check do |singleton|
+      singleton.should include(singleton.first)
+    end
+
+    property("x ∉ A, for all x ∈ ¬A") do
+      mksubset(universe)
+    end.check do |a|
+      (~a).each{|e| a.should_not include(e) }
+    end
+  end
+
+  describe "#finite?" do
+    it "is true" do
+      null.should be_finite
+      single.should be_finite
+      subset.should be_finite
+      universe.should be_finite
+    end
+  end
+
+  describe "#empty?" do
+    specify "∅.empty? is true" do
+      null.should be_empty
+    end
+
+    specify "{x}.empty? is false" do
+      single.should_not be_empty
+    end
+  end
+
+  describe "#size" do
+    specify "∅.size == 0" do
+      null.size == 0
+    end
+
+    specify "{x}.size == 1" do
+      single.size.should == 1
+    end
+  end
+
+  describe "#complement" do
+    specify "A ∩ ¬A = ∅" do
+      (null & ~null).should == null
+      (single & ~single).should == null
+      (subset & ~subset).should == null
+      (universe & ~universe).should == null
+    end
+
+    property("A ∩ ¬A = ∅") do
+      mksubset(universe)
+    end.check do |a|
+      (a & ~a).should == null
+    end
+
+    specify "A ∪ ¬A = U" do
+      (null | ~null).should == universe
+      (single | ~single).should == universe
+      (subset | ~subset).should == universe
+      (universe | ~universe).should == universe
+    end
+
+    property("A ∪ ¬A = U") do
+      mksubset(universe)
+    end.check do |a|
+      (a | ~a).should == universe
+    end
+
+    specify "A ⊖ ¬A = U" do
+      (null ^ ~null).should == universe
+      (single ^ ~single).should == universe
+      (subset ^ ~subset).should == universe
+      (universe ^ ~universe).should == universe
+    end
+
+    property("A ⊖ ¬A = U") do
+      mksubset(universe)
+    end.check do |a|
+      (a ^ ~a).should == universe
+    end
+
+    specify "A ∖ ¬A = A" do
+      (null - ~null).should == null
+      (single - ~single).should == single
+      (subset - ~subset).should == subset
+      (universe - ~universe).should == universe
+    end
+
+    property("A ∖ ¬A = A") do
+      mksubset(universe)
+    end.check do |a|
+      (a - ~a).should == a
+    end
+
+    specify "x ∉ ¬A, for all x ∉ U" do
+      (~null).should_not include("A")
+      (~single).should_not include("A")
+      (~subset).should_not include("A")
+      (~universe).should_not include("A")
+    end
+
+    property("x ∈ ¬A, for all x ∈ U and x ∉ A") do
+      mksubset(universe)
+    end.check do |a|
+      (~a).each{|e| a.should_not include(e) }
+    end
+
+    property("x ∉ ¬A, for all x ∈ U and x ∈ A") do
+      mksubset(universe)
+    end.check do |a|
+      a.each{|e| (~a).should_not include(e) }
+    end
+
+    specify "¬U = ∅" do
+      (~universe).should == null
+    end
+
+    specify "¬∅ = U" do
+      (~null).should == universe
+    end
+
+    # Identity
+    specify "¬(¬A) = A" do
+      (~(~null)).should == null
+      (~(~single)).should == single
+      (~(~subset)).should == subset
+      (~(~universe)).should == universe
+    end
+
+    property("¬(¬A) = A") do
+      mksubset(universe)
+    end.check do |a|
+      (~(~a)).should == a
+    end
+
+    # De Morgan's Laws
+    property("¬(A ∪ B) = ¬A ∩ ¬B") do
+      [mksubset(universe), mksubset(universe)]
+    end.check do |a, b|
+      (~(a | b)).should == (~a & ~b)
+    end
+
+    property("¬(A ∩ B) = ¬A ∪ ¬B") do
+      [mksubset(universe), mksubset(universe)]
+    end.check do |a, b|
+      (~(a & b)).should == (~a | ~b)
+    end
+
+    # Uniqueness of Complements
+    property("B = ¬A, given A ∪ B = U and A ∩ B = ∅") do
+      # Create a smaller universe, because the chances of choosing
+      # two random subsets from 2**26 possible, that happen to be
+      # disjoint is very small.
+      universe = Cantor.absolute(%w(a b c d e f))
+
+      a = mksubset(universe)
+      b = mksubset(universe)
+
+      guard(a | b == universe)
+      guard(a & b == null)
+
+      [a, b]
+    end.check(2, 500) do |a, b|
+      b.should == ~a
+    end
+  end
+
+  describe "#union(other)" do
+    property("x ∈ A ∪ B, for all x ∈ A") do
+      a = mksubset(universe)
+      b = mksubset(universe)
+      [a, b, (a | b)]
+    end.check do |a, b, union|
+      a.each{|x| union.should include(x) }
+    end
+
+    property("x ∈ A ∪ B, for all x ∈ B") do
+      a = mksubset(universe)
+      b = mksubset(universe)
+      [a, b, (a | b)]
+    end.check do |a, b, union|
+      b.each{|x| union.should include(x) }
+    end
+
+    property("x ∉ A ∪ B, for all x ∉ A and x ∉ B") do
+      a = mksubset(universe)
+      b = mksubset(universe)
+      [a, b, (a | b)]
+    end.check do |a, b, union|
+      universe.each do |x|
+        unless a.include?(x) or b.include?(x)
+          union.should_not include(x)
+        end
+      end
+    end
+
+    property("A ∪ B = A, given B ⊂ A") do
+      # Create a smaller universe, because the chances of choosing
+      # two random subsets from 2**26 possible, that happen to be
+      # subsets of each other is very small.
+      universe = Cantor.absolute(%w(a b c d e f))
+
+      a = mksubset(universe)
+      b = mksubset(universe)
+      guard(b < a)
+
+      [a, b]
+    end.check do |a, b|
+      (a | b).should == a
+    end
+
+    property("A ∪ B = B, given B ⊃ A") do
+      # Create a smaller universe, because the chances of choosing
+      # two random subsets from 2**26 possible, that happen to be
+      # subsets of each other is very small.
+      universe = Cantor.absolute(%w(a b c d e f))
+
+      a = mksubset(universe)
+      b = mksubset(universe)
+      guard(b > a)
+
+      [a, b]
+    end.check do |a, b|
+      (a | b).should == b
+    end
+
+    property("A ∪ B ⊇ A") do
+      [mksubset(universe), mksubset(universe)]
+    end.check do |a, b|
+      (a | b).should >= a
+    end
+
+    property("A ∪ B ⊇ B") do
+      [mksubset(universe), mksubset(universe)]
+    end.check do |a, b|
+      (a | b).should >= b
+    end
+
+    property("A ∪ B ⊃ A, given A ∩ B = ∅") do
+      # Create a smaller universe, because the chances of choosing
+      # two random subsets from 2**26 possible, that happen to be
+      # disjoint is very small.
+      universe = Cantor.absolute(%w(a b c d e f))
+
+      a = mksubset(universe)
+      b = mksubset(universe)
+      guard(b & a == null)
+
+      [a, b]
+    end.check do |a, b|
+      (a | b) > a
+    end
+
+    # Absorption
+    property("A ∪ (A ∩ B) = A") do
+      [mksubset(universe), mksubset(universe)]
+    end.check do |a, b|
+      (a | (a & b)).should == a
+    end
+
+    # Idempotent
+    specify "A ∪ A = A" do
+      (null + null).should == null
+      (single + single).should == single
+      (subset + subset).should == subset
+      (universe + universe).should == universe
+    end
+
+    # Domination
+    specify "A ∪ U = U" do
+      (null + universe).should == universe
+      (single + universe).should == universe
+      (subset + universe).should == universe
+      (universe + universe).should == universe
+    end
+
+    # Complement
+    specify "A ∪ ¬A = U" do
+      (null | ~null).should == universe
+      (single | ~single).should == universe
+      (subset | ~subset).should == universe
+      (universe | ~universe).should == universe
+    end
+
+    # Identity
+    specify "A ∪ ∅ = A" do
+      (null + null).should == null
+      (single + null).should == single
+      (subset + null).should == subset
+      (universe + null).should == universe
+    end
+
+    # Distributive
+    property("A ∪ (B ∩ C) = (A ∪ B) ∩ (A ∪ C)") do
+      [mksubset(universe), mksubset(universe), mksubset(universe)]
+    end.check do |a, b, c|
+      (a | (b & c)).should == ((a | b) & (a | c))
+    end
+
+    # Commutative
+    property("A ∪ B = B ∪ A") do
+      [mksubset(universe), mksubset(universe)]
+    end.check do |a, b|
+      (a | b).should == (b | a)
+    end
+
+    # Associative
+    property("(A ∪ B) ∪ C = A ∪ (B ∪ C)") do
+      [mksubset(universe), mksubset(universe), mksubset(universe)]
+    end.check do |a, b, c|
+      ((a | b) | c).should == (a | (b | c))
+    end
+
+    context "if B is a RelativeSet" do
+      context "and B ⊆ U" do
+        property("then A ∪ B = A ∪ Cantor.absolute(B, U)") do
+          [mksubset(universe), mksubset(universe)]
+        end.check do |a, b|
+          r = Cantor.build(b.to_a)
+
+          (a | b).should == (a | r)
+          (a | r).should == (a | b)
+          (a | r).should be_a(Cantor::AbsoluteSet)
+        end
+      end
+
+      context "and B ⊈ U" do
+        property("then A ∪ B raises an error") do
+          a = mksubset(universe)
+          b = mksubset(Cantor.absolute(universe.to_a + universe.to_a.map(&:upcase)))
+          [a, b]
+        end.check do |a, b|
+          r = Cantor.build(b.to_a)
+
+          lambda { a | r }.should \
+            raise_error(/universe does not contain/)
+        end
+      end
+    end
+
+    context "if B is a RelativeComplement" do
+      context "and ¬B ⊆ U" do
+        property("then A ∪ B = B ∪ A") do
+          a = mksubset(universe)
+          b = mksubset(universe)
+
+          [a, Cantor.complement(b.to_a)]
+        end.check do |a, b|
+          (a | b).should == b | a
+          (a | b).should be_a(Cantor::RelativeComplement)
+        end
+      end
+
+      context "and ¬B ⊈ U" do
+        property("then A ∪ B = B ∪ A") do
+          a = mksubset(universe)
+          b = mksubset(Cantor.absolute(universe.to_a + universe.to_a.map(&:upcase)))
+
+          [a, Cantor.complement(b.to_a)]
+        end.check do |a, b|
+          (a | b).should == b | a
+          (a | b).should be_a(Cantor::RelativeComplement)
+        end
+      end
+    end
+
+    context "if B is an Array" do
+      context "and B ⊆ U" do
+        property("then A ∪ B = A ∪ Cantor.absolute(B, U)") do
+          [mksubset(universe), mksubset(universe)]
+        end.check do |a, b|
+          r = b.to_a
+
+          (a | b).should == (a | r)
+          (a | r).should == (a | b)
+          (a | r).should be_a(Cantor::AbsoluteSet)
+        end
+      end
+
+      context "and B ⊈ U" do
+        property("then A ∪ B raises an error") do
+          a = mksubset(universe)
+          b = mksubset(Cantor.absolute(universe.to_a + universe.to_a.map(&:upcase)))
+          [a, b]
+        end.check do |a, b|
+          r = b.to_a
+
+          lambda { a | r }.should \
+            raise_error(/universe does not contain/)
+        end
+      end
+    end
+  end
+
+  describe "#intersection(other)" do
+    property("x ∈ A ∩ B, for all x ∈ A and x ∈ B") do
+      a = mksubset(universe)
+      b = mksubset(universe)
+      [a, b, (a & b)]
+    end.check do |a, b, intersection|
+      a.each do |x|
+        if b.include?(x)
+          intersection.should include(x)
+        end
+      end
+    end
+
+    property("x ∉ A ∩ B, for all x ∉ A") do
+      a = mksubset(universe)
+      b = mksubset(universe)
+      [a, b, (a & b)]
+    end.check do |a, b, intersection|
+      universe.each do |x|
+        unless a.include?(x)
+          intersection.should_not include(x)
+        end
+      end
+    end
+
+    property("x ∉ A ∩ B, for all x ∉ B") do
+      a = mksubset(universe)
+      b = mksubset(universe)
+      [a, b, (a & b)]
+    end.check do |a, b, intersection|
+      universe.each do |x|
+        unless b.include?(x)
+          intersection.should_not include(x)
+        end
+      end
+    end
+
+    specify "A ∩ U = A" do
+      (null & universe).should == null
+      (single & universe).should == single
+      (subset & universe).should == subset
+      (universe & universe).should == universe
+    end
+
+    property("A ∩ B = A, given B ⊇ A") do
+      # Create a smaller universe, because the chances of choosing
+      # two random subsets from 2**26 possible, that happen to be
+      # subsets of each other is very small.
+      universe = Cantor.absolute(%w(a b c d e f))
+
+      a = mksubset(universe)
+      b = mksubset(universe)
+      guard(b >= a)
+
+      [a, b]
+    end.check do |a, b|
+      (a & b).should == a
+    end
+
+    property("A ∩ B = B, given B ⊆ A") do
+      # Create a smaller universe, because the chances of choosing
+      # two random subsets from 2**26 possible, that happen to be
+      # subsets of each other is very small.
+      universe = Cantor.absolute(%w(a b c d e f))
+
+      a = mksubset(universe)
+      b = mksubset(universe)
+      guard(b <= a)
+
+      [a, b]
+    end.check do |a, b|
+      (a & b).should == b
+    end
+
+    # Absorption
+    property("A ∩ (A ∪ B) = A") do
+      [mksubset(universe), mksubset(universe)]
+    end.check do |a, b|
+      (a & (a | b)).should == a
+    end
+
+    # Idempotent
+    specify "A ∩ A = A" do
+      (null & null).should == null
+      (single & single).should == single
+      (subset & subset).should == subset
+      (universe & universe).should == universe
+    end
+
+    # Domination
+    specify "A ∩ ∅ = ∅" do
+      (null & null).should == null
+      (single & null).should == null
+      (subset & null).should == null
+      (universe & null).should == null
+    end
+
+    # Complement
+    specify "A ∩ ¬A = ∅" do
+      (null & ~null).should == null
+      (single & ~single).should == null
+      (subset & ~subset).should == null
+      (universe & ~universe).should == null
+    end
+
+    # Distributive
+    property("A ∩ (B ∪ C) = (A ∩ B) ∪ (A ∩ C)") do
+      [mksubset(universe), mksubset(universe), mksubset(universe)]
+    end.check do |a, b, c|
+      (a & (b | c)).should == ((a & b) | (a & c))
+    end
+
+    # Commutative
+    property("A ∩ B = B ∩ A") do
+      [mksubset(universe), mksubset(universe)]
+    end.check do |a, b|
+      (a & b).should == (b & a)
+    end
+
+    # Associative
+    property("(A ∩ B) ∩ C = A ∩ (B ∩ C)") do
+      [mksubset(universe), mksubset(universe), mksubset(universe)]
+    end.check do |a, b, c|
+      ((a & b) & c).should == (a & (b & c))
+    end
+
+    context "if B is a RelativeSet" do
+      context "and B ⊆ U" do
+        property("then A ∩ B = A ∩ Cantor.absolute(B, U)") do
+          [mksubset(universe), mksubset(universe)]
+        end.check do |a, b|
+          r = Cantor.build(b.to_a)
+
+          (a & b).should == (a & r)
+          (a & r).should == (a & b)
+          (a & r).should be_a(Cantor::AbsoluteSet)
+        end
+      end
+
+      context "and B ⊈ U" do
+        property("then A ∩ B = A ∩ Cantor.absolute(B ∩ U, U)") do
+          a = mksubset(universe)
+          b = mksubset(Cantor.absolute(universe.to_a + universe.to_a.map(&:upcase)))
+          [a, b]
+        end.check do |a, b|
+          r = Cantor.build(b.to_a)                # B
+          b = universe.select{|x| b.include?(x) } # B ∩ U
+
+          (a & b).should == (a & r)
+          (a & r).should == (a & b)
+          (a & r).should be_a(Cantor::AbsoluteSet)
+        end
+      end
+    end
+
+    context "if B is a RelativeComplement" do
+      context "and ¬B ⊆ U" do
+        property("then A ∩ B = B ∩ A") do
+          a = mksubset(universe)
+          b = mksubset(universe)
+
+          [a, Cantor.complement(b.to_a)]
+        end.check do |a, b|
+          (a & b).should == b & a
+          (a & b).should be_a(Cantor::AbsoluteSet)
+        end
+      end
+
+      context "and ¬B ⊈ U" do
+        property("then A ∩ B = B ∩ A") do
+          a = mksubset(universe)
+          b = mksubset(Cantor.absolute(universe.to_a + universe.to_a.map(&:upcase)))
+
+          [a, Cantor.complement(b.to_a)]
+        end.check do |a, b|
+          (a & b).should == b & a
+          (a & b).should be_a(Cantor::AbsoluteSet)
+        end
+      end
+    end
+
+    context "if B is an Array" do
+      context "and B ⊆ U" do
+        property("then A ∩ B = A ∩ Cantor.absolute(B, U)") do
+          [mksubset(universe), mksubset(universe)]
+        end.check do |a, b|
+          r = b.to_a
+
+          (a & b).should == (a & r)
+          (a & r).should == (a & b)
+          (a & r).should be_a(Cantor::AbsoluteSet)
+        end
+      end
+
+      context "and B ⊈ U" do
+        property("then A ∩ B = A ∩ Cantor.absolute(B ∩ U, U)") do
+          a = mksubset(universe)
+          b = mksubset(Cantor.absolute(universe.to_a + universe.to_a.map(&:upcase)))
+          [a, b]
+        end.check do |a, b|
+          r = b.to_a                              # B
+          b = universe.select{|x| b.include?(x) } # B ∩ U
+
+          (a & b).should == (a & r)
+          (a & r).should == (a & b)
+          (a & r).should be_a(Cantor::AbsoluteSet)
+        end
+      end
+    end
+  end
+
+  describe "#difference(other)" do
+    property("x ∈ A ∖ B, for all x ∈ A and x ∉ B") do
+      a = mksubset(universe)
+      b = mksubset(universe)
+      [a, b, (a - b)]
+    end.check do |a, b, difference|
+      a.each do |x|
+        unless b.include?(x)
+          difference.should include(x)
+        end
+      end
+    end
+
+    property("x ∉ A ∖ B, for all x ∉ A") do
+      a = mksubset(universe)
+      b = mksubset(universe)
+      [a, b, (a - b)]
+    end.check do |a, b, difference|
+      universe.each do |x|
+        unless a.include?(x)
+          difference.should_not include(x)
+        end
+      end
+    end
+
+    property("x ∉ A ∖ B, for all x ∈ B") do
+      a = mksubset(universe)
+      b = mksubset(universe)
+      [a, b, (a - b)]
+    end.check do |a, b, difference|
+      b.each do |x|
+        difference.include?(x).should be_false
+      end
+    end
+
+    specify "U ∖ A = ¬A" do
+      (universe - null).should == ~null
+      (universe - single).should == ~single
+      (universe - subset).should == ~subset
+      (universe - universe).should == ~universe
+    end
+
+    specify "∅ ∖ A = ∅" do
+      (null - null).should == null
+      (null - single).should == null
+      (null - subset).should == null
+      (null - universe).should == null
+    end
+
+    specify "A ∖ A = ∅" do
+      (null - null).should == null
+      (single - single).should == null
+      (subset - subset).should == null
+      (universe - universe).should == null
+    end
+
+    specify "A ∖ ∅ = A" do
+      (null - null).should == null
+      (single - null).should == single
+      (subset - null).should == subset
+      (universe - null).should == universe
+    end
+
+    specify "A ∖ U = ∅" do
+      (null - universe).should == null
+      (single - universe).should == null
+      (subset - universe).should == null
+      (universe - universe).should == null
+    end
+
+    property("A ∖ B = A, given A ∩ B = ∅")
+
+    property("A ∖ B ⊂ A, given A ∩ B ≠ ∅") do
+      a = mksubset(universe)
+      b = mksubset(universe)
+      guard(a & b != null)
+
+      [a, b]
+    end.check do |a, b|
+      (a - b).should < a
+    end
+
+    property("A ∖ B ≠ B ∖ A, given A ≠ B") do
+      a = mksubset(universe)
+      b = mksubset(universe)
+      guard(a != b)
+
+      [a, b]
+    end.check do |a, b|
+      (a - b).should_not == (b - a)
+    end
+
+    property("C ∖ (A ∩ B) = (C ∖ A) ∪ (C ∖ B)") do
+      [mksubset(universe), mksubset(universe), mksubset(universe)]
+    end.check do |a, b, c|
+      (c - (a & b)).should == ((c - a) | (c - b))
+    end
+
+    property("C ∖ (A ∪ B) = (C ∖ A) ∩ (C ∖ B)") do
+      [mksubset(universe), mksubset(universe), mksubset(universe)]
+    end.check do |a, b, c|
+      (c - (a | b)).should == ((c - a) & (c - b))
+    end
+
+    property("C ∖ (B ∖ A) = (A ∩ C) ∪ (C ∖ B)") do
+      [mksubset(universe), mksubset(universe), mksubset(universe)]
+    end.check do |a, b, c|
+      (c - (b - a)).should == ((a & c) | (c - b))
+    end
+
+  # property("(B ∖ A) ∩ C = (B ∩ C) ∖ A = B ∩ (C ∖ A)") do
+  #   [mksubset(universe), mksubset(universe), mksubset(universe)]
+  # end.check do |a, b, c|
+  # end
+
+    property("(B ∖ A) ∪ C = (B ∪ C) ∖ (A ∖ C)") do
+      [mksubset(universe), mksubset(universe), mksubset(universe)]
+    end.check do |a, b, c|
+      ((b - a) | c).should == ((b | c) - (a - c))
+    end
+
+    property("B ∖ A = ¬A ∩ B") do
+      [mksubset(universe), mksubset(universe)]
+    end.check do |a, b|
+      (b - a).should == (~a & b)
+    end
+
+    property("¬(B ∖ A) = A ∪ ¬B") do
+      [mksubset(universe), mksubset(universe)]
+    end.check do |a, b|
+      (~(b - a)).should == (a | ~b)
+    end
+
+    context "if B is a RelativeSet" do
+      context "and B ⊆ U" do
+        property("then A ∖ B = A ∖ Cantor.absolute(B, U)") do
+          [mksubset(universe), mksubset(universe)]
+        end.check do |a, b|
+          r = Cantor.build(b.to_a)
+
+          (a - b).should == (a - r)
+          (a - r).should == (a - b)
+          (a - r).should be_a(Cantor::AbsoluteSet)
+        end
+      end
+
+      context "and B ⊈ U" do
+        property("then A ∖ B = A ∖ Cantor.absolute(B ∩ U, U)") do
+          a = mksubset(universe)
+          b = mksubset(Cantor.absolute(universe.to_a + universe.to_a.map(&:upcase)))
+          [a, b]
+        end.check do |a, b|
+          r = Cantor.build(b.to_a)                # B
+          b = universe.select{|x| b.include?(x) } # B ∩ U
+
+          (a - b).should == (a - r)
+          (a - r).should == (a - b)
+          (a - r).should be_a(Cantor::AbsoluteSet)
+        end
+      end
+    end
+
+    context "if B is a RelativeComplement" do
+      context "and ¬B ⊆ U" do
+        property("then A ∖ B = A ∩ ¬B") do
+          a = mksubset(universe)
+          b = mksubset(universe)
+
+          [a, Cantor.complement(b.to_a)]
+        end.check do |a, b|
+          (a - b).should == (a & ~b)
+          (a - b).should be_a(Cantor::AbsoluteSet)
+        end
+      end
+
+      context "and ¬B ⊈ U" do
+        property("then A ∖ B = A ∩ ¬B") do
+          a = mksubset(universe)
+          b = mksubset(Cantor.absolute(universe.to_a + universe.to_a.map(&:upcase)))
+
+          [a, Cantor.complement(b.to_a)]
+        end.check do |a, b|
+          (a - b).should == (a & ~b)
+          (a - b).should be_a(Cantor::AbsoluteSet)
+        end
+      end
+    end
+
+    context "if B is an Array" do
+      context "and B ⊆ U" do
+        property("then A ∖ B = A ∖ Cantor.absolute(B, U)") do
+          [mksubset(universe), mksubset(universe)]
+        end.check do |a, b|
+          r = b.to_a
+
+          (a - b).should == (a - r)
+          (a - r).should == (a - b)
+          (a - r).should be_a(Cantor::AbsoluteSet)
+        end
+      end
+
+      context "and B ⊈ U" do
+        property("then A ∖ B = A ∖ Cantor.absolute(B ∩ U, U)") do
+          a = mksubset(universe)
+          b = mksubset(Cantor.absolute(universe.to_a + universe.to_a.map(&:upcase)))
+          [a, b]
+        end.check do |a, b|
+          r = b.to_a                              # B
+          b = universe.select{|x| b.include?(x) } # B ∩ U
+
+          (a - b).should == (a - r)
+          (a - r).should == (a - b)
+          (a - r).should be_a(Cantor::AbsoluteSet)
+        end
+      end
+    end
+  end
+
+  describe "#symmetric_difference(other)" do
+    specify "A ⊖ A = ∅" do
+      (null ^ null).should == null
+      (single ^ single).should == null
+      (subset ^ subset).should == null
+      (universe ^ universe).should == null
+    end
+
+    specify "A ⊖ U = ¬A" do
+      (null ^ universe).should == ~null
+      (single ^ universe).should == ~single
+      (subset ^ universe).should == ~subset
+      (universe ^ universe).should == ~universe
+    end
+
+    specify "A ⊖ ∅ = A" do
+      (null ^ null).should == null
+      (single ^ null).should == single
+      (subset ^ null).should == subset
+      (universe ^ null).should == universe
+    end
+
+    property("A ⊖ B = (A ∖ B) ∪ (B ∖ A)") do
+      [mksubset(universe), mksubset(universe)]
+    end.check do |a, b|
+      (a ^ b).should == ((a - b) | (b - a))
+    end
+
+    property("A ⊖ B = (A ∪ B) ∖ (A ∩ B)") do
+      [mksubset(universe), mksubset(universe)]
+    end.check do |a, b|
+      (a ^ b).should == ((a | b) - (a & b))
+    end
+
+    property("A ⊖ B = B ⊖ A") do
+      [mksubset(universe), mksubset(universe)]
+    end.check do |a, b|
+      (a ^ b).should == (b ^ a)
+    end
+
+    property("(A ⊖ B) ⊖ C = A ⊖ (B ⊖ C)") do
+      [mksubset(universe), mksubset(universe), mksubset(universe)]
+    end.check do |a, b, c|
+      ((a ^ b) ^ c).should == (a ^ (b ^ c))
+    end
+
+    property("(A ⊖ B) ⊖ (B ⊖ C) = A ⊖ C") do
+      [mksubset(universe), mksubset(universe), mksubset(universe)]
+    end.check do |a, b, c|
+      ((a ^ b) ^ (b ^ c)).should == (a ^ c)
+    end
+
+    property("A ∩ (B ⊖ C) = (A ∩ B) ⊖ (A ∩ C)") do
+      [mksubset(universe), mksubset(universe), mksubset(universe)]
+    end.check do |a, b, c|
+      (a & (b ^ c)).should == ((a & b) ^ (a & c))
+    end
+
+    context "if B is a RelativeSet" do
+      context "and B ⊆ U" do
+        property("then A ⊖ B = A ⊖ Cantor.absolute(B, U)") do
+          [mksubset(universe), mksubset(universe)]
+        end.check do |a, b|
+          r = Cantor.build(b.to_a)
+
+          (a ^ b).should == (a ^ r)
+          (a ^ r).should == (a ^ b)
+          (a ^ r).should be_a(Cantor::AbsoluteSet)
+        end
+      end
+
+      context "and B ⊈ U" do
+        property("then A ⊖ B raises an error") do
+          a = mksubset(universe)
+          b = mksubset(Cantor.absolute(universe.to_a + universe.to_a.map(&:upcase)))
+          [a, b]
+        end.check do |a, b|
+          r = Cantor.build(b.to_a)
+
+          lambda { a ^ r }.should \
+            raise_error(/universe does not contain/)
+        end
+      end
+    end
+
+    context "if B is a RelativeComplement" do
+      context "and ¬B ⊆ U" do
+        property("then A ⊖ B = B ⊖ A") do
+          a = mksubset(universe)
+          b = mksubset(universe)
+
+          [a, Cantor.complement(b.to_a)]
+        end.check do |a, b|
+          (a ^ b).should == b ^ a
+          (a ^ b).should be_a(Cantor::AbsoluteSet)
+        end
+      end
+
+      context "and ¬B ⊈ U" do
+        property("then A ⊖ B = B ⊖ A") do
+          a = mksubset(universe)
+          b = mksubset(Cantor.absolute(universe.to_a + universe.to_a.map(&:upcase)))
+
+          [a, Cantor.complement(b.to_a)]
+        end.check do |a, b|
+          (a ^ b).should == b ^ a
+          (a ^ b).should be_a(Cantor::AbsoluteSet)
+        end
+      end
+    end
+
+    context "if B is an Array" do
+      context "and B ⊆ U" do
+        property("then A ⊖ B = A ⊖ Cantor.absolute(B, U)") do
+          [mksubset(universe), mksubset(universe)]
+        end.check do |a, b|
+          r = b.to_a
+
+          (a ^ b).should == (a ^ r)
+          (a ^ r).should == (a ^ b)
+          (a ^ r).should be_a(Cantor::AbsoluteSet)
+        end
+      end
+
+      context "and B ⊈ U" do
+        property("then A ⊖ B raises an error") do
+          a = mksubset(universe)
+          b = mksubset(Cantor.absolute(universe.to_a + universe.to_a.map(&:upcase)))
+          [a, b]
+        end.check do |a, b|
+          r = b.to_a
+
+          lambda { a ^ r }.should \
+            raise_error(/universe does not contain/)
+        end
+      end
+    end
+  end
+
+  describe "#subset?(other)" do
+    # Reflexivity
+    specify "A ⊆ A" do
+      null.should <= null
+      single.should <= single
+      subset.should <= subset
+      universe.should <= universe
+    end
+
+    # Antisymmetry
+    property("A ⊆ B and B ⊆ A, given A = B") do
+      universe = Cantor.absolute(%w(a b c d e f))
+
+      a = mksubset(universe)
+      b = mksubset(universe)
+      guard(a == b)
+
+      [a, b]
+    end.check(5, 200) do |a, b|
+      a.should <= b
+      b.should <= a
+    end
+
+    property("A = B, given A ⊆ B and B ⊆ A") do
+      universe = Cantor.absolute(%w(a b c d e f))
+
+      a = mksubset(universe)
+      b = mksubset(universe)
+      guard(a <= b)
+      guard(b <= a)
+
+      [a, b]
+    end.check(5, 200) do |a, b|
+      a.should == b
+    end
+
+    # Transitivity
+    property("A ⊆ C, given A ⊆ B and B ⊆ C") do
+      universe = Cantor.absolute(%w(a b c d e f))
+
+      a = mksubset(universe)
+      b = mksubset(universe)
+      c = mksubset(universe)
+      guard(a <= b)
+      guard(b <= c)
+
+      [a, b, c]
+    end.check(5, 200) do |a, b, c|
+      a.should <= c
+    end
+
+    # Existence of a Least Element
+    specify "∅ ⊆ A" do
+      null.should <= null
+      null.should <= single
+      null.should <= subset
+      null.should <= universe
+    end
+
+    # Existence of a Greatest Element
+    specify "A ⊆ U" do
+      null.should <= universe
+      single.should <= universe
+      subset.should <= universe
+      universe.should <= universe
+    end
+
+    # Existence of Joins
+    property("A ⊆ A ∪ B") do
+      [mksubset(universe), mksubset(universe)]
+    end.check do |a, b|
+      a.should <= (a | b)
+    end
+
+    # Existence of meets
+    property("A ∪ B ⊇ C, given C ⊆ A and C ⊆ B") do
+      universe = Cantor.absolute(%w(a b c d e f))
+
+      a = mksubset(universe)
+      b = mksubset(universe)
+      c = mksubset(universe)
+      guard(c <= a)
+      guard(c <= b)
+
+      [a, b, c]
+    end.check(5, 200) do |a, b, c|
+      (a | b).should >= c
+    end
+
+    # Equivalent Statements
+    property("A ⊆ B => ...") do
+      [mksubset(universe), mksubset(universe)]
+    end.check do |a, b|
+      if a <= b
+        (a & b).should == a
+        (a | b).should == b
+        (a - b).should == null
+        (~b).should <= (~a)
+      end
+    end
+
+    # Equivalent Statements
+    property("A ∩ B = A => ...") do
+      [mksubset(universe), mksubset(universe)]
+    end.check do |a, b|
+      if (a & b) == a
+        a.should <= b
+        (a | b).should == b
+        (a - b).should == null
+        (~b).should <= (~a)
+      end
+    end
+
+    # Equivalent Statements
+    property("A ∪ B = B => ...") do
+      [mksubset(universe), mksubset(universe)]
+    end.check do |a, b|
+      if (a | b) == b
+        a.should <= b
+        (a & b).should == a
+        (a - b).should == null
+        (~b).should <= (~a)
+      end
+    end
+
+    # Equivalent Statements
+    property("A ∖ B = ∅ => ...") do
+      [mksubset(universe), mksubset(universe)]
+    end.check do |a, b|
+      if (a - b) == null
+        a.should <= b
+        (a & b).should == a
+        (a | b).should == b
+        (~b).should <= (~a)
+      end
+    end
+
+    # Equivalent Statements
+    property("¬B ⊆ ¬A => ...") do
+      [mksubset(universe), mksubset(universe)]
+    end.check do |a, b|
+      if (~b) <= (~a)
+        a.should <= b
+        (a & b).should == a
+        (a | b).should == b
+        (a - b).should == null
+      end
+    end
+
+    context "if B is a RelativeSet" do
+      context "and B ⊆ U" do
+        property("then A ⊆ B = A ⊆ Cantor.absolute(B, U)") do
+          [mksubset(universe), mksubset(universe)]
+        end.check do |a, b|
+          r = Cantor.build(b.to_a)
+          (a <= b).should == (a <= r)
+        end
+      end
+
+      context "and B ⊈ U" do
+        property("then A ⊈ B = A ⊆ Cantor.absolute(B ∩ U, U)") do
+          a = mksubset(universe)
+          b = mksubset(Cantor.absolute(universe.to_a + universe.to_a.map(&:upcase)))
+          [a, b]
+        end.check do |a, b|
+          r = Cantor.build(b.to_a)                # B
+          b = universe.select{|x| b.include?(x) } # B ∩ U
+          (a <= b).should == (a <= r)
+        end
+      end
+    end
+
+    context "if B is a RelativeComplement(C)" do
+      context "and C ⊆ U" do
+        property("then A ⊆ ¬C ≡ A ∩ C = ∅") do
+          [mksubset(universe), mksubset(universe)]
+        end.check do |a, c|
+          b = Cantor.complement(c.to_a)
+          (a <= b).should == ((a & c) == null)
+        end
+      end
+
+      context "and C ⊈ U" do
+        property("then A ⊆ ¬C ≡ A ∩ C = ∅") do
+          a = mksubset(universe)
+          c = mksubset(Cantor.absolute(universe.to_a + universe.to_a.map(&:upcase)))
+          [a, c]
+        end.check do |a, c|
+          b = Cantor.complement(c.to_a)
+          (a <= b).should == ((a & c) == null)
+        end
+      end
+    end
+
+    context "when B is an Array" do
+      context "and B ⊆ U" do
+        property("then A ⊆ B = A ⊆ Cantor.absolute(B, U)") do
+          [mksubset(universe), mksubset(universe)]
+        end.check do |a, b|
+          r = b.to_a
+          (a <= b).should == (a <= r)
+        end
+      end
+
+      context "and B ⊈ U" do
+        property("then A ⊆ B = A ⊆ Cantor.absolute(B ∩ U, U)") do
+          a = mksubset(universe)
+          b = mksubset(Cantor.absolute(universe.to_a + universe.to_a.map(&:upcase)))
+          [a, b]
+        end.check do |a, b|
+          r = b.to_a                              # B
+          b = universe.select{|x| b.include?(x) } # B ∩ U
+
+          (a <= b).should == (a <= r)
+        end
+      end
+    end
+  end
+
+  describe "#==(other)" do
+    # Reflexive
+    specify "A = A" do
+      null.should == null
+      single.should == single
+      subset.should == subset
+      universe.should == universe
+    end
+
+    # Symmetric
+    property("if A = B then B = A") do
+      universe = Cantor.absolute(%w(a b c d e f))
+      [mksubset(universe), mksubset(universe)]
+    end.check do |a, b|
+      if a == b
+        b.should == a
+      end
+    end
+
+    # Transitive
+    property("if A = B and B = C then A = C") do
+      universe = Cantor.absolute(%w(a b c d e f))
+      [mksubset(universe), mksubset(universe), mksubset(universe)]
+    end.check do |a, b, c|
+      if a == b and b == c
+        a.should == c
+      end
+    end
+
+    context "if B is a RelativeSet" do
+      context "and B ⊆ U" do
+        property("then A = B ≡ A = Cantor.absolute(B, U)") do
+          [mksubset(universe), mksubset(universe)]
+        end.check do |a, b|
+          r = Cantor.build(b.to_a)
+          (a == b).should == (a == r)
+        end
+      end
+
+      context "and B ⊈ U" do
+        property("then A = B ≡ A = Cantor.absolute(B ∩ U, U)") do
+          a = mksubset(universe)
+          b = mksubset(Cantor.absolute(universe.to_a + universe.to_a.map(&:upcase)))
+          [a, b]
+        end.check do |a, b|
+          r = Cantor.build(b.to_a)                # B
+          b = universe.select{|x| b.include?(x) } # B ∩ U
+          (a == b).should == (a == r)
+        end
+      end
+    end
+
+    context "if B is a RelativeComplement" do
+      context "and ¬B ⊆ U" do
+        property("then A = B ≡ B = A") do
+          a = mksubset(universe)
+          b = mksubset(universe)
+
+          [a, Cantor.complement(b.to_a)]
+        end.check do |a, b|
+          (a == b).should == (b == a)
+        end
+      end
+
+      context "and ¬B ⊈ U" do
+        property("then A = B ≡ B = A") do
+          a = mksubset(universe)
+          b = mksubset(Cantor.absolute(universe.to_a + universe.to_a.map(&:upcase)))
+
+          [a, Cantor.complement(b.to_a)]
+        end.check do |a, b|
+          (a == b).should == (b == a)
+        end
+      end
+    end
+
+    context "if B is an Array" do
+      context "and B ⊆ U" do
+        property("then A = B ≡ A = Cantor.absolute(B, U)") do
+          [mksubset(universe), mksubset(universe)]
+        end.check do |a, b|
+          r = b.to_a
+          (a == b).should == (a == r)
+        end
+      end
+
+      context "and B ⊈ U" do
+        property("then A = B ≡ A = Cantor.absolute(B ∩ U, U)") do
+          a = mksubset(universe)
+          b = mksubset(Cantor.absolute(universe.to_a + universe.to_a.map(&:upcase)))
+          [a, b]
+        end.check do |a, b|
+          r = b.to_a                              # B
+          b = universe.select{|x| b.include?(x) } # B ∩ U
+
+          (a == b).should == (a == r)
+        end
+      end
+    end
+  end
+
+  describe "#replace(other)" do
+    context "if B is an AbsoluteSet" do
+      context "and B.universe = U" do
+        property("then A.replace(B) = B") do
+          [mksubset(universe), mksubset(universe)]
+        end.check do |a, b|
+          a.replace(b).should == b
+        end
+      end
+
+      context "and B.universe ≠ U" do
+        property("then A.replace(B) = B") do
+          a = mksubset(universe)
+          b = mksubset(Cantor.absolute(universe.to_a + universe.to_a.map(&:upcase)))
+          [a, b]
+        end.check do |a, b|
+          a.replace(b).should == b
+        end
+      end
+    end
+
+    context "if B is a RelativeSet" do
+      property("then A.replace(B) = B") do
+        a = mksubset(universe)
+        b = mksubset(Cantor.absolute(universe.to_a + universe.to_a.map(&:upcase)))
+        [a, Cantor.build(b.to_a)]
+      end.check do |a, b|
+        a.replace(b).should == b
+      end
+    end
+
+    context "if B is a RelativeComplement" do
+      property("then A.replace(B) = B") do
+        a = mksubset(universe)
+        b = mksubset(Cantor.absolute(universe.to_a + universe.to_a.map(&:upcase)))
+        [a, Cantor.complement(b.to_a)]
+      end.check do |a, b|
+        a.replace(b).should == b
+      end
+    end
+
+    context "if B is an Array" do
+      context "and B ⊆ U" do
+        property("then A.replace(B) ≡ Cantor.absolute(B, U)") do
+          [mksubset(universe), mksubset(universe)]
+        end.check do |a, b|
+          a.replace(b.to_a).should == b
+        end
+      end
+
+      context "and B ⊈ U" do
+        property("then A.replace(B) raises an error") do
+          a = mksubset(universe)
+          b = mksubset(universe)
+          c = mksubset(universe)
+          guard(!c.empty?)
+
+          [a, (b.to_a | c.to_a.map(&:upcase))]
+        end.check do |a, b|
+          lambda { a.replace(b) }.should \
+            raise_error(/universe does not contain/)
+        end
+      end
+    end
+  end
+
+end