CSG reference

All possible combinations of two objects in CSG. 
A
 [A] 
not A
 [not A] 
object { A }

object { A inverse }

B
 [B] 
not B
 [not B] 
object { B }

object { B inverse }

A or B
 [A or B] 
A nor B =
not (A or B) =
(not A) and (not B)
 [A nor B] 
union
{ object { A }
  object { B }
}

union
{ object { A }
  object { B }
  inverse
}

intersection
{ object { A inverse }
  object { B inverse }
}

A and B
 [A and B] 
A nand B =
not (A and B) =
(not A) or (not B)
 [A nand B] 
intersection
{ object { A }
  object { B }
}

intersection
{ object { A }
  object { B }
  inverse
}

union
{ object { A inverse }
  object { B inverse }
}

A - B =
A and (not B) =
(not B) - (not A)
 [A-B] 
not (A - B) =
(not A) or B
 [not (A-B)] 
difference
{ object { A }
  object { B }
}

difference
{ object { A }
  object { B }
  inverse
}

intersection
{ object { A }
  object { B inverse }
}

union
{ object { A inverse }
  object { B }
}

difference
{ object { B inverse }
  object { A inverse }
}

B - A =
B and (not A) =
(not A) - (not B)
 [B-A] 
not (B - A) =
A or (not B)
 [not (B-A)] 
difference
{ object { B }
  object { A }
}

difference
{ object { B }
  object { A }
  inverse
}

intersection
{ object { B }
  object { A inverse }
}

union
{ object { A }
  object { B inverse}
}

difference
{ object { A inverse }
  object { B inverse }
}

A xor B =
(A or B) and
(not (A and B)) =
(A or B) and
((not A) or (not B)) =
(A - B) or (B - A)
 [A xor B] 
not (A xor B) =
not ((A or B) and
(not (A and B))) =
(A and B) or
(not (A or B)) =
(A and B) or
((not A) and (not B))
 [not (A xor B)] 
intersection
{ union
  { object { A }
    object { B }
  }
  intersection
  { object { A }
    object { B }
    inverse
  }
}

intersection
{ union
  { object { A }
    object { B }
  }
  intersection
  { object { A }
    object { B }
    inverse
  }
  inverse
}

intersection
{ union
  { object { A }
    object { B }
  }
  union
  { object { A inverse }
    object { B inverse }
  }
}

union
{ intersection
  { object { A }
    object { B }
  }
  union
  { object { A }
    object { B }
    inverse
  }
}

union
{ difference
  { object { A }
    object { B }
  }
  difference
  { object { B }
    object { A }
  }
}

union
{ intersection
  { object { A }
    object { B }
  }
  intersection
  { object { A inverse }
    object { B inverse }
  }
}
Special cases (no reasonable meaning in set theory) 
A or (A and B)
[ = A ]
 [A or (A and B)] 
not (A or (A and B))
[ = not A ]
 [not (A or (A and B))] 
union
{ object { A }
  intersection
  { object { A }
    object { B }
  }
}

union
{ object { A }
  intersection
  { object { A }
    object { B }
  }
  inverse
}

B or (A and B)
[ = B ]
 [B or (A and B)] 
not (B or (A and B))
[ = not B ]
 [not (B or (A and B))] 
union
{ object { B }
  intersection
  { object { A }
    object { B }
  }
}

union
{ object { B }
  intersection
  { object { A }
    object { B }
  }
  inverse
}

merge(A,B) =
not ((not A) and (not B))
[ = A or B ]
 [merge(A,B)] 
merge
{ object { A }
  object { B }
}

intersection
{ object { A inverse }
  object { B inverse }
  inverse
}