+// =============================================================================
+
+// TODO: Anywhere we do simple comparisons for number equality testing, we need
+// to upgrade to dual-LEQ comparisons.
+
+// =============================================================================
+
+type surrealUniverse struct {
+ // TODO: Note that the elements of this array are maintained in order
+ // w.r.t. Axiom 2. Maybe I should just rename number -> numberLine?
+ numbers []surrealNumber
+ nextUniqueID int
+}
+
+func (u *surrealUniverse) getIndex(num surrealNumber) (exists bool, index int) {
+ // TODO: After I implement a LEQ comparison function, the fact that
+ // u.numbers[] is ordered by that comparison will allow me to greatly
+ // shorten the search.
+ for i := 0; i < len(u.numbers); i++ {
+ if num.number == u.numbers[i].number {
+ return true, i
+ }
+ }
+ return false, 0
+}
+
+func (u *surrealUniverse) cardinality() int {
+ return len(u.numbers)
+}
+
+func (u *surrealUniverse) insert(num surrealNumber) {
+ exists, _ := u.getIndex(num)
+ if !exists {
+ num.metadata.identifier = u.nextUniqueID
+ u.nextUniqueID++
+ // Find spot to insert based on ordering defined in Axiom 2.
+ // TODO: Insert some comments explaining the basic algorithm.
+ for i := 0; i < len(u.numbers); i++ {
+
+// if num.number.leftSet != nil {
+// // By assumption, everything is in reduced form by this point,
+// // thus there is precisely one element at this time.
+// _, leftIndex := u.getIndex(num.number.leftSet[0])
+// _, rightIndex := u.getIndex(u.numbers[i])
+// if leftIndex >= rightIndex {
+// // num is NOT LEQ to u.numbers[i]
+// }
+// }
+// if u.numbers[i].rightSet != nil {
+// // TODO: How do I check if the second number's rightSet is less
+// // than or equal to the first number? After all, the first
+// // number isn't on the numberline yet.
+// }
+
+// =================================================================================================
+//// Algorithm
+//foreach u.numbers as oldNum, in increasing order:
+// if newNum <= oldNum:
+// if oldNum <= newNum:
+// // the number are the same, just in a different reduced form.
+// else:
+// // Insert newNum immediately before oldNum
+// else:
+// if more oldNums exist:
+// // loop and try the next oldNum
+// else:
+// // Found a new largest number?
+// =================================================================================================
+
+// if !lessThanOrEqual(num, u.numbers[i]) {
+// if i+1 < len(u.numbers) {
+// // There are still more entries to check.
+// continue
+// } else {
+// // New largest number. Append to numberline.
+// u.numbers = append(u.numbers, num)
+// }
+// } else {
+// // Found insertion spot between two existing numbers.
+// u.numbers = append(u.numbers[:i], num, u.numbers[i:]...)
+// }
+ }
+ }
+}
+
+func (u *surrealUniverse) remove(num surrealNumber) {
+ for i := 0; i < len(u.numbers); i++ {
+ if num.number == u.numbers[i].number {
+ u.numbers = append(u.numbers[:i], u.numbers[i+1:]...)
+ }
+ }
+}
+
+// TODO: Note that this is only for numbers already in the universe, not for
+// new numbers constructed FROM the universe. To determine where a new number
+// goes, insert it into the universe.
+func (u *surrealUniverse) lessThanOrEqual(left, right surrealNumber) bool {
+ _, leftIndex := u.getIndex(left)
+ _, rightIndex := u.getIndex(right)
+ if leftIndex <= rightIndex {
+ return true
+ } else {
+ return false
+ }
+}
+
+// =============================================================================
+
+type surrealNumber struct {
+ number surrealValue
+ metadata surrealMetadata
+}
+
+// TODO: Note that this is split from the metadata so we can do direct
+// comparisons when numbers are in reduced form.
+type surrealValue struct {
+ leftSet *surrealSet
+ rightSet *surrealSet
+}
+
+type surrealMetadata struct {
+ identifier int
+ generation int
+}
+
+// =============================================================================
+
+type surrealSet struct {
+ members []surrealNumber
+}
+
+func (s *surrealSet) isMember(num surrealNumber) bool {
+ for i := 0; i < len(s.members); i++ {
+ if num.number == s.members[i].number {
+ return true
+ }
+ }
+ return false
+}
+
+func (s *surrealSet) cardinality() int {
+ return len(s.members)
+}
+
+func (s *surrealSet) insert(num surrealNumber) {
+ if !s.isMember(num) {
+ s.members = append(s.members, num)
+ }
+}
+
+func (s *surrealSet) remove(num surrealNumber) {
+ for i := 0; i < len(s.members); i++ {
+ if num.number == s.members[i].number {
+ s.members[i] = s.members[len(s.members)-1]
+ s.members = s.members[:len(s.members)-1]
+ }
+ }
+}
+
+// =============================================================================
+