passagemath-fricas 10.5.40__cp310-cp310-macosx_14_0_arm64.whl → 10.5.41__cp310-cp310-macosx_14_0_arm64.whl

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/logic.spad

@@ -592,30 +592,23 @@ the whole order and not just one element (unlike PartialOrder in catdef.spad).
 
 )abbrev category PREORD Preorder
 ++ Author: Martin Baker
-++ Description: implies operation with reflexivity and transitivity
-++   for more documentation see:
-++   http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm
-++ Related Domains: PartialOrder in catdef.spad
 ++ Axiom: reflexivity forall(x): x<=x
 ++ Axiom: transitivity forall(x, y, z): x<=y and y<=z implies x<=z
 ++ Date Created: Aug 2015
+++ Description: implies operation with reflexivity and transitivity
+++   for more documentation see:
+++   \url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm}
 Preorder(S) : Category == Definition where
  S : SetCategory
  NNI ==> NonNegativeInteger
  Definition ==> FiniteGraph(S) with
-    le : (s : %, NNI, NNI) -> Boolean
-      ++ le(s, x, y) checs if x is less than or equal to y.
-      ++ I would have liked to have used: "<=" instead of "le"
-      ++ "<=" compiles but when called gives:
-      ++ Internal Error: The function <= with signature hashcode is
-      ++ missing from domain.
+    le : (s : %, S, S) -> Boolean
+      ++ le(s, x, y) returns true if and only if x is less than or equal
+      ++ to y.  Note: at first glance we would like to use '<='.
+      ++ But le needs 3 arguments while '<=' has only 2.
 
 )abbrev category POSET Poset
 ++ Author: Martin Baker
-++ Description: holds a complete set together with a structure to codify
-++   the partial order.
-++   for more documentation see:
-++   http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm
 ++ Date Created: Aug 2015
 ++ Basic Operations:
 ++ Related packages: UserDefinedPartialOrdering in setorder.spad
@@ -629,6 +622,10 @@ Preorder(S) : Category == Definition where
 ++ Axiom: reflexivity forall(x): x<=x
 ++ Axiom: antisymmetry forall(x, y): x<=y and y<=x iff x=y
 ++ Axiom: transitivity forall(x, y, z): x<=y and y<=z implies x<=z
+++ Description: holds a complete set together with a structure to codify
+++   the partial order.
+++   for more documentation see:
+++   \url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm}
 Poset(S) : Category == Definition where
  S : SetCategory
  PI ==> PositiveInteger
@@ -660,34 +657,17 @@ Poset(S) : Category == Definition where
        ++ Note: different from getArrows(s) which is inherited from
        ++ FiniteGraph(S)
 
-     setVert : (s : %, v : List S) -> Void
-       ++ setVert(s, lv) sets the list of all vertices (or objects)
-
-     setArr : (s : %, v : List List Boolean) -> Void
-       ++ setArr(s, la) sets the list of all arrows (or edges)
-
-     addObject! : (s : %, n : S) -> %
-       ++ addObject!(s, n) adds object with coordinates n to the
-       ++ graph s.
-       ++ This is done in a non-mutable way, that is, the original
-       ++ poset is not changed instead a new one is constructed.
-     addArrow! : (s : %, n1 : NNI, n2 : NNI) -> %
-       ++ addArrow!(s, nm, n1, n2) adds an arrow to the graph s, where:
-       ++ n1 is the index of the start object
-       ++ n2 is the index of the end object
-       ++ This is done in a non-mutable way, that is, the original
-       ++ poset is not changed instead a new one is constructed.
+     addObject : (s : %, n : S) -> %
+       ++ addObject(s, n) constructs new poset by adding object n
+       ++ to the poset s.
+     addArrow : (s : %, n1 : S, n2 : S) -> %
+       ++ addArrow(s, nm, n1, n2) constructs new poset by adding
+       ++ to the poset s arrow from n1 to n2.
 
      opposite : (s : %) -> %
        ++ opposite(s) constructs the opposite in the category theory sense
        ++ of reversing all the arrows.
 
-     powerSetStructure : (objs : S) -> %
-       ++ powerSetStructure(set) is a constructor for a Poset
-       ++ where each element is a set (implemented as a list)
-       ++ and with a subset structure.
-       ++ requires S to be a list.
-
      implies : (s : %, NNI, NNI) -> Boolean
 
      meetIfCan : (s : %, a : NNI, b : NNI) -> Union(NNI, "failed")
@@ -736,20 +716,6 @@ Poset(S) : Category == Definition where
      objectToIndex : (s : %, obj : S) -> NNI
        ++ objectToIndex returns the index of a given object.
 
-     completeReflexivity : (s : %) -> %
-       ++ Reflexivity requires forall(x): x<=x
-       ++ This function enforces this by making sure that every element has
-       ++ arrow to itself. That is, the leading diagonal is true.
-
-     completeTransitivity : (s : %) -> %
-       ++ Transitivity requires forall(x, y, z): x<=y and y<=z implies x<=z
-       ++ This function enforces this by making sure that the composition
-       ++ of any two arrows is also an arrow.
-
-     isAntisymmetric? : (s : %) -> Boolean
-       ++ Antisymmetric requires forall(x, y): x<=y and y<=x iff x=y
-       ++ Returns true if this is the case for every element.
-
      isChain? : (s : %) -> Boolean
        ++ isChain?(s) checks if s is a chain, that is any two elements
        ++ in s are comparable.
@@ -779,86 +745,83 @@ Poset(S) : Category == Definition where
        ++ \url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/moebius/}
 
   add
+      import from List(S)
+      import from List(List(Boolean))
 
       -- adds an object to this poset
-      addObject!(s : %, n : S) : % ==
-          dim : NNI := #(getVert(s)) + 1
-          obs : List S := concat(getVert(s), n)
+      addObject(s : %, n : S) : % ==
+          verts := getVert(s)
+          member?(n, verts) => s
+          dim : NNI := #verts + 1
+          verts := concat(verts, n)
           arrows := []$List(List(Boolean))
-          for a in getArr(s) repeat
-              width : NNI := #a
-              padding : Union(NNI, "failed") := subtractIfCan(dim, width)
-              if padding ~= "failed" then
-                  diff : NNI := padding::NNI
-                  --print(("addObject diff=", string(diff))$String)])
-                  for x in 1..diff repeat
-                      a := concat(a, false)
-              if empty?(arrows)
-                  then arrows := [a]
-                  else arrows := concat(arrows, a)
-          emptyRow : List Boolean := [false for x in 1..dim]
-          arrows := concat(arrows, emptyRow)
-          finitePoset(obs, arrows)
-
-      -- TODO - make this non-mutable
+          for row in getArr(s) repeat
+              row2 := concat(row, false)
+              arrows := cons(row2, arrows)
+          emptyRow : List Boolean := [i = dim for i in 1..dim]
+          arrows := cons(emptyRow, arrows)
+          finitePoset(verts, reverse!(arrows))
+
+      bll_to_mat(dim : NNI, arr : List(List(Boolean))
+                ) : TwoDimensionalArray(Boolean) ==
+          mat := new(dim, dim, false)$TwoDimensionalArray(Boolean)
+          for row in arr for i in 1..dim repeat
+              for y in row for j in 1..dim repeat
+                  mat(i, j) := y
+          mat
+
+      mat_to_bll(mat : TwoDimensionalArray(Boolean)
+                ) : List(List(Boolean)) ==
+          dim : NNI := nrows(mat)
+          arr : List(List(Boolean)) := []
+          for i in dim..1 by -1 repeat
+              row : List Boolean := []
+              for j in 1..dim repeat
+                  row := cons(mat(i, j), row)
+              arr := cons(reverse!(row), arr)
+          arr
+
+      transitive_closure!(mat : TwoDimensionalArray(Boolean)) :  Void ==
+          dim : NNI := nrows(mat)
+          for j in 1..dim repeat
+              for i in 1..dim repeat
+                  if mat(i, j) then
+                      for k in 1..dim repeat
+                          mat(i, k) := mat(i, k) or mat(j, k)
+
+      anitsymmetric?(mat : TwoDimensionalArray(Boolean)) :  Boolean ==
+          dim : NNI := nrows(mat)
+          for i in 1..dim repeat
+              for j in 1..dim repeat
+                  i = j => iterate
+                  if mat(i, j) and mat(j, i) then return false
+          true
+
       -- adds an arrow to this graph, where:
       -- s is the graph where the arrow is to be added
       -- n1 is the index of the start object
       -- n2 is the index of the end object
-      addArrow!(s : %, n1 : NNI, n2 : NNI) : % ==
-          a : List Boolean := qelt(getArr(s), n1)
-          setelt!(a, n2, true)
-          setelt!(getArr(s), n1, a)
-          finitePoset(getVert(s), getArr(s))
+      add_arrow(s : %, n1 : NNI, n2 : NNI) : % ==
+          dim : NNI := #(getVert(s))
+          mat := bll_to_mat(dim, getArr(s))
+          mat(n1, n2) := true
+          transitive_closure!(mat)
+          not(anitsymmetric?(mat)) =>
+              error "add_arrow: incompatible arrow"
+          finitePoset(getVert(s), mat_to_bll(mat))
+
+      addArrow(s : %, n1 : S, n2 : S) : % ==
+          add_arrow(s, objectToIndex(s, n1), objectToIndex(s, n2))
 
       -- local function to test a single value in the arrow matrix
       isArrow?(arr : List(List(Boolean)), a : NNI, b : NNI) : Boolean ==
-          row : NNI := 1
-          for x in arr repeat
-              if row = a then
-                  val : Boolean := qelt(x, b)
-                  return val
-              row = row + 1
-          false
+          qelt(qelt(arr, a), b)
 
-      le(s : %, a : NNI, b : NNI) : Boolean == isArrow?(getArr(s), a, b)
-
-      -- local function to set a single value in the arrow matrix
-      setArrow!(arr : List(List(Boolean)), a : NNI, b : NNI, c : Boolean
-               ) : Void ==
-          row : NNI := 1
-          for x in arr repeat
-              if row = a then
-                  setelt!(x, b, c)
-                  return void
-              row = row + 1
-          void
+      le(s : %, a : S, b : S) : Boolean ==
+          isArrow?(getArr(s), objectToIndex(s, a), objectToIndex(s, b))
 
       -- start of FiniteGraph implementation
 
-      -- addObject!(s, n) adds object n to the graph s.
-      -- mutable version of addObject.
-      addObject!(s : %, n : S) : % ==
-          dim : NNI := #(getVert(s)) + 1
-          obs : List S := concat(getVert(s), n)
-          arrows := []$List(List(Boolean))
-          for a in getArr(s) repeat
-              width : NNI := #a
-              padding : Union(NNI, "failed") := subtractIfCan(dim, width)
-              if padding ~= "failed" then
-                  diff : NNI := padding::NNI
-                  --print("addObject! diff="::Symbol << string(diff))
-                  for x in 1..diff repeat
-                      a := concat(a, false)
-              if empty?(arrows)
-                  then arrows := [a]
-                  else arrows := concat(arrows, a)
-          emptyRow : List Boolean := [false for x in 1..dim]
-          arrows := concat(arrows, emptyRow)
-          setVert(s, obs)
-          setArr(s, arrows)
-          s
-
       -- addObject!(s, n) adds object with coordinates n to the
       -- graph s.
       addObject!(s : %, n : OBJT) : % ==
@@ -870,10 +833,7 @@ Poset(S) : Category == Definition where
       -- n1 is the index of the start object
       -- n2 is the index of the end object
       addArrow!(s : %, name : String, n1 : NNI, n2 : NNI) : % ==
-          a : List Boolean := qelt(getArr(s), n1)
-          setelt!(a, n2, true)
-          setelt!(getArr(s), n1, a)
-          finitePoset(getVert(s), getArr(s))
+          add_arrow(s, n1, n2)
 
       -- addArrow!(s, nm, n1, n2, mp) adds an arrow to the graph s, where:
       -- nm is the name of the arrow
@@ -898,8 +858,8 @@ Poset(S) : Category == Definition where
                       arr : ARROW := ["x", 0::NNI, x pretend NNI,
                                        y pretend NNI, 0::Integer, 0::Integer,
                                          []$List(NNI)]
-                      res := concat(res, arr)
-          res
+                      res := cons(arr, res)
+          reverse!(res)
 
       -- flatten(n) takes a second order graph, we don't really need
       -- this here so return an empty poset.
@@ -941,12 +901,9 @@ Poset(S) : Category == Definition where
       unit(objs : List(S), arrowName : String) : % ==
           dim : NNI := #objs
           arrs : List(List(Boolean)) := [[]$List(Boolean)]
-          for x in 1..dim repeat
-              row : List Boolean := []
-              for y in 1..dim repeat
-                  val : Boolean := (x = y)
-                  row := concat(row, val)
-              arrs := concat(arrs, row)
+          for i in dim..1 by -1 repeat
+              row : List(Boolean) := [i = j for j in 1..dim]
+              arrs := cons(row, arrs)
           finitePoset(objs, arrs)
 
       -- kgraph(objs, arrowName)
@@ -1167,19 +1124,16 @@ Poset(S) : Category == Definition where
 
       -- end of FiniteGraph implementation
 
-      -- constucts the opposite in the category theory sense of reversing
+      -- constructs the opposite in the category theory sense of reversing
       -- all the arrows
       opposite(s : %) : % ==
           arr2 : List List Boolean := [[]]
-          for x in getArr(s) repeat
-              row : List Boolean := []
-              for y in x repeat
-                  row := concat(row, false)
-              arr2 := concat(arr2, row)
-          for a in 1..#(getArr(s)) repeat
-              for b in 1..#(getArr(s)) repeat
-                  if isArrow?(getArr(s), a, b) then setArrow!(arr2, b, a, true)
-          finitePoset(getVert(s), arr2)
+          dim : NNI := #getVert(s)
+          mat := new(dim, dim, false)$TwoDimensionalArray(Boolean)
+          for row in getArr(s) for i in 1.. repeat
+              for y in row for j in 1.. repeat
+                  mat(j, i) := y
+          finitePoset(getVert(s), mat_to_bll(mat))
 
       implies(s : %, left : NNI, right : NNI) : Boolean ==
           a : List Boolean := qelt(getArr(s), left)
@@ -1334,42 +1288,6 @@ Poset(S) : Category == Definition where
       objectToIndex(s : %, obj : S) : NNI ==
           position(obj, getVert(s))$List(S) pretend NNI
 
-      -- Reflexivity requires forall(x): x<=x
-      -- This function enforces this by making sure that every element has
-      -- arrow to itself. That is, the leading diagonal is true.
-      completeReflexivity(s : %) : % ==
-          set2 : List S := getVert(s)
-          struct2 : List(List(Boolean)) := copy(getArr(s))
-          for a in 1..(#set2) repeat
-              setArrow!(struct2, a, a, true)
-          finitePoset(set2, struct2)
-
-      -- Transitivity requires forall(x, y, z): x<=y and y<=z implies x<=z
-      -- This function enforces this by making sure that the composition
-      -- of any two arrows is also an arrow.
-      completeTransitivity(s : %) : % ==
-          set2 : List S := getVert(s)
-          dim : NNI := #set2
-          struct2 : List(List(Boolean)) := copy(getArr(s))
-          for a in 1..dim repeat
-              for b in 1..dim repeat
-                  for c in 1..dim repeat
-                      if isArrow?(struct2, a, b) and isArrow?(struct2, b, c)
-                           and not(isArrow?(struct2, a, c)) then
-                          setArrow!(struct2, a, c, true)
-          finitePoset(set2, struct2)
-
-      -- Antisymmetric requires forall(x, y): x<=y and y<=x iff x=y
-      -- Returns true if this is the case for every element.
-      isAntisymmetric?(s : %) : Boolean ==
-          dim : NNI := #(getVert(s))
-          struct2 : List(List(Boolean)) := copy(getArr(s))
-          for a in 1..dim repeat
-              for b in 1..dim repeat
-                  if isArrow?(struct2, a, b) and isArrow?(struct2, b, a) then
-                      if a ~= b then return false
-          true
-
       -- \spad{zetaMatrix(P)} returns the matrix of the zeta function
       -- This function is based on code by Franz Lehner.
       zetaMatrix(s : %) : IncidenceAlgebra(Integer, S) ==
@@ -1458,11 +1376,6 @@ Poset(S) : Category == Definition where
 
 )abbrev domain FPOSET FinitePoset
 ++ Author: Martin Baker
-++ Description: holds a complete set together with a structure to codify
-++   the partial order.
-++   for more documentation see:
-++   http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm
-++ Date Created: Aug 2015
 ++ Basic Operations:
 ++ Related packages: UserDefinedPartialOrdering in setorder.spad
 ++ Related categories: PartialOrder in catdef.spad
@@ -1475,7 +1388,10 @@ Poset(S) : Category == Definition where
 ++ Axiom: reflexivity forall(x): x<=x
 ++ Axiom: antisymmetry forall(x, y): x<=y and y<=x iff x=y
 ++ Axiom: transitivity forall(x, y, z): x<=y and y<=z implies x<=z
-
+++ Description: holds a complete set together with a structure to codify
+++   the partial order.
+++   for more documentation see:
+++   \url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm}
 FinitePoset(S) : Exports == Impl where
     S : SetCategory
     PI ==> PositiveInteger
@@ -1515,16 +1431,6 @@ FinitePoset(S) : Exports == Impl where
       getArr(s : %) : List List Boolean ==
           s.struct1
 
-      -- sets the list of all vertices (or objects)
-      setVert(s : %, v : List S) : Void ==
-          s.set1 := v
-          void
-
-      -- sets the list of all arrows (or edges)
-      setArr(s : %, v : List List Boolean) : Void ==
-          s.struct1 := v
-          void
-
 )if false
 \section{Complete Partial Order}
 Complete partial orders are partial orders which are guaranteed to have meets
@@ -1553,13 +1459,13 @@ DCPOs, we obvously cant do this by using a list of all the elements
 
 )abbrev category DCPO Dcpo
 ++ Author: Martin Baker
-++ Description:
-++ Directed-complete partial order, partial order that is guaranteed to
-++ have a join of any two elements.  For more documentation see:
-++   http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm
 ++ Axiom: reflexivity forall(x): x<=x
 ++ Axiom: transitivity forall(x, y, z): x<=y and y<=z implies x<=z
 ++ Date Created: Oct 2015
+++ Description:
+++ Directed-complete partial order, partial order that is guaranteed to
+++ have a join of any two elements.  For more documentation see:
+++   \url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm}
 Dcpo(S) : Category == Definition where
  S : SetCategory
  NNI ==> NonNegativeInteger
@@ -1571,10 +1477,6 @@ Dcpo(S) : Category == Definition where
 
 )abbrev domain FDCPO FiniteDcpo
 ++ Author: Martin Baker
-++ Description: holds a complete set together with a structure to codify
-++   the partial order.
-++   for more documentation see:
-++   http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm
 ++ Date Created: Aug 2015
 ++ Basic Operations:
 ++ Related packages: UserDefinedPartialOrdering in setorder.spad
@@ -1588,7 +1490,10 @@ Dcpo(S) : Category == Definition where
 ++ Axiom: reflexivity forall(x): x<=x
 ++ Axiom: antisymmetry forall(x, y): x<=y and y<=x iff x=y
 ++ Axiom: transitivity forall(x, y, z): x<=y and y<=z implies x<=z
-
+++ Description: holds a complete set together with a structure to codify
+++   the partial order.
+++   for more documentation see:
+++   \url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm}
 FiniteDcpo(S) : Exports == Impl where
     S : SetCategory
     PI ==> PositiveInteger
@@ -1616,13 +1521,13 @@ alternatively it is sometimes called a filtered complete partial order.
 
 )abbrev category CODCPO CoDcpo
 ++ Author: Martin Baker
-++ Description:
-++ Directed-complete Order, partial order that is guaranteed to have
-++ a meet of any two elements.  For more documentation see:
-++   http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm
 ++ Axiom: reflexivity forall(x): x<=x
 ++ Axiom: transitivity forall(x, y, z): x<=y and y<=z implies x<=z
 ++ Date Created: Oct 2015
+++ Description:
+++ Directed-complete Order, partial order that is guaranteed to have
+++ a meet of any two elements.  For more documentation see:
+++   \url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm}
 CoDcpo(S) : Category == Definition where
  S : SetCategory
  NNI ==> NonNegativeInteger
@@ -1634,10 +1539,6 @@ CoDcpo(S) : Category == Definition where
 
 )abbrev domain FCDCPO FiniteCoDcpo
 ++ Author: Martin Baker
-++ Description: holds a complete set together with a structure to codify
-++   the partial order.
-++   for more documentation see:
-++   http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm
 ++ Date Created: Aug 2015
 ++ Basic Operations:
 ++ Related packages: UserDefinedPartialOrdering in setorder.spad
@@ -1651,7 +1552,10 @@ CoDcpo(S) : Category == Definition where
 ++ Axiom: reflexivity forall(x): x<=x
 ++ Axiom: antisymmetry forall(x, y): x<=y and y<=x iff x=y
 ++ Axiom: transitivity forall(x, y, z): x<=y and y<=z implies x<=z
-
+++ Description: holds a complete set together with a structure to codify
+++   the partial order.
+++   for more documentation see:
+++   \url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm}
 FiniteCoDcpo(S) : Exports == Impl where
     S : SetCategory
     PI ==> PositiveInteger
@@ -1679,21 +1583,17 @@ are guaranteed to exist.
 
 )abbrev category BICPO BiCPO
 ++ Author: Martin Baker
-++ Description:
-++ Complete partial Order, partial order that is guaranteed to have both
-++ a join and a meet of any two elements.  For more documentation see:
-++   http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm
 ++ Axiom: reflexivity forall(x): x<=x
 ++ Axiom: transitivity forall(x, y, z): x<=y and y<=z implies x<=z
 ++ Date Created: Oct 2015
+++ Description:
+++ Complete partial Order, partial order that is guaranteed to have both
+++ a join and a meet of any two elements.  For more documentation see:
+++   \url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm}
 BiCPO(S: SetCategory): Category == Join(Dcpo(S), CoDcpo(S))
 
 )abbrev domain FBICPO FiniteBiCPO
 ++ Author: Martin Baker
-++ Description:
-++ Holds a complete set together with a structure to codify the partial order.
-++ For more documentation see:
-++   http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm
 ++ Date Created: Aug 2015
 ++ Basic Operations:
 ++ Related packages: UserDefinedPartialOrdering in setorder.spad
@@ -1707,7 +1607,10 @@ BiCPO(S: SetCategory): Category == Join(Dcpo(S), CoDcpo(S))
 ++ Axiom: reflexivity forall(x): x<=x
 ++ Axiom: antisymmetry forall(x, y): x<=y and y<=x iff x=y
 ++ Axiom: transitivity forall(x, y, z): x<=y and y<=z implies x<=z
-
+++ Description:
+++ Holds a complete set together with a structure to codify the partial order.
+++ For more documentation see:
+++   \url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm}
 FiniteBiCPO(S) : Exports == Impl where
     S : SetCategory
     PI ==> PositiveInteger
@@ -1749,13 +1652,13 @@ End of POSET structures and start of lattice structures
 ++  the case for all finite meet semilattices since we can do a meet of
 ++  all values
 ++ Keywords: Meet
-++ Description: meet semilattice
-++   Implementations in set, logic and orders
-++   for more documentation see:
-++   http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm
 ++ Axiom: commutativity forall(x, y): x/\y=y/\x
 ++ Axiom: associativity forall(x, y, z): (x/\y)/\z=y/\(x/\z)
 ++ Axiom: idempotence forall x: x/\x=x
+++ Description: meet semilattice
+++   Implementations in set, logic and orders
+++   for more documentation see:
+++   \url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm}
 MeetSemilattice : Category == SetCategory with
       _/_\ : (%, %) -> %
         ++ returns the logical 'meet', e.g. 'and'.
@@ -1769,11 +1672,11 @@ MeetSemilattice : Category == SetCategory with
 ++  the case for all finite meet semilattice since we can do a meet of
 ++  all values
 ++ Keywords: Meet Top
+++ Axiom: unit forall x: x/\ T=x
 ++ Description: meet semilattice with top
 ++   Implementations in set, logic and orders
 ++   for more documentation see:
-++   http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm
-++ Axiom: unit forall x: x/\ T=x
+++   \url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm}
 BoundedMeetSemilattice : Category == MeetSemilattice with
       T : constant -> %
         ++ Top (true in logic).
@@ -1786,15 +1689,15 @@ BoundedMeetSemilattice : Category == MeetSemilattice with
 ++  use BoundedJoinSemilattice if the semilattice has a 'bottom' which will be
 ++  the case for all finite join semilattices since we can do a join of all values
 ++ Keywords: Join
+++ Axiom: commutativity forall(x, y): x\/y=y\/x
+++ Axiom: associativity forall(x, y, z): (x\/y)\/z=y\/(x\/z)
+++ Axiom: idempotence forall x: x\/x=x
 ++ Description: join semilattice
 ++   Different from exterior Grassmann product operator as
 ++   that anticommutes.
 ++   need to check precedence when used as an infix operator
 ++   for more documentation see:
-++   http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm
-++ Axiom: commutativity forall(x, y): x\/y=y\/x
-++ Axiom: associativity forall(x, y, z): (x\/y)\/z=y\/(x\/z)
-++ Axiom: idempotence forall x: x\/x=x
+++   \url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm}
 JoinSemilattice: Category == SetCategory with
       _\_/ : (%, %) -> %
         ++ returns the logical 'join', e.g. 'or'.
@@ -1808,13 +1711,13 @@ JoinSemilattice: Category == SetCategory with
 ++  the case for all finite join semilattices since we can do a join of all
 ++  values
 ++ Keywords: Join Bottom
+++ Axiom: unit forall x: x \/ _|_=x
 ++ Description: join semilattice with bottom
 ++   Different from exterior Grassmann product operator as
 ++   that anticommutes.
 ++   need to check precedence when used as an infix operator
 ++   for more documentation see:
-++   http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm
-++ Axiom: unit forall x: x \/ _|_=x
+++   \url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm}
 BoundedJoinSemilattice: Category == JoinSemilattice with
       "__|__" : constant -> %
         ++ bottom (false in logic).
@@ -1828,11 +1731,11 @@ BoundedJoinSemilattice: Category == JoinSemilattice with
 ++  the case for all finite lattices since we can do a meet and join of all
 ++  values
 ++ Keywords: Meet Top Join Bottom
-++ Description: lattice
-++   for more documentation see:
-++   http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm
 ++ Axiom: absorptionMeetOverJoin forall(x, y): x/\(x\/y)=x
 ++ Axiom: absorptionJoinOverMeet forall(x, y): x\/(x/\y)=x
+++ Description: lattice
+++   for more documentation see:
+++   \url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm}
 Lattice: Category == Join(MeetSemilattice, JoinSemilattice)
 
 )abbrev category BLAT BoundedLattice
@@ -1844,11 +1747,11 @@ Lattice: Category == Join(MeetSemilattice, JoinSemilattice)
 ++  the case for all finite lattices since we can do a meet and join of all
 ++  values
 ++ Keywords: Meet Top Join Bottom
-++ Description: lattice with top and bottom
-++   for more documentation see:
-++   http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm
 ++ Axiom: absorptionMeetOverJoin forall(x, y): x/\(x\/y)=x
 ++ Axiom: absorptionJoinOverMeet forall(x, y): x\/(x/\y)=x
+++ Description: lattice with top and bottom
+++   for more documentation see:
+++   \url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm}
 BoundedLattice: Category == Join(BoundedMeetSemilattice,
                                  BoundedJoinSemilattice)
 
@@ -1861,12 +1764,12 @@ BoundedLattice: Category == Join(BoundedMeetSemilattice,
 ++  which will be the case for all finite lattices since we can do a
 ++  meet and join of all values
 ++ Keywords: Meet Top Join Bottom
+++ Axiom: distribution1 forall(x, y, z): x/\(y\/z)=(x/\y)\/(x/\z)
+++ Axiom: distribution2 forall(x, y, z): x\/(y/\z)=(x\/y)/\(x\/z)
 ++ Description: not every lattice is distributive so treat this
 ++              as a separate case
 ++   for more documentation see:
-++   http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm
-++ Axiom: distribution1 forall(x, y, z): x/\(y\/z)=(x/\y)\/(x/\z)
-++ Axiom: distribution2 forall(x, y, z): x\/(y/\z)=(x\/y)/\(x\/z)
+++   \url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm}
 DistributiveLattice: Category == Lattice
 
 )abbrev category BDISTL BoundedDistributiveLattice
@@ -1881,7 +1784,7 @@ DistributiveLattice: Category == Lattice
 ++ Description: not every lattice is distributive so treat this
 ++              as a separate case
 ++   for more documentation see:
-++   http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm
+++   \url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.htm}
 ++ Axiom: distribution1 forall(x, y, z): x/\(y\/z)=(x/\y)\/(x/\z)
 ++ Axiom: distribution2 forall(x, y, z): x\/(y/\z)=(x\/y)/\(x\/z)
 BoundedDistributiveLattice: Category == Join(BoundedLattice,
@@ -2127,7 +2030,7 @@ essentially the same.
 ++  Provides functions to construct various small posets
 ++  including powerset.
 ++  Perhaps it should be called a 'powerlist' but since we do
-++  not expect duplicates or reqire specific ordering it is
+++  not expect duplicates or require specific ordering it is
 ++  essentially the same.
 PI ==> PositiveInteger
 NNI ==> NonNegativeInteger
@@ -2460,7 +2363,7 @@ so we get the required deduction 'b'
 ++ Date Created: March 2011
 ++ Basic Operations:
 ++ Related Constructors:
-++ Keywords: intuitionisticLogic
+++ Keywords: intuitionistic Logic
 ++ Description: ILogic is an algebra with
 ++ true, false and other 'unproven' values
 ++ References:
@@ -2470,7 +2373,7 @@ ILogic() : Exports == Implementation where
 
  NNI ==> NonNegativeInteger
  PR ==> Record(rft : %, pout : NNI)
-   ++ parse result includes term returned and new index
+   -- parse result includes term returned and new index
 
  Exports == BoundedLattice with
   logicT : () -> %
@@ -2506,7 +2409,7 @@ ILogic() : Exports == Implementation where
     ++ This is used to determine the returned type when converting
     ++ ILogic to types by using the Curry-Howard isomorphism.
   "=" : (a : %, b : %) -> Boolean
-    ++ returns true (boolean true) if intuitionisticLogic values
+    ++ returns true (boolean true) if Intuitionistic Logic values
     ++ are the same.
     ++ Translates from Intuitionistic Logic to Boolean Logic
   _~ : % -> %
@@ -2724,7 +2627,7 @@ ILogic() : Exports == Implementation where
   -- splits n into a list of factors which must be true for the
   -- whole to be true.
   -- This assumes that the top level is already a set of factors
-  -- seperated by /\ otherwise the result will just be a list with
+  -- separated by /\ otherwise the result will just be a list with
   -- one entry: 'n'.
   -- This is used when converting ILogic to types by using the
   -- Curry-Howard isomorphism.
@@ -3235,7 +3138,7 @@ LatticeMeetOfJoins() : Exports == Implementation where
 
  NNI ==> NonNegativeInteger
  PR ==> Record(rft : %, pout : NNI)
-   ++ parse result includes term returned and new index
+   -- parse result includes term returned and new index
  ELEMENT ==> Union(_
                const : Record(val : Symbol), _
                var : Record(str : String) _
@@ -3587,7 +3490,7 @@ LatticeJoinOfMeets() : Exports == Implementation where
 
  NNI ==> NonNegativeInteger
  PR ==> Record(rft : %, pout : NNI)
-   ++ parse result includes term returned and new index
+   -- parse result includes term returned and new index
  ELEMENT ==> Union(_
                const : Record(val : Symbol), _
                var : Record(str : String) _
@@ -4134,6 +4037,8 @@ BitStreamFrame() : Exports == Impl where
 
      hash(s : %) : SingleInteger == 0$SingleInteger
 
+     import from Integer
+
      -- returns true if x equals y
      -- this is equality and not isomorphism
      -- that is it returns true only if exact index values and names are used