--> ****************************************************************
-->                         Generic Sets
--> ****************************************************************

--> ----------------------------------------------------------------
--> SET: generic sets 
--> ----------------------------------------------------------------
mod! SET(X :: TRIV) {
[Elt < Set]
-- empty set
op empty : -> Set {constr} .
op __ : Set Set -> Set {constr assoc comm id: empty} .
-- impotent
ceq (S:Set S) = S if not(S == empty) .
}

--> ================================================================
--> basic tests for SET
--> ----------------------------------------------------------------
open SET(NAT) .
sh op __ .
red 1 3 2 = 2 3 1 .
red 2 1 empty = 1 empty 2 .
red 2 1 2 = 1 2 1 .
red 1 1 2 = 2 3 .
close

open SET(NAT) .
pred atLeast1&2 : Set .
eq atLeast1&2(S:Set) = ((1 2 S1:Set) := S) .
red atLeast1&2(1 2) .
red atLeast1&2(1 1) .
red atLeast1&2(1 3 1 4) .
red atLeast1&2(2 3 4 1) .
red atLeast1&2(3 4 5 6 7 8 1 9 10 2) .
close

--> ----------------------------------------------------------------
--> TRIV=: TRIV with _=e_
--> ----------------------------------------------------------------
mod* TRIV= {
[Elt]
pred _=e_ : Elt Elt {comm} .
eq (E:Elt =e E) = true .
cq [:nonexec]: E1:Elt = E2:Elt if (E1 =e E2) .
}
--> ----------------------------------------------------------------
--> SETin: generic sets with _in_
--> ----------------------------------------------------------------
mod! SETin (X :: TRIV=) {
pr(SET(X))
-- in
pred _in_ : Elt Set .
eq (E:Elt in empty) = false .
eq (E1:Elt in (E2:Elt S:Set)) = ((E1 =e E2) or (E1 in S)) .
}

--> ================================================================
--> basic tests for SETin
--> ----------------------------------------------------------------
open SETin(NAT{op E1:Elt =e E2:Elt -> E1:Nat = E2:Nat}) .
red 1 in empty .
red 1 in 1 .
red 1 in 2 3 .
close

open SETin(NAT{op E1:Elt =e E2:Elt -> E1:Nat == E2:Nat}) .
red 1 in empty .
red 1 in 1 .
red 1 in 2 3 .
close

--> ----------------------------------------------------------------
--> SET=: generic sets with _=_
--> ----------------------------------------------------------------
mod! SET= {
pr(SETin)
-- equality on Set
pred _=s_ : Set Set {comm} .
eq (S:Set =s S) = true .
cq [:nonexec]: S1:Set = S2:Set if (S1 =s S2) .
-- _=<_, equal of less than
pred _=<_ : Set Set .
eq (empty =< S:Set) = true .
eq ((E1:Elt S1:Set) =< S2:Set) = (E1 in S2) and (S1 =< S2) .
-- 
eq (S1:Set =s S2:Set) = ((S1 =< S2) and (S2 =< S1)) .
}
** if _=e_ and _=s_ are not distinguished,
** i.e. the same _=_ is used for both,
** the last eq can make a dependency chain
**    (E1:Elt = E2:Elt) -> 
**    (E1:Elt in E2:Elt) -> 
**    (E1:Elt = E2:Elt) 
** that causes an infinite loop

--> ================================================================
--> basic tests for SET=
--> ----------------------------------------------------------------
open SET=(NAT{op E1:Elt =e E2:Elt -> E1:Nat = E2:Nat}) .
red 1 =s empty .
red 1 =s 1 .
red 1 =s 2 3 .
red 2 1 3 =s 3 2 3 1 .
close

open SET=(NAT{op E1:Elt =e E2:Elt -> E1:Nat == E2:Nat}) .
red 1 =s empty .
red 1 =s 1 .
red 1 =s 2 3 .
red 2 1 3 =s 3 2 3 1 .
close

--> ****************************************************************
--> end of file
eof
--> ****************************************************************