Copyright (c) 2002-2008 ClearSy

Tout droit de propriete industrielle et intellectuelle reserve 
selon la convention C-93-IGT001.

Les informations presentes dans ce fichier sont la propriete de 
ClearSy et ne doivent pas etre copiees, reproduites, dupliquees
totalement ou partiellement sans autorisation ecrite.



----- Rules Database - Prover 3.0 -----



Backward theories Forward theories



BACKWARD THEORIES

SimplifyX
RecEqualityX
FindLabX
LabelRecX
AssociativityXY
CommutativityXY
SimplifySeqEnuXY
SimplifyBoolXY
SimplifyExistXY
SimplifyFunctionXY
SimplifyIntMaxXY
SimplifyIntMinXY
SimplifyIntPIXY
SimplifyIntParXY
SimplifyIntSIGXY
SimplifyRelComXY
SimplifyRelDoaLongXY
SimplifyRelDoaXY
SimplifyRelDomXY
SimplifyRelDorLongXY
SimplifyRelDorXY
SimplifyRelFonXY
SimplifyRelId
SimplifyRelImaLongXY
SimplifyRelImaXY
SimplifyRelInvXY
SimplifyRelOveXY
SimplifyRelRaaLongXY
SimplifyRelRaaXY
SimplifyRelRanXY
SimplifyRelRarLongXY
SimplifyRelRarXY
SimplifySeqDomXY
SimplifySeqOpeXY
SimplifySeqRanXY
SimplifySeqSizXY
SimplifyTryEnsCard
SimplifyEnsCard
SimplifySetComXY
SimplifySetIntXY
SimplifyTrySetSubXY
SimplifySetSubXY
SimplifySetUniXY
SimplifyStructXY
ContradictionTryXY
ContradictionXY
ContraEnumAllNotX
ContraExtAllNotX
DifferenceTryXY
DifferenceXY
EqualityXY
ExistTryXY
ExistXY
ForAllX
ImplicationXY
b1
s1
f1
InFINXY
InFunctionTryXY
InFunctionXY
InINTEGERTryXY
InINTEGERXY
InREALTryXY
InREALXY
InPOWTryXY
InPOWXY
InPOWLeavesXY
InRelationXY
InSequenceXY
InSetTryXY
InSetXY
InSetLeavesXY
InStructXY
NegationXY
NotInSetTryXY
NotInSetXY
OrderTryXY
OrderXY
DisjonctionTryXY
DisjonctionXY
SplitOr
TryRulesXY

FORWARD THEORIES

GenDirectContradictionX
GenTryContradictionX
GenEqualityX
GenFromRelationX
GenAllInPOWX
GenInPOWX
GenAllInSetX
GenInSetX
GenAllNotEqualX
GenNotEqualX
GenNotInSetX
GenAllOrderX
GenOrderX
GenObvPredicateX
GenPredicateX
OptimGenAnyX
_Empty

BACKWARD RULES


THEORY SimplifyX IS



  RULE SimplifyX.1
	(i => (j => k)) == (i & j => k)


  RULE SimplifyX.2
	(bnot(bstring(a)))
	=>
	(a => bfalse) == not(a)


  RULE SimplifyX.3
	(bfalse => a) == btrue


  RULE SimplifyX.4
	(a => btrue) == btrue


  RULE SimplifyX.5
	(btrue => a) == a


  RULE SimplifyX.6
	(bvrb(x)) &
	(x\a)
	=>
	#x.a == a


  RULE SimplifyX.7
	(bvrb(x)) &
	(x\b)
	=>
	#x.(a & b) == (#x.a & b)


  RULE SimplifyX.8
	(bvrb(x)) &
	(x\a)
	=>
	#x.(a & b) == (a & #x.b)


  RULE SimplifyX.9
	band((bsearch((y = x),(P & p),u)), 
	band((bsearch(x,(L,l),M)), 
	band((x\y), 
	(bnot(bpattern(y,(A,a))))))) &
	(bguard((SUB~;RES): bresult([x:=y](P & p => S)),(Q => T)))
	=>
	!(L,l).(P & p => S) == !M.(Q => T)


  RULE SimplifyX.10
	band((bsearch((x = y),(P & p),u)), 
	band((bsearch(x,(L,l),M)), 
	band((x\y), 
	(bnot(bpattern(y,(A,a))))))) &
	(bguard((SUB~;RES): bresult([x:=y](P & p => S)),(Q => T)))
	=>
	!(L,l).(P & p => S) == !M.(Q => T)


  RULE SimplifyX.11
	band((bsearch((y = L),(P & p),u)), 
	band((L\y), 
	(bguard((SUB;RES): bresult([L:=y]!OK.OK),!OK.OK)))) &
	(bguard((SUB~;RES): bresult([L:=y](P & p => S)),(Q => T)))
	=>
	!L.(P & p => S) == (Q => T)


  RULE SimplifyX.12
	band((bsearch((L = y),(P & p),u)), 
	band((L\y), 
	(bguard((SUB;RES): bresult([L:=y]!OK.OK),!OK.OK)))) &
	(bguard((SUB~;RES): bresult([L:=y](u => S)),(Q => T)))
	=>
	!L.(P & p => S) == (Q => T)


  RULE SimplifyX.13
	(bfresh(y,(x,p,q,r),Y)) &
	(bguard((FLAT~;RES): bresult(bflat(x,Y)),Z)) &
	(bguard((SUB~;RES): bresult([y:=Y](q => r)),(Q => R)))
	=>
	!x.(p => !y.(q => r)) == !Z.(p & Q => R)


  RULE SimplifyX.14
	(bvrb(x)) &
	(bpattern(p,(u & v))) &
	band((bsearch(c,p,r)), 
	(x\c))
	=>
	!x.(p => q) == (c => !x.(r => q))


  RULE SimplifyX.15
	(bvrb(x)) &
	(x\a)
	=>
	!x.a == a


  RULE SimplifyX.16
	(x\b)
	=>
	!x.(a or b) == (!x.a or b)


  RULE SimplifyX.17
	(x\a)
	=>
	!x.(a or b) == (a or !x.b)


  RULE SimplifyX.18
	(bvrb(x)) &
	(x\b)
	=>
	!x.(not(a) => b) == (not(!x.a) => b)


  RULE SimplifyX.19
	(bvrb(x)) &
	(x\a)
	=>
	!x.(not(a) => b) == (not(!x.b) => a)


  RULE SimplifyX.20
	!x.(a & b) == (!x.a & !x.b)


  RULE SimplifyX.21
	(bnum(p))
	=>
	m+p<=n+p == m<=n


  RULE SimplifyX.22
	(binhyp(p: INTEGER)) &
	(blvar(Q)) &
	(Q\p)
	=>
	m+p<=n+p == m<=n


  RULE SimplifyX.23
	(bnum(p))
	=>
	m-p<=n-p == m<=n


  RULE SimplifyX.24
	(binhyp(p: INTEGER)) &
	(blvar(Q)) &
	(Q\p)
	=>
	m-p<=n-p == m<=n


  RULE SimplifyX.25
	(btest(p>0))
	=>
	m*p<=n*p == m<=n


  RULE SimplifyX.26
	(bnum(p))
	=>
	m+p = n+p == (m = n)


  RULE SimplifyX.27
	(binhyp(p: INTEGER)) &
	(blvar(Q)) &
	(Q\p)
	=>
	m+p = n+p == (m = n)


  RULE SimplifyX.28
	(bnum(p))
	=>
	m-p = n-p == (m = n)


  RULE SimplifyX.29
	(binhyp(p: INTEGER)) &
	(blvar(Q)) &
	(Q\p)
	=>
	m-p = n-p == (m = n)


  RULE SimplifyX.30
	(btest(p>0))
	=>
	m*p = n*p == (m = n)


  RULE SimplifyX.31
	bool(P) = FALSE == not(P)


  RULE SimplifyX.32
	bool(P) = TRUE == P


  RULE SimplifyX.33
	FALSE = x == (x = FALSE)


  RULE SimplifyX.34
	TRUE = x == (x = TRUE)


  RULE SimplifyX.35
	FALSE = TRUE == bfalse


  RULE SimplifyX.36
	TRUE = FALSE == bfalse


  RULE SimplifyX.37
	TRUE: BOOL == btrue


  RULE SimplifyX.38
	FALSE: BOOL == btrue


  RULE SimplifyX.39
	(bguard(FindLabX: __fl(rec(L) | l),v))
	=>
	rec(L)'l == v


  RULE SimplifyX.40
	(bguard((LabelRecX;FLAT): __labrec(r | struct(T)),L))
	=>
	r: struct(T) == L


  RULE SimplifyX.41
	x|->y: A*B == (x: A & y: B)


  RULE SimplifyX.42
	x,y: A*B == (x: A & y: B)


  RULE SimplifyX.43
	(bnot(bpattern(a,(u,v))))
	=>
	[a]: seq(E) == (a: E)


  RULE SimplifyX.44
	[a,b]: seq(E) == (b: E & [a]: seq(E))


  RULE SimplifyX.45
	s: iseq(a) == (s: seq(a) & s~: a +-> NATURAL-{0})


  RULE SimplifyX.46
	f: a >->> b == (f: a +-> b & f~: b +-> a & dom(f) = a & ran(f) = b)


  RULE SimplifyX.47
	f: a >-> b == (f: a +-> b & f~: b +-> a & dom(f) = a)


  RULE SimplifyX.48
	f: a -->> b == (f: a +-> b & dom(f) = a & ran(f) = b)


  RULE SimplifyX.49
	f: a +->> b == (f: a +-> b & ran(f) = b)


  RULE SimplifyX.50
	f: a --> b == (f: a +-> b & dom(f) = a)


  RULE SimplifyX.51
	f: a >+> b == (f: a +-> b & f~: b +-> a)


  RULE SimplifyX.52
	a: b/\c == (a: b & a: c)


  RULE SimplifyX.53
	not(a: b\/c) == (not(a: b) & not(a: c))


  RULE SimplifyX.54
	a: b-c == (a: b & not(a: c))


  RULE SimplifyX.55
	a: POW({x}) == (not(a = {}) => a = {x})


  RULE SimplifyX.56
	(bvrb(x)) &
	(bfresh(x,(a: POW(SET(x).P)),y))
	=>
	a: POW(SET(x).P) == !y.(y: a => [x:=y]P)


  RULE SimplifyX.57
	a: INT == (a: INTEGER & a<=maxint & minint<=a)


  RULE SimplifyX.58
	(btest(2<1))
	=>
	(__blankrule)


  RULE SimplifyX.59
	a: NAT == (a: INTEGER & 0<=a & a<=maxint)


  RULE SimplifyX.60
	a: NATURAL == (a: INTEGER & 0<=a)


  RULE SimplifyX.61
	a: NATURAL-{0} == (a: INTEGER & 0<=a & not(a = 0))


  RULE SimplifyX.62
	a: NAT-{0} == (a: INTEGER & 0<=a & a<=maxint & not(a = 0))


  RULE SimplifyX.63
	(bnot(bpattern(x,(y,z))))
	=>
	a: {x} == (a = x)


  RULE SimplifyX.64
	(bguard((SUB;RES): bresult([x:=a]P),R)) &
	(bnot(bpattern(R,[y:=z]S)))
	=>
	a: SET(x).P == R


  RULE SimplifyX.65
	{x}: POW(a) == (x: a)


  RULE SimplifyX.66
	x\/{y}: POW(a) == (y: a & x: POW(a))


  RULE SimplifyX.67
	(bvrb(x)) &
	(bfresh(x,(SET(x).P: POW(a)),y))
	=>
	SET(x).P: POW(a) == !y.([x:=y]P => y: a)


  RULE SimplifyX.68
	size(s) = 0 == (s = {})


  RULE SimplifyX.69
	a\/b = a == (b: POW(a))


  RULE SimplifyX.70
	a\/b = b == (a: POW(b))


  RULE SimplifyX.71
	a/\b = b == (b: POW(a))


  RULE SimplifyX.72
	a/\b = a == (a: POW(b))


  RULE SimplifyX.73
	a\/b = {} == (a = {} & b = {})


  RULE SimplifyX.74
	a/\{x} = {} == not(x: a)


  RULE SimplifyX.75
	a/\(x\/{y}) = {} == (not(y: a) & a/\x = {})


  RULE SimplifyX.76
	(bvrb(x)) &
	(bfresh(x,(a/\SET(x).P = {}),y))
	=>
	a/\SET(x).P = {} == !y.(y: a => not([x:=y]P))


  RULE SimplifyX.77
	a-b = {} == (a: POW(b))


  RULE SimplifyX.78
	a<|b = {} == (a/\dom(b) = {})


  RULE SimplifyX.79
	a<<|b = {} == (dom(b): POW(a))


  RULE SimplifyX.80
	a|>b = {} == (ran(a)/\b = {})


  RULE SimplifyX.81
	a|>>b = {} == (ran(a): POW(b))


  RULE SimplifyX.82
	x = E,F == (x = E|->F)


  RULE SimplifyX.83
	x,y = E,F == (y = F & x = E)


  RULE SimplifyX.84
	x|->y = E|->F == (y = F & x = E)


  RULE SimplifyX.85
	(bvrb(x)) &
	(bsearch((x: a),(P & Q),R))
	=>
	SET(x).(P & Q) = {} == !x.(x: a => not(R))


  RULE SimplifyX.86
	(bvrb(x)) &
	(bsearch((x = a),(P & Q),R))
	=>
	SET(x).(P & Q) = {} == !x.(x = a => not(R))


  RULE SimplifyX.87
	{} = a == (a = {})


  RULE SimplifyX.88
	(bguard((RecEqualityX~;RES): (rec(L) = rec(M)),R))
	=>
	rec(L) = rec(M) == R


  RULE SimplifyX.89
	not(not(a)) == a


  RULE SimplifyX.90
	(btest(a<=b))
	=>
	a<=b == btrue


  RULE SimplifyX.91
	(btest(b
	a<=b == bfalse


  RULE SimplifyX.92
	(bnum(a)) &
	(bnum(b)) &
	(btest(b/=a))
	=>
	a = b == bfalse


  RULE SimplifyX.93
	not(a <=> b) == ((not(a) => b) & (b => not(a)))


  RULE SimplifyX.94
	not(a or b) == (not(a) & not(b))


  RULE SimplifyX.95
	not(btrue) == bfalse


  RULE SimplifyX.96
	not(bfalse) == btrue


  RULE SimplifyX.97
	not(a => b) == (a & not(b))


  RULE SimplifyX.98
	(a or btrue) == btrue


  RULE SimplifyX.99
	(btrue or a) == btrue


  RULE SimplifyX.100
	(a or bfalse) == a


  RULE SimplifyX.101
	(bfalse or a) == a


  RULE SimplifyX.102
	(a or a) == a


  RULE SimplifyX.103
	(a & bfalse) == bfalse


  RULE SimplifyX.104
	(bfalse & a) == bfalse


  RULE SimplifyX.105
	(a & btrue) == a


  RULE SimplifyX.106
	(btrue & a) == a


  RULE SimplifyX.107
	(a & bfalse & bfalse) == bfalse


  RULE SimplifyX.108
	(bfalse & a & bfalse) == bfalse


  RULE SimplifyX.109
	(bfalse & bfalse & a) == bfalse


  RULE SimplifyX.110
	(a & btrue & btrue) == a


  RULE SimplifyX.111
	(btrue & a & btrue) == a


  RULE SimplifyX.112
	(btrue & btrue & a) == a


  RULE SimplifyX.113
	x = x == btrue


  RULE SimplifyX.114
	(a & x = x) == a


  RULE SimplifyX.115
	(x = x & a) == a


  RULE SimplifyX.116
	(a & x = x & y = y) == a


  RULE SimplifyX.117
	(x = x & a & y = y) == a


  RULE SimplifyX.118
	(x = x & y = y & a) == a


  RULE SimplifyX.119
	(bnum(i)) &
	(bnum(j)) &
	(btest(i/=j))
	=>
	i|->E = j|->E == bfalse


  RULE SimplifyX.120
	(bnum(i)) &
	(bnum(j)) &
	(btest(i/=j))
	=>
	not(i|->E = j|->E) == btrue


  RULE SimplifyX.121
	(bnum(i)) &
	(bnum(j)) &
	(btest(i/=j))
	=>
	(a & i|->E = j|->E) == bfalse


  RULE SimplifyX.122
	(bnum(i)) &
	(bnum(j)) &
	(btest(i/=j))
	=>
	(i|->E = j|->E & a) == bfalse


  RULE SimplifyX.123
	(bnum(i)) &
	(bnum(j)) &
	(btest(i/=j))
	=>
	(a & not(i|->E = j|->E)) == a


  RULE SimplifyX.124
	(bnum(i)) &
	(bnum(j)) &
	(btest(i/=j))
	=>
	(not(i|->E = j|->E) & a) == a


  RULE SimplifyX.125
	a: {} == bfalse


  RULE SimplifyX.126
	{b} = {} == bfalse



THEORY RecEqualityX IS



  RULE RecEqualityX.1
	(bresult(R & x = y))
	=>
	(Goal(l>>x | l>>y | R))


  RULE RecEqualityX.2
	(Goal(L | M | R & x = y))
	=>
	(Goal(L,l>>x | M,l>>y | R))


  RULE RecEqualityX.3
	(bresult(x = y))
	=>
	(rec(l>>x) = rec(l>>y))


  RULE RecEqualityX.4
	(Goal(L | M | x = y))
	=>
	(rec(L,l>>x) = rec(M,l>>y))



THEORY FindLabX IS



  RULE FindLabX.1
	__fl(rec(x>>v) | l)


  RULE FindLabX.2
	(bcall(RES: bresult(v)))
	=>
	(__fl(rec(l>>v) | l))


  RULE FindLabX.3
	(__fl(rec(L) | l))
	=>
	(__fl(rec(L,x>>v) | l))


  RULE FindLabX.4
	(bcall(RES: bresult(v)))
	=>
	(__fl(rec(L,l>>v) | l))



THEORY LabelRecX IS



  RULE LabelRecX.1
	(bcall((FLAT;RES): bresult(bflat(P & r'x: E))))
	=>
	(__labrec1(r | struct(x>>E) | P))


  RULE LabelRecX.2
	(__labrec1(r | struct(T) | bflat(P & r'x: E)))
	=>
	(__labrec1(r | struct(T,x>>E) | P))


  RULE LabelRecX.3
	(bcall(RES: bresult(r'x: E)))
	=>
	(__labrec(r | struct(x>>E)))


  RULE LabelRecX.4
	(__labrec1(r | struct(T) | r'x: E))
	=>
	(__labrec(r | struct(T,x>>E)))



THEORY AssociativityXY IS



  RULE AssociativityXY.1
	(binhyp(not(e: v))) &
	(blvar(Q)) &
	(Q\not(e: v))
	=>
	(u\/{e})-v == u-v\/{e}


  RULE AssociativityXY.2
	(binhyp(not(a: u))) &
	(blvar(Q)) &
	(Q\not(a: u))
	=>
	(u\/v-{a})-w == (u\/v)-w-{a}


  RULE AssociativityXY.3
	a-{e}-b == a-b-{e}


  RULE AssociativityXY.4
	a\/{x}\/b == a\/b\/{x}


  RULE AssociativityXY.5
	(s;(r;t)) == (s;r;t)


  RULE AssociativityXY.6
	a+(b+c) == a+b+c


  RULE AssociativityXY.7
	a+b+c == a+(b+c)


  RULE AssociativityXY.8
	a\/(b\/c) == a\/b\/c


  RULE AssociativityXY.9
	a/\(b/\c) == a/\b/\c


  RULE AssociativityXY.10
	r<+(s<+t) == r<+s<+t



THEORY CommutativityXY IS



  RULE CommutativityXY.1
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(n: INTEGER | Curr))) &
	(blvar(Q)) &
	(Q\n)
	=>
	n*p == p*n


  RULE CommutativityXY.2
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(p: INTEGER | Curr))) &
	(blvar(Q)) &
	(Q\p)
	=>
	n*p == p*n


  RULE CommutativityXY.3
	not(n = p) == not(p = n)


  RULE CommutativityXY.4
	a\/b == b\/a


  RULE CommutativityXY.5
	a/\b == b/\a


  RULE CommutativityXY.6
	n+(m-p) == n+m-p


  RULE CommutativityXY.7
	n-q+p == n+p-q


  RULE CommutativityXY.8
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(n: INTEGER | Curr))) &
	(blvar(Q)) &
	(Q\n)
	=>
	n*(p*q) == n*p*q


  RULE CommutativityXY.9
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(p: INTEGER | Curr))) &
	(blvar(Q)) &
	(Q\p)
	=>
	n*(p*q) == n*p*q


  RULE CommutativityXY.10
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(q: INTEGER | Curr))) &
	(blvar(Q)) &
	(Q\q)
	=>
	n*(p*q) == n*p*q


  RULE CommutativityXY.11
	a-c/\b == (a/\b)-c


  RULE CommutativityXY.12
	a\/b\/c == a\/c\/b


  RULE CommutativityXY.13
	a/\b/\c == a/\c/\b


  RULE CommutativityXY.14
	u<|(r|>v) == u<|r|>v


  RULE CommutativityXY.15
	u<|(r|>>v) == u<|r|>>v


  RULE CommutativityXY.16
	u<|r|>v == u<|(r|>v)


  RULE CommutativityXY.17
	u<<|r|>v == u<<|(r|>v)


  RULE CommutativityXY.18
	u<<|(r|>v) == u<<|r|>v


  RULE CommutativityXY.19
	u<<|(r|>>v) == u<<|r|>>v


  RULE CommutativityXY.20
	u<|r|>>v == u<|(r|>>v)


  RULE CommutativityXY.21
	u<<|r|>>v == u<<|(r|>>v)


  RULE CommutativityXY.22
	a\/b == b\/a


  RULE CommutativityXY.23
	a/\b == b/\a


  RULE CommutativityXY.24
	a\/b/\c == a/\c\/(b/\c)


  RULE CommutativityXY.25
	a\/b == b\/a


  RULE CommutativityXY.26
	a\/(b\/c) == a\/b\/c


  RULE CommutativityXY.27
	a/\(b/\c) == a/\b/\c


  RULE CommutativityXY.28
	r<+s<+t == r<+(s<+t)



THEORY SimplifySeqEnuXY IS



  RULE SimplifySeqEnuXY.1
	(btest(2<1))
	=>
	(__blankrule)


  RULE SimplifySeqEnuXY.2
	[a,b] == [a]\/{size([a])+1|->b}



THEORY SimplifyBoolXY IS



  RULE SimplifyBoolXY.1
	bool(bfalse) == FALSE


  RULE SimplifyBoolXY.2
	bool(btrue) == TRUE



THEORY SimplifyExistXY IS



  RULE SimplifyExistXY.1
	(bsearch((E = y),(P & R),Q)) &
	(IWD(expr(E),Z)) &
	(bsearch((E = y),(P & R),U,Z)) &
	(y\E) &
	(bsearch(y,(w,x),z)) &
	(bguard((SUB;RES): bresult([y:=E]U),S)) &
	(bnot(bpattern(S,[a:=b]T)))
	=>
	#(w,x).(P & R) == #z.[y:=E]U


  RULE SimplifyExistXY.2
	(bsearch((E = y),(P & R),Q)) &
	(bgetallhyp(H)) &
	(bsubfrm(E,toto,H,(I,?))) &
	(y\E) &
	(bsearch(y,(w,x),z)) &
	(z\E) &
	(bguard((SUB;RES): bresult([y:=E]Q),S)) &
	(bnot(bpattern(S,[a:=b]T)))
	=>
	#(w,x).(P & R) == #z.[y:=E]Q


  RULE SimplifyExistXY.3
	(bsearch((E = y),(P & R),Q)) &
	(WD(expr(E),Z)) &
	(y\E) &
	(bsearch(y,(w,x),z)) &
	(z\E) &
	(bguard((SUB;RES): bresult([y:=E]Q),S)) &
	(bnot(bpattern(S,[a:=b]T)))
	=>
	#(w,x).(P & R) == #z.[y:=E]Q


  RULE SimplifyExistXY.4
	(bsearch((y = E),(P & R),Q)) &
	(IWD(expr(E),Z)) &
	(bsearch((y = E),(P & R),U,Z)) &
	(y\E) &
	(bsearch(y,(w,x),z)) &
	(bguard((SUB;RES): bresult([y:=E]U),S)) &
	(bnot(bpattern(S,[a:=b]T)))
	=>
	#(w,x).(P & R) == #z.[y:=E]U


  RULE SimplifyExistXY.5
	(bsearch((y = E),(P & R),Q)) &
	(bgetallhyp(H)) &
	(bsubfrm(E,toto,H,(I,?))) &
	(y\E) &
	(bsearch(y,(w,x),z)) &
	(z\E) &
	(bguard((SUB;RES): bresult([y:=E]Q),S)) &
	(bnot(bpattern(S,[a:=b]T)))
	=>
	#(w,x).(P & R) == #z.[y:=E]Q


  RULE SimplifyExistXY.6
	(bsearch((y = E),(P & R),Q)) &
	(WD(expr(E),Z)) &
	(y\E) &
	(bsearch(y,(w,x),z)) &
	(z\E) &
	(bguard((SUB;RES): bresult([y:=E]Q),S)) &
	(bnot(bpattern(S,[a:=b]T)))
	=>
	#(w,x).(P & R) == #z.[y:=E]Q


  RULE SimplifyExistXY.7
	(bsearch((E = x),(P & R),Q)) &
	(IWD(expr(E),Z)) &
	(bsearch((x = E),(P & R),U,Z)) &
	(x\E) &
	(bguard((SUB;RES): bresult([x:=E]U),S)) &
	(bnot(bpattern(S,[a:=b]T)))
	=>
	#x.(P & R) == [x:=E]U


  RULE SimplifyExistXY.8
	(bsearch((E = x),(P & R),Q)) &
	(bgetallhyp(H)) &
	(bsubfrm(E,toto,H,(I,?))) &
	(x\E) &
	(bguard((SUB;RES): bresult([x:=E]Q),S)) &
	(bnot(bpattern(S,[a:=b]T)))
	=>
	#x.(P & R) == [x:=E]Q


  RULE SimplifyExistXY.9
	(bsearch((E = x),(P & R),Q)) &
	(WD(expr(E),Z)) &
	(x\E) &
	(bguard((SUB;RES): bresult([x:=E]Q),S)) &
	(bnot(bpattern(S,[a:=b]T)))
	=>
	#x.(P & R) == [x:=E]Q


  RULE SimplifyExistXY.10
	(bsearch((x = E),(P & R),Q)) &
	(IWD(expr(E),Z)) &
	(bsearch((x = E),(P & R),U,Z)) &
	(x\E) &
	(bguard((SUB;RES): bresult([x:=E]U),S)) &
	(bnot(bpattern(S,[a:=b]T)))
	=>
	#x.(P & R) == [x:=E]U


  RULE SimplifyExistXY.11
	(bsearch((x = E),(P & R),Q)) &
	(bgetallhyp(H)) &
	(bsubfrm(E,toto,H,(I,?))) &
	(x\E) &
	(bguard((SUB;RES): bresult([x:=E]Q),S)) &
	(bnot(bpattern(S,[a:=b]T)))
	=>
	#x.(P & R) == [x:=E]Q


  RULE SimplifyExistXY.12
	(bsearch((x = E),(P & R),Q)) &
	(WD(expr(E),Z)) &
	(x\E) &
	(bguard((SUB;RES): bresult([x:=E]Q),S)) &
	(bnot(bpattern(S,[a:=b]T)))
	=>
	#x.(P & R) == [x:=E]Q


  RULE SimplifyExistXY.13
	(x\E)
	=>
	#x.(x = E) == btrue



THEORY SimplifyFunctionXY IS



  RULE SimplifyFunctionXY.1
	(binhyp(L\/{a|->b}: s +-> t)) &
	(blvar(Q)) &
	(Q\(a,b,L)) &
	(bsearch({x|->y},L\/{a|->b},R))
	=>
	(L\/{a|->b})(x) == y


  RULE SimplifyFunctionXY.2
	%x.(bfalse | e) == {}


  RULE SimplifyFunctionXY.3
	f><{} == {}


  RULE SimplifyFunctionXY.4
	{}>

THEORY SimplifyIntMaxXY IS



  RULE SimplifyIntMaxXY.1
	(btest(q<=p))
	=>
	max({p}\/{q}) == p


  RULE SimplifyIntMaxXY.2
	(binhyp(q<=p)) &
	(blvar(Q)) &
	(Q\(q<=p))
	=>
	max({p}\/{q}) == p


  RULE SimplifyIntMaxXY.3
	(btest(p<=q))
	=>
	max({p}\/{q}) == q


  RULE SimplifyIntMaxXY.4
	(binhyp(p<=q)) &
	(blvar(Q)) &
	(Q\(p<=q))
	=>
	max({p}\/{q}) == q


  RULE SimplifyIntMaxXY.5
	(blvar(V)) &
	band((bsearch({a},L\/e,Q\/f)), 
	band((bsearch({b},Q\/f,R)), 
	band((V\(a,b)), 
	(bguard(PutInOrderX: PutInOrderG(a | b),PutInOrderR(A | B))))))
	=>
	max(L\/e) == max(R\/{B})


  RULE SimplifyIntMaxXY.6
	max(a..b) == b


  RULE SimplifyIntMaxXY.7
	max({max(s)}\/t) == max(s\/t)


  RULE SimplifyIntMaxXY.8
	max({p}) == p



THEORY SimplifyIntMinXY IS



  RULE SimplifyIntMinXY.1
	(binhyp(min(a)+1<=min(b))) &
	(blvar(Q)) &
	(Q\(min(a)+1<=min(b)))
	=>
	min(a-b) == min(a)


  RULE SimplifyIntMinXY.2
	(btest(b<=a))
	=>
	min({a}\/{b}) == b


  RULE SimplifyIntMinXY.3
	(binhyp(b<=a)) &
	(blvar(Q)) &
	(Q\(b<=a))
	=>
	min({a}\/{b}) == b


  RULE SimplifyIntMinXY.4
	(btest(a<=b))
	=>
	min({a}\/{b}) == a


  RULE SimplifyIntMinXY.5
	(binhyp(a<=b)) &
	(blvar(Q)) &
	(Q\(a<=b))
	=>
	min({a}\/{b}) == a


  RULE SimplifyIntMinXY.6
	(blvar(V)) &
	band((bsearch({a},L\/e,Q\/f)), 
	band((bsearch({b},Q\/f,R)), 
	band((V\(a,b)), 
	(bguard(PutInOrderX: PutInOrderG(a | b),PutInOrderR(A | B))))))
	=>
	min(L\/e) == min(R\/{A})


  RULE SimplifyIntMinXY.7
	min(p..q) == p


  RULE SimplifyIntMinXY.8
	min({min(s)}\/t) == min(s\/t)


  RULE SimplifyIntMinXY.9
	min(NATURAL) == 0


  RULE SimplifyIntMinXY.10
	min(NATURAL-{0}) == 1


  RULE SimplifyIntMinXY.11
	min({a}) == a



THEORY SimplifyIntPIXY IS



  RULE SimplifyIntPIXY.1
	(binhyp(f: S +-> T)) &
	(binhyp(not(s: S))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(dom(f) = S | Curr))) &
	(blvar(Q)) &
	(Q\(f: S +-> T)) &
	(Q\not(s: S)) &
	(x\(S,f,s))
	=>
	PI(x).(x: S | size((f\/{s|->y})(x))) == PI(x).(x: S | size(f(x)))


  RULE SimplifyIntPIXY.2
	(binhyp(f: S +-> T)) &
	(binhyp(not(s: dom(f)))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(dom(f) = S | Curr))) &
	(blvar(Q)) &
	(Q\(f: S +-> T)) &
	(Q\not(s: dom(f))) &
	(x\(S,f,s))
	=>
	PI(x).(x: S | size((f\/{s|->y})(x))) == PI(x).(x: S | size(f(x)))


  RULE SimplifyIntPIXY.3
	(binhyp(f: S +-> NATURAL)) &
	(binhyp(not(s: S))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(dom(f) = S | Curr))) &
	(blvar(Q)) &
	(Q\(f: S +-> NATURAL)) &
	(Q\not(s: S)) &
	(x\(S,f,s))
	=>
	PI(x).(x: S | (f\/{s|->y})(x)) == PI(x).(x: S | f(x))


  RULE SimplifyIntPIXY.4
	(binhyp(f: S +-> NATURAL)) &
	(binhyp(not(s: dom(f)))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(dom(f) = S | Curr))) &
	(blvar(Q)) &
	(Q\(f: S +-> NATURAL)) &
	(Q\not(s: dom(f))) &
	(x\(S,f,s))
	=>
	PI(x).(x: S | (f\/{s|->y})(x)) == PI(x).(x: S | f(x))


  RULE SimplifyIntPIXY.5
	(binhyp(not(b: a))) &
	(blvar(Q)) &
	(Q\not(b: a)) &
	(x\(a,b))
	=>
	PI(x).(x: a\/{b} | e) == PI(x).(x: a | e)*[x:=b]e


  RULE SimplifyIntPIXY.6
	(btest(2<1))
	=>
	(__blankrule)


  RULE SimplifyIntPIXY.7
	PI(x).(x: A & x: {} | e) == 1


  RULE SimplifyIntPIXY.8
	(x\a)
	=>
	PI(x).(x: {a} | e) == [x:=a]e



THEORY SimplifyIntParXY IS



  RULE SimplifyIntParXY.1
	(binhyp(p: r..q+1)) &
	(btest(q
	p == q+1


  RULE SimplifyIntParXY.2
	(binhyp(q+1<=p)) &
	(binhyp(p: r..q+1)) &
	(blvar(Q)) &
	(Q\(p: r..q+1))
	=>
	p == q+1



THEORY SimplifyIntSIGXY IS



  RULE SimplifyIntSIGXY.1
	(binhyp(f: S +-> T)) &
	(binhyp(not(s: S))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(dom(f) = S | Curr))) &
	(blvar(Q)) &
	(Q\(f: S +-> T)) &
	(Q\not(s: S)) &
	(x\(f,s,S))
	=>
	SIGMA(x).(x: S | size((f\/{s|->y})(x))) == SIGMA(x).(x: S | size(f(x)))


  RULE SimplifyIntSIGXY.2
	(binhyp(f: S +-> T)) &
	(binhyp(not(s: dom(f)))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(dom(f) = S | Curr))) &
	(blvar(Q)) &
	(Q\(f: S +-> T)) &
	(Q\not(s: dom(f))) &
	(x\(f,s,S))
	=>
	SIGMA(x).(x: S | size((f\/{s|->y})(x))) == SIGMA(x).(x: S | size(f(x)))


  RULE SimplifyIntSIGXY.3
	(binhyp(f: S +-> NATURAL)) &
	(binhyp(not(s: S))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(dom(f) = S | Curr))) &
	(blvar(Q)) &
	(Q\(f: S +-> NATURAL)) &
	(Q\not(s: S)) &
	(x\(f,s,S))
	=>
	SIGMA(x).(x: S | (f\/{s|->y})(x)) == SIGMA(x).(x: S | f(x))


  RULE SimplifyIntSIGXY.4
	(binhyp(f: S +-> NATURAL)) &
	(binhyp(not(s: dom(f)))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(dom(f) = S | Curr))) &
	(blvar(Q)) &
	(Q\(f: S +-> NATURAL)) &
	(Q\not(s: dom(f))) &
	(x\(f,s,S))
	=>
	SIGMA(x).(x: S | (f\/{s|->y})(x)) == SIGMA(x).(x: S | f(x))


  RULE SimplifyIntSIGXY.5
	(bnot(bpattern(x,(y,z)))) &
	(binhyp(not(b: a))) &
	(blvar(Q)) &
	(Q\not(b: a)) &
	(x\(a,b))
	=>
	SIGMA(x).(x: a\/{b} | e) == SIGMA(x).(x: a | e)+[x:=b]e


  RULE SimplifyIntSIGXY.6
	(blvar(Q)) &
	(Q\(a,b)) &
	(bnot(brule(DangerousExp.m,SIGMA(x).(x: a..b | e)))) &
	(bguard((ARI~;Fast_Prove_All_Order): a<=b)) &
	(bguard((ARI~;Fast_Prove_All_Order): b<=a+20)) &
	(bguard(TryEvalSigma: SIGMA(x).(x: a..b | e),T))
	=>
	SIGMA(x).(x: a..b | e) == T


  RULE SimplifyIntSIGXY.7
	(bsubfrm((x: INTEGER & 0<=x & a<=x & x<=b),(x: a..b/\NATURAL),P,Q))
	=>
	SIGMA(x).(P | e) == SIGMA(x).(Q | e)


  RULE SimplifyIntSIGXY.8
	(bsubfrm((x: INTEGER & 0<=x & x<=b & a<=x),(x: a..b/\NATURAL),P,Q))
	=>
	SIGMA(x).(P | e) == SIGMA(x).(Q | e)


  RULE SimplifyIntSIGXY.9
	(bsearch((x: p..q),P,r))
	=>
	SIGMA(x).(P | 0) == 0


  RULE SimplifyIntSIGXY.10
	(btest(2<1))
	=>
	(__blankrule)


  RULE SimplifyIntSIGXY.11
	(btest(2<1))
	=>
	(__blankrule)


  RULE SimplifyIntSIGXY.12
	(bnot(bpattern(x,(y,z)))) &
	(x\a)
	=>
	SIGMA(x).(x: {a} | e) == [x:=a]e


  RULE SimplifyIntSIGXY.13
	(bpattern(P,(u & v))) &
	band((bsearch(x<=q,P,r)), 
	(bsearch(p<=x,P,s)))
	=>
	SIGMA(x).(P | 0) == 0


  RULE SimplifyIntSIGXY.14
	SIGMA(x).(x: p..q | 0) == 0



THEORY SimplifyRelComXY IS



  RULE SimplifyRelComXY.1
	(binhyp(not(a: ran(r)))) &
	(blvar(Q)) &
	(Q\not(a: ran(r)))
	=>
	(r;{a}<<|s) == (r;s)


  RULE SimplifyRelComXY.2
	(binhyp(not(a: ran(r)))) &
	(blvar(Q)) &
	(Q\not(a: ran(r)))
	=>
	(r;{a|->b}) == {}


  RULE SimplifyRelComXY.3
	(binhyp(ran(s): POW(dom(t)))) &
	(blvar(Q)) &
	(Q\(ran(s): POW(dom(t))))
	=>
	(r<+s;t) == (r;t)<+(s;t)


  RULE SimplifyRelComXY.4
	(binhyp(r: u +-> v)) &
	(blvar(Q)) &
	(Q\(r: u +-> v))
	=>
	(r;s<+t) == (r;s)<+(r;t)


  RULE SimplifyRelComXY.5
	(binhyp(r: u +-> v)) &
	(blvar(Q)) &
	(Q\(r: u +-> v))
	=>
	(r;s/\t) == (r;s)/\(r;t)


  RULE SimplifyRelComXY.6
	(binhyp(r: u +-> v)) &
	(blvar(Q)) &
	(Q\(r: u +-> v))
	=>
	(r;s-t) == (r;s)-(r;t)


  RULE SimplifyRelComXY.7
	(binhyp(r: u +-> v)) &
	(blvar(Q)) &
	(Q\(r: u +-> v))
	=>
	(r;s><(r;t)


  RULE SimplifyRelComXY.8
	(binhyp(t~: u +-> v)) &
	(blvar(Q)) &
	(Q\(t~: u +-> v))
	=>
	(r/\s;t) == (r;t)/\(s;t)


  RULE SimplifyRelComXY.9
	(binhyp(t~: u +-> v)) &
	(blvar(Q)) &
	(Q\(t~: u +-> v))
	=>
	(r-s;t) == (r;t)-(s;t)


  RULE SimplifyRelComXY.10
	(binhyp(r: u +-> v)) &
	(blvar(Q)) &
	(Q\(r: u +-> v))
	=>
	(r~;r) == id(ran(r))


  RULE SimplifyRelComXY.11
	(binhyp(r~: u +-> v)) &
	(blvar(Q)) &
	(Q\(r~: u +-> v))
	=>
	(r;r~) == id(dom(r))


  RULE SimplifyRelComXY.12
	(r;u*v) == r~[u]*v


  RULE SimplifyRelComXY.13
	(r;(s;t)) == (r;s;t)


  RULE SimplifyRelComXY.14
	(r;id(u)) == r|>u


  RULE SimplifyRelComXY.15
	(r;u<|s) == (r|>u;s)


  RULE SimplifyRelComXY.16
	(r;s|>u) == (r;s)|>u


  RULE SimplifyRelComXY.17
	(r;u<<|s) == (r|>>u;s)


  RULE SimplifyRelComXY.18
	(r;s|>>u) == (r;s)|>>u


  RULE SimplifyRelComXY.19
	(r;s\/t) == (r;s)\/(r;t)


  RULE SimplifyRelComXY.20
	(r;{a|->b}) == r~[{a}]*{b}


  RULE SimplifyRelComXY.21
	(u*v;r) == u*r[v]


  RULE SimplifyRelComXY.22
	(id(u);r) == u<|r


  RULE SimplifyRelComXY.23
	(u<|r;s) == u<|(r;s)


  RULE SimplifyRelComXY.24
	(btest(2<1))
	=>
	(__blankrule)


  RULE SimplifyRelComXY.25
	(u<<|r;s) == u<<|(r;s)


  RULE SimplifyRelComXY.26
	(btest(2<1))
	=>
	(__blankrule)


  RULE SimplifyRelComXY.27
	(r\/s;t) == (r;t)\/(s;t)


  RULE SimplifyRelComXY.28
	(id(u);id(v)) == id(u/\v)


  RULE SimplifyRelComXY.29
	(p || q;(r || s)) == (p;r || (q;s))


  RULE SimplifyRelComXY.30
	(p><(q;s)


  RULE SimplifyRelComXY.31
	({a|->b};r) == {a}*r[{b}]


  RULE SimplifyRelComXY.32
	(r;{}) == {}


  RULE SimplifyRelComXY.33
	({};r) == {}



THEORY SimplifyRelDoaLongXY IS



  RULE SimplifyRelDoaLongXY.1
	u<<|(r<+s) == u<<|r<+(u<<|s)


  RULE SimplifyRelDoaLongXY.2
	u<<|(r><(u<<|s)


  RULE SimplifyRelDoaLongXY.3
	u<<|(r\/s) == u<<|r\/(u<<|s)


  RULE SimplifyRelDoaLongXY.4
	u<<|(r/\s) == u<<|r/\(u<<|s)


  RULE SimplifyRelDoaLongXY.5
	u\/v<<|r == u<<|r/\(v<<|r)


  RULE SimplifyRelDoaLongXY.6
	u/\v<<|r == u<<|r\/(v<<|r)


  RULE SimplifyRelDoaLongXY.7
	u-v<<|r == u<<|r\/(v<|r)



THEORY SimplifyRelDoaXY IS



  RULE SimplifyRelDoaXY.1
	INTEGER<<|r == {}


  RULE SimplifyRelDoaXY.2
	(binhyp(f: u +-> v)) &
	(blvar(Q)) &
	(Q\(f: u +-> v))
	=>
	f~[w]<<|f == f|>>w


  RULE SimplifyRelDoaXY.3
	(bguard(Fast_Prove_Difference: not(a = b))) &
	(blvar(Q)) &
	(Q\not(a = b))
	=>
	{a}<<|{b|->c} == {b|->c}


  RULE SimplifyRelDoaXY.4
	(binhyp(not(a: dom(r)))) &
	(blvar(Q)) &
	(Q\not(a: dom(r)))
	=>
	{a}<<|r == r


  RULE SimplifyRelDoaXY.5
	(binhyp(not(a: u))) &
	(blvar(Q)) &
	(Q\not(a: u))
	=>
	u<<|{a|->b} == {a|->b}


  RULE SimplifyRelDoaXY.6
	(binhyp(a: u)) &
	(blvar(Q)) &
	(Q\(a: u))
	=>
	u<<|{a|->b} == {}


  RULE SimplifyRelDoaXY.7
	(binhyp(dom(r): POW(u))) &
	(blvar(Q)) &
	(Q\(dom(r): POW(u)))
	=>
	u<<|r == {}


  RULE SimplifyRelDoaXY.8
	(binhyp(dom(r)/\u = {})) &
	(blvar(Q)) &
	(Q\(dom(r)/\u = {}))
	=>
	u<<|r == r


  RULE SimplifyRelDoaXY.9
	(binhyp(u/\dom(r) = {})) &
	(blvar(Q)) &
	(Q\(u/\dom(r) = {}))
	=>
	u<<|r == r


  RULE SimplifyRelDoaXY.10
	((x,y)\u)
	=>
	u<<|SET(x,y).(x: S & y: T & P) == SET(x,y).(x: S-u & y: T & P)


  RULE SimplifyRelDoaXY.11
	(x\u)
	=>
	u<<|%x.(x: S | E) == %x.(x: S-u | E)


  RULE SimplifyRelDoaXY.12
	(x\u)
	=>
	u<<|%x.(x: S & P | E) == %x.(x: S-u & P | E)


  RULE SimplifyRelDoaXY.13
	u<<|(r;s) == (u<<|r;s)


  RULE SimplifyRelDoaXY.14
	u<<|id(v) == id(v-u)


  RULE SimplifyRelDoaXY.15
	u<<|(v<|r) == v-u<|r


  RULE SimplifyRelDoaXY.16
	u<<|(v<<|r) == u\/v<<|r


  RULE SimplifyRelDoaXY.17
	u<<|v*t == (v-u)*t


  RULE SimplifyRelDoaXY.18
	u<<|u*v == {}


  RULE SimplifyRelDoaXY.19
	u<<|r-s == (u<<|r)-s


  RULE SimplifyRelDoaXY.20
	dom(r)<<|r == {}


  RULE SimplifyRelDoaXY.21
	u<<|{} == {}


  RULE SimplifyRelDoaXY.22
	{}<<|r == r


  RULE SimplifyRelDoaXY.23
	{a}<<|{a|->b} == {}



THEORY SimplifyRelDomXY IS



  RULE SimplifyRelDomXY.1
	(binhyp(ran(r): POW(dom(s)))) &
	(blvar(Q)) &
	(Q\(ran(r): POW(dom(s))))
	=>
	dom(r;s) == dom(r)


  RULE SimplifyRelDomXY.2
	(binhyp(not(v = {}))) &
	(blvar(Q)) &
	(Q\v)
	=>
	dom(u*v) == u


  RULE SimplifyRelDomXY.3
	(binhyp(f: A +-> B)) &
	(binhyp(g: POW(f))) &
	(blvar(Q)) &
	(Q\(f: A +-> B & g: POW(f)))
	=>
	dom(f-g) == dom(f)-dom(g)


  RULE SimplifyRelDomXY.4
	(binhyp(r: s +-> t)) &
	(blvar(Q)) &
	(Q\(r: s +-> t))
	=>
	dom(r|>>u) == dom(r)-r~[u]


  RULE SimplifyRelDomXY.5
	dom(%x.(P | e)) == SET(x).P


  RULE SimplifyRelDomXY.6
	dom(r;s) == r~[dom(s)]


  RULE SimplifyRelDomXY.7
	dom(u*{a}) == u


  RULE SimplifyRelDomXY.8
	dom(id(s)) == s


  RULE SimplifyRelDomXY.9
	dom(succ) == INTEGER


  RULE SimplifyRelDomXY.10
	dom(pred) == INTEGER


  RULE SimplifyRelDomXY.11
	dom(u<|r) == u/\dom(r)


  RULE SimplifyRelDomXY.12
	dom(r|>u) == r~[u]


  RULE SimplifyRelDomXY.13
	dom(u<<|r) == dom(r)-u


  RULE SimplifyRelDomXY.14
	dom(r~) == ran(r)


  RULE SimplifyRelDomXY.15
	dom(r<+s) == dom(r)\/dom(s)


  RULE SimplifyRelDomXY.16
	dom(r>
	dom({a|->b}) == {a}


  RULE SimplifyRelDomXY.22
	dom({}) == {}


  RULE SimplifyRelDomXY.23
	(bnot(bpattern(d,(e,f))))
	=>
	dom({(c,d)|->b}) == dom({c|->b})*{d}



THEORY SimplifyRelDorLongXY IS



  RULE SimplifyRelDorLongXY.1
	u<|(r<+s) == u<|r<+(u<|s)


  RULE SimplifyRelDorLongXY.2
	u<|(r><(u<|s)


  RULE SimplifyRelDorLongXY.3
	a<|(r\/s) == a<|r\/(a<|s)


  RULE SimplifyRelDorLongXY.4
	u<|(r/\s) == u<|r/\(u<|s)


  RULE SimplifyRelDorLongXY.5
	u/\v<|r == u<|r/\(v<|r)


  RULE SimplifyRelDorLongXY.6
	a\/b<|r == a<|r\/(b<|r)


  RULE SimplifyRelDorLongXY.7
	u-v<|r == (u<|r)-(v<|r)



THEORY SimplifyRelDorXY IS



  RULE SimplifyRelDorXY.1
	(binhyp(not(a: dom(f)))) &
	(blvar(Q)) &
	(Q\(a: dom(f)))
	=>
	{a}<|(f\/{a|->b}) == {a|->b}


  RULE SimplifyRelDorXY.2
	(binhyp(f: u +-> v)) &
	(binhyp(a: dom(f))) &
	(blvar(Q)) &
	(Q\(f: u +-> v)) &
	(Q\(a: dom(f)))
	=>
	{a}<|f == {a|->f(a)}


  RULE SimplifyRelDorXY.3
	(binhyp(not(a: dom(r)))) &
	(blvar(Q)) &
	(Q\not(a: dom(r)))
	=>
	{a}<|r == {}


  RULE SimplifyRelDorXY.4
	(binhyp(not(b: ran(r)))) &
	(blvar(Q)) &
	(Q\not(b: ran(r)))
	=>
	{b}<|r~ == {}


  RULE SimplifyRelDorXY.5
	(binhyp(f: u +-> v)) &
	(blvar(Q)) &
	(Q\(f: u +-> v))
	=>
	f~[w]<|f == f|>w


  RULE SimplifyRelDorXY.6
	(binhyp(u/\dom(r) = {})) &
	(blvar(Q)) &
	(Q\(u/\dom(r) = {}))
	=>
	u<|(r;s) == {}


  RULE SimplifyRelDorXY.7
	(binhyp(a: u)) &
	(blvar(Q)) &
	(Q\(a: u))
	=>
	u<|{a|->b} == {a|->b}


  RULE SimplifyRelDorXY.8
	(binhyp(not(a: u))) &
	(blvar(Q)) &
	(Q\(a: u))
	=>
	u<|{a|->b} == {}


  RULE SimplifyRelDorXY.9
	(binhyp(dom(r): POW(u))) &
	(blvar(Q)) &
	(Q\(dom(r): POW(u)))
	=>
	u<|r == r


  RULE SimplifyRelDorXY.10
	(binhyp(u/\dom(r) = {})) &
	(blvar(Q)) &
	(Q\(u/\dom(r) = {}))
	=>
	u<|r == {}


  RULE SimplifyRelDorXY.11
	(binhyp(dom(r)/\u = {})) &
	(blvar(Q)) &
	(Q\(dom(r)/\u = {}))
	=>
	u<|r == {}


  RULE SimplifyRelDorXY.12
	(bguard(Fast_Prove_Difference: not(a = b))) &
	(blvar(Q)) &
	(Q\not(a = b))
	=>
	{a}<|{b|->c} == {}


  RULE SimplifyRelDorXY.13
	(x\u)
	=>
	u<|%x.(x: S | E) == %x.(x: u/\S | E)


  RULE SimplifyRelDorXY.14
	(x\u)
	=>
	u<|%x.(x: S & P | E) == %x.(x: u/\S & P | E)


  RULE SimplifyRelDorXY.15
	((x,y)\u)
	=>
	u<|SET(x,y).(x: S & y: T & P) == SET(x,y).(x: u/\S & y: T & P)


  RULE SimplifyRelDorXY.16
	u<|id(v) == id(u/\v)


  RULE SimplifyRelDorXY.17
	u<|v*w == (u/\v)*w


  RULE SimplifyRelDorXY.18
	u<|u*v == u*v


  RULE SimplifyRelDorXY.19
	u<|(v<|r) == u/\v<|r


  RULE SimplifyRelDorXY.20
	u<|(v<<|r) == u-v<|r


  RULE SimplifyRelDorXY.21
	u*v<|(r || s) == (u<|r || v<|s)


  RULE SimplifyRelDorXY.22
	u<|r-s == (u<|r)-s


  RULE SimplifyRelDorXY.23
	{a}<|{a|->b} == {a|->b}


  RULE SimplifyRelDorXY.24
	dom(r)<|r == r


  RULE SimplifyRelDorXY.25
	ran(r)<|r~ == r~


  RULE SimplifyRelDorXY.26
	u<|{} == {}


  RULE SimplifyRelDorXY.27
	{}<|r == {}



THEORY SimplifyRelFonXY IS



  RULE SimplifyRelFonXY.1
	(binhyp(c: C*{a})) &
	(blvar(Q)) &
	(Q\(c: C*{a}))
	=>
	prj2(A,B)(c) == a


  RULE SimplifyRelFonXY.2
	id(u)(a) == a


  RULE SimplifyRelFonXY.3
	(binhyp(r: s +-> t)) &
	(blvar(Q)) &
	(Q\(r: s +-> t))
	=>
	(u<|r)(a) == r(a)


  RULE SimplifyRelFonXY.4
	(binhyp(r: s +-> t)) &
	(blvar(Q)) &
	(Q\(r: s +-> t))
	=>
	(u<<|r)(a) == r(a)


  RULE SimplifyRelFonXY.5
	(binhyp(r: s +-> t)) &
	(blvar(Q)) &
	(Q\(r: s +-> t))
	=>
	(r|>u)(a) == r(a)


  RULE SimplifyRelFonXY.6
	(binhyp(r: s +-> t)) &
	(blvar(Q)) &
	(Q\(r: s +-> t))
	=>
	(r|>>u)(a) == r(a)


  RULE SimplifyRelFonXY.7
	(binhyp(r: u +-> v)) &
	(binhyp(not(a: dom(s)))) &
	(blvar(Q)) &
	(Q\(not(a: dom(s)) & r: u +-> v))
	=>
	(r<+s)(a) == r(a)


  RULE SimplifyRelFonXY.8
	(binhyp(a: dom(s))) &
	(blvar(Q)) &
	(Q\(a: dom(s)))
	=>
	(r<+s)(a) == s(a)


  RULE SimplifyRelFonXY.9
	band((binhyp(r: u +-> v)), 
	(binhyp(c: dom(r)))) &
	(bguard(Fast_Prove_Difference: not(a = c))) &
	(blvar(Q)) &
	(Q\(not(a = c) & c: dom(r) & r: u +-> v))
	=>
	(r<+{a|->b})(c) == r(c)


  RULE SimplifyRelFonXY.10
	(r<+{a|->b})(a) == b


  RULE SimplifyRelFonXY.11
	(binhyp(r: u +-> t)) &
	(binhyp(s: v +-> w)) &
	(blvar(Q)) &
	(Q\(r,s))
	=>
	(r>s(a)


  RULE SimplifyRelFonXY.12
	(binhyp(f: s +-> t)) &
	(blvar(Q)) &
	(Q\(f: s +-> t))
	=>
	(f/\g)(a) == f(a)


  RULE SimplifyRelFonXY.13
	(binhyp(g: s +-> t)) &
	(blvar(Q)) &
	(Q\(g: s +-> t))
	=>
	(f/\g)(a) == g(a)


  RULE SimplifyRelFonXY.14
	(binhyp(a: dom(r))) &
	(blvar(Q)) &
	(Q\(a: dom(r) & s))
	=>
	(r\/s)(a) == r(a)


  RULE SimplifyRelFonXY.15
	(binhyp(a: dom(s))) &
	(blvar(Q)) &
	(Q\(a: dom(s) & r))
	=>
	(r\/s)(a) == s(a)


  RULE SimplifyRelFonXY.16
	(bguard(Fast_Prove_Difference: not(a = c))) &
	(blvar(Q)) &
	(Q\(c: dom(r<+{a|->b})))
	=>
	(r\/{a|->b})(c) == r(c)


  RULE SimplifyRelFonXY.17
	(r\/{a|->b})(a) == b


  RULE SimplifyRelFonXY.18
	(binhyp(r: u +-> v)) &
	(blvar(Q)) &
	(Q\(r: u +-> v))
	=>
	(r-s)(a) == r(a)


  RULE SimplifyRelFonXY.19
	(binhyp(f: A +-> B)) &
	(binhyp(g: C +-> D)) &
	(blvar(Q)) &
	(Q\(x & f: A +-> B & g: C +-> D))
	=>
	(f;g)(x) == g(f(x))


  RULE SimplifyRelFonXY.20
	r~(r(a)) == a


  RULE SimplifyRelFonXY.21
	r(r~(a)) == a


  RULE SimplifyRelFonXY.22
	(bguard((SUB;RES): bresult([x:=a]E),R)) &
	(bnot(bpattern(R,[y:=z]S)))
	=>
	(%x.(P | E))(a) == R


  RULE SimplifyRelFonXY.23
	(binhyp(c: {a}*C)) &
	(blvar(Q)) &
	(Q\(c: {a}*C))
	=>
	prj1(A,B)(c) == a


  RULE SimplifyRelFonXY.24
	prj1(u,v)(a|->b) == a


  RULE SimplifyRelFonXY.25
	prj2(u,v)(a|->b) == b


  RULE SimplifyRelFonXY.26
	(A*{y})(x) == y


  RULE SimplifyRelFonXY.27
	(bguard(Fast_Prove_Num: x))
	=>
	succ(x) == x+1


  RULE SimplifyRelFonXY.28
	(bguard(Fast_Prove_Num: x))
	=>
	pred(x) == x-1


  RULE SimplifyRelFonXY.29
	{a|->b}(a) == b


  RULE SimplifyRelFonXY.30
	([a,b])(size([a,b])-1) == ([a])(size([a]))


  RULE SimplifyRelFonXY.31
	(bnot(bpattern(a,(u,v))))
	=>
	([a])(size([a])) == a


  RULE SimplifyRelFonXY.32
	([a,b])(size([a,b])) == b


  RULE SimplifyRelFonXY.33
	(bnot(bpattern(a,(u,v))))
	=>
	([a])(1) == a


  RULE SimplifyRelFonXY.34
	([a,b])(1) == ([a])(1)


  RULE SimplifyRelFonXY.35
	{a}b == {a}(b)


  RULE SimplifyRelFonXY.36
	(a\/{b})c == (a\/{b})(c)



THEORY SimplifyRelId IS



  RULE SimplifyRelId.1
	id(u\/v) == id(u)\/id(v)


  RULE SimplifyRelId.2
	id(u/\v) == id(u)/\id(v)


  RULE SimplifyRelId.3
	id(u-v) == id(u)-id(v)


  RULE SimplifyRelId.4
	id({a}) == {a|->a}


  RULE SimplifyRelId.5
	id({}) == {}



THEORY SimplifyRelImaLongXY IS



  RULE SimplifyRelImaLongXY.1
	(binhyp(r|>ran(s) = s|>ran(r))) &
	(blvar(Q)) &
	(Q\(r/\s))
	=>
	(r/\s)[u] == r[u]/\s[u]


  RULE SimplifyRelImaLongXY.2
	(binhyp(r|>ran(s) = s|>ran(r))) &
	(blvar(Q)) &
	(Q\r-s)
	=>
	(r-s)[u] == r[u]-s[u]


  RULE SimplifyRelImaLongXY.3
	(binhyp(r~: t +-> s)) &
	(blvar(Q)) &
	(Q\(r~: t +-> s))
	=>
	r[u/\v] == r[u]/\r[v]


  RULE SimplifyRelImaLongXY.4
	(binhyp(r~: t +-> s)) &
	(blvar(Q)) &
	(Q\(r~: t +-> s))
	=>
	r[u-v] == r[u]-r[v]


  RULE SimplifyRelImaLongXY.5
	(r\/s)[u] == r[u]\/s[u]


  RULE SimplifyRelImaLongXY.6
	r[u\/v] == r[u]\/r[v]



THEORY SimplifyRelImaXY IS



  RULE SimplifyRelImaXY.1
	(binhyp(dom(r): POW(A))) &
	(blvar(Q)) &
	(Q\(dom(r): POW(A)))
	=>
	r[A] == ran(r)


  RULE SimplifyRelImaXY.2
	(binhyp(r: A +-> B)) &
	(binhyp(a: ran(r))) &
	(blvar(Q)) &
	(Q\(r: A +-> B & a: ran(r)))
	=>
	r[{r~(a)}] == {a}


  RULE SimplifyRelImaXY.3
	(binhyp(not(B = {}))) &
	(blvar(Q)) &
	(Q\B)
	=>
	prj1(A,B)[A*B] == A


  RULE SimplifyRelImaXY.4
	(binhyp(not(A = {}))) &
	(blvar(Q)) &
	(Q\A)
	=>
	prj2(A,B)[A*B] == B


  RULE SimplifyRelImaXY.5
	(binhyp(r: POW(s))) &
	(blvar(Q)) &
	(Q\(r: POW(s)))
	=>
	r[dom(s)] == ran(r)


  RULE SimplifyRelImaXY.6
	(binhyp(r: POW(s~))) &
	(blvar(Q)) &
	(Q\(r: POW(s~)))
	=>
	r[ran(s)] == ran(r)


  RULE SimplifyRelImaXY.7
	(bguard(Fast_Prove_Difference: not(a = b))) &
	(blvar(Q)) &
	(Q\not(a = b))
	=>
	({a}*v)[{b}] == {}


  RULE SimplifyRelImaXY.8
	(binhyp(not(u = {}))) &
	(blvar(Q)) &
	(Q\u)
	=>
	(u*v)[u] == v


  RULE SimplifyRelImaXY.9
	(binhyp(not(u/\w = {}))) &
	(blvar(Q)) &
	(Q\not(u/\w = {}))
	=>
	(u*v)[w] == v


  RULE SimplifyRelImaXY.10
	(binhyp(u/\w = {})) &
	(blvar(Q)) &
	(Q\(u/\w = {}))
	=>
	(u*v)[w] == {}


  RULE SimplifyRelImaXY.11
	(binhyp(dom(r)/\u = {})) &
	(blvar(Q)) &
	(Q\(dom(r)/\u = {}))
	=>
	r[u] == {}


  RULE SimplifyRelImaXY.12
	(binhyp(u/\dom(r) = {})) &
	(blvar(Q)) &
	(Q\(u/\dom(r) = {}))
	=>
	r[u] == {}


  RULE SimplifyRelImaXY.13
	(binhyp(f(a) = b)) &
	(binhyp(a: dom(f))) &
	(blvar(Q)) &
	(Q\(f(a) = b))
	=>
	f[{a}] == {b}


  RULE SimplifyRelImaXY.14
	(binhyp(not(a: ran(r)))) &
	(blvar(Q)) &
	(Q\(a: ran(r)))
	=>
	r~[{a}] == {}


  RULE SimplifyRelImaXY.15
	(binhyp(not(a: dom(r)))) &
	(blvar(Q)) &
	(Q\(a: dom(r)))
	=>
	r[{a}] == {}


  RULE SimplifyRelImaXY.16
	band((binhyp(r: u +-> v)), 
	(binhyp(a: dom(r)))) &
	(blvar(Q)) &
	(Q\(r: u +-> v)) &
	(Q\(a: dom(r)))
	=>
	r[{a}] == {r(a)}


  RULE SimplifyRelImaXY.17
	(binhyp(not(a: u))) &
	(blvar(Q)) &
	(Q\not(a: u))
	=>
	{a|->b}[u] == {}


  RULE SimplifyRelImaXY.18
	(binhyp(a: u)) &
	(blvar(Q)) &
	(Q\(a: u))
	=>
	{a|->b}[u] == {b}


  RULE SimplifyRelImaXY.19
	(bguard(Fast_Prove_Difference: not(a = c))) &
	(blvar(Q)) &
	(Q\not(a = c))
	=>
	{a|->b}[{c}] == {}


  RULE SimplifyRelImaXY.20
	succ[a..b] == succ(a)..succ(b)


  RULE SimplifyRelImaXY.21
	pred[a..b] == pred(a)..pred(b)


  RULE SimplifyRelImaXY.22
	id(u)[v] == u/\v


  RULE SimplifyRelImaXY.23
	(r;s)[v] == s[r[v]]


  RULE SimplifyRelImaXY.24
	(u<|r)[v] == r[u/\v]


  RULE SimplifyRelImaXY.25
	(u<<|r)[v] == r[v-u]


  RULE SimplifyRelImaXY.26
	(u<<|r)[u] == {}


  RULE SimplifyRelImaXY.27
	(r|>u)[v] == r[v]/\u


  RULE SimplifyRelImaXY.28
	(r|>>u)[v] == r[v]-u


  RULE SimplifyRelImaXY.29
	(u<<|r)~[v] == r~[v]-u


  RULE SimplifyRelImaXY.30
	(r|>u)~[u] == r~[u]


  RULE SimplifyRelImaXY.31
	(r|>>u)~[u] == {}


  RULE SimplifyRelImaXY.32
	(r<+s)[u] == (dom(s)<<|r)[u]\/s[u]


  RULE SimplifyRelImaXY.33
	(r>a}[{TRUE}] == {}


  RULE SimplifyRelImaXY.37
	{TRUE|->a}[{FALSE}] == {}


  RULE SimplifyRelImaXY.38
	r[{}] == {}


  RULE SimplifyRelImaXY.39
	{}[a] == {}


  RULE SimplifyRelImaXY.40
	r[dom(r)] == ran(r)


  RULE SimplifyRelImaXY.41
	r~[ran(r)] == dom(r)


  RULE SimplifyRelImaXY.42
	{a|->b}[{a}] == {b}



THEORY SimplifyRelInvXY IS



  RULE SimplifyRelInvXY.1
	(bnot(bpattern(x,(u,v))))
	=>
	(SET(x,y).P)~ == SET(y,x).P


  RULE SimplifyRelInvXY.2
	{a|->b}~ == {b|->a}


  RULE SimplifyRelInvXY.3
	id(u)~ == id(u)


  RULE SimplifyRelInvXY.4
	(r;s)~ == (s~;r~)


  RULE SimplifyRelInvXY.5
	(r<+s)~ == r~|>>dom(s)\/s~


  RULE SimplifyRelInvXY.6
	(u<|r)~ == r~|>u


  RULE SimplifyRelInvXY.7
	(u<<|r)~ == r~|>>u


  RULE SimplifyRelInvXY.8
	(r|>u)~ == u<|r~


  RULE SimplifyRelInvXY.9
	(r|>>u)~ == u<<|r~


  RULE SimplifyRelInvXY.10
	(u*v)~ == v*u


  RULE SimplifyRelInvXY.11
	(r || s)~ == (r~ || s~)


  RULE SimplifyRelInvXY.12
	(r/\s)~ == r~/\s~


  RULE SimplifyRelInvXY.13
	(r\/s)~ == r~\/s~


  RULE SimplifyRelInvXY.14
	(r-s)~ == r~-s~


  RULE SimplifyRelInvXY.15
	r~~ == r


  RULE SimplifyRelInvXY.16
	{}~ == {}


  RULE SimplifyRelInvXY.17
	pred~ == succ


  RULE SimplifyRelInvXY.18
	succ~ == pred



THEORY SimplifyRelOveXY IS



  RULE SimplifyRelOveXY.1
	(binhyp(dom(s)<|r = dom(r)<|s)) &
	(blvar(Q)) &
	(Q\(dom(s)<|r = dom(r)<|s))
	=>
	r<+s == r\/s


  RULE SimplifyRelOveXY.2
	(bguard(Fast_Prove_Difference: not(a = c))) &
	(blvar(Q)) &
	(Q\(a = c))
	=>
	{a|->b}<+{c|->d} == {a|->b}\/{c|->d}


  RULE SimplifyRelOveXY.3
	(binhyp(not(a: ran(r)))) &
	(blvar(Q)) &
	(Q\(a: ran(r)))
	=>
	r~<+{a|->b} == r~\/{a|->b}


  RULE SimplifyRelOveXY.4
	(f;g)<+{x|->g(d)} == (f<+{x|->d};g)


  RULE SimplifyRelOveXY.5
	f<+{x|->f(x)} == f


  RULE SimplifyRelOveXY.6
	(binhyp(g: POW(f))) &
	(binhyp(f: s +-> t)) &
	(blvar(Q)) &
	(Q\(g: POW(f)))
	=>
	f<+g == f


  RULE SimplifyRelOveXY.7
	(binhyp(not(x: dom(g)))) &
	(blvar(Q)) &
	(Q\(x: dom(g)))
	=>
	f<+g<+{x|->y} == f<+{x|->y}<+g


  RULE SimplifyRelOveXY.8
	(bnot(band(bpattern(s,{a}),bpattern(t,{b}))))
	=>
	r<+(s<+t) == r<+s<+t


  RULE SimplifyRelOveXY.9
	r<+{a}<+{b} == r<+({a}<+{b})


  RULE SimplifyRelOveXY.10
	u*{b}<+{a|->b} == (u\/{a})*{b}


  RULE SimplifyRelOveXY.11
	{a}*v<+{a|->b} == {a|->b}


  RULE SimplifyRelOveXY.12
	{}<+r == r


  RULE SimplifyRelOveXY.13
	r<+{} == r


  RULE SimplifyRelOveXY.14
	{a|->b}<+{a|->c} == {a|->c}



THEORY SimplifyRelRaaLongXY IS



  RULE SimplifyRelRaaLongXY.1
	r<+s|>>v == dom(s)<<|r|>>v\/(s|>>v)


  RULE SimplifyRelRaaLongXY.2
	r|>>(u\/v) == r|>>u/\(r|>>v)


  RULE SimplifyRelRaaLongXY.3
	r|>>(u/\v) == r|>>u\/(r|>>v)


  RULE SimplifyRelRaaLongXY.4
	r|>>u-v == r|>>u\/(r|>v)


  RULE SimplifyRelRaaLongXY.5
	r/\s|>>u == r|>>u/\(s|>>u)


  RULE SimplifyRelRaaLongXY.6
	r\/s|>>u == r|>>u\/(s|>>u)



THEORY SimplifyRelRaaXY IS



  RULE SimplifyRelRaaXY.1
	(bguard(Fast_Prove_Difference: not(b = c))) &
	(blvar(Q)) &
	(Q\not(b = c))
	=>
	{a|->b}|>>{c} == {a|->b}


  RULE SimplifyRelRaaXY.2
	(binhyp(not(a: ran(r)))) &
	(blvar(Q)) &
	(Q\not(a: ran(r)))
	=>
	r|>>{a} == r


  RULE SimplifyRelRaaXY.3
	(binhyp(not(b: u))) &
	(blvar(Q)) &
	(Q\not(b: u))
	=>
	{a|->b}|>>u == {a|->b}


  RULE SimplifyRelRaaXY.4
	(binhyp(b: u)) &
	(blvar(Q)) &
	(Q\(b: u))
	=>
	{a|->b}|>>u == {}


  RULE SimplifyRelRaaXY.5
	(binhyp(ran(r): POW(u))) &
	(blvar(Q)) &
	(Q\(ran(r): POW(u)))
	=>
	r|>>u == {}


  RULE SimplifyRelRaaXY.6
	(binhyp(ran(r)/\u = {})) &
	(blvar(Q)) &
	(Q\(ran(r)/\u = {}))
	=>
	r|>>u == r


  RULE SimplifyRelRaaXY.7
	(binhyp(u/\ran(r) = {})) &
	(blvar(Q)) &
	(Q\(u/\ran(r) = {}))
	=>
	r|>>u == r


  RULE SimplifyRelRaaXY.8
	(binhyp(f~: u +-> v)) &
	(blvar(Q)) &
	(Q\(f~: u +-> v))
	=>
	f|>>f[w] == w<<|f


  RULE SimplifyRelRaaXY.9
	(binhyp(not(a: dom(r)))) &
	(blvar(Q)) &
	(Q\(a: dom(r)))
	=>
	r~|>>{a} == r~


  RULE SimplifyRelRaaXY.10
	((x,y)\u)
	=>
	SET(x,y).(x: S & y: T & P)|>>u == SET(x,y).(x: S & y: T-u & P)


  RULE SimplifyRelRaaXY.11
	(r;s)|>>u == (r;s|>>u)


  RULE SimplifyRelRaaXY.12
	id(u)|>>v == id(u-v)


  RULE SimplifyRelRaaXY.13
	r|>u|>>v == r|>u-v


  RULE SimplifyRelRaaXY.14
	r|>>u|>>v == r|>>(u\/v)


  RULE SimplifyRelRaaXY.15
	u*v|>>t == u*(v-t)


  RULE SimplifyRelRaaXY.16
	u*v|>>v == {}


  RULE SimplifyRelRaaXY.17
	r-s|>>u == (r|>>u)-s


  RULE SimplifyRelRaaXY.18
	r|>>ran(r) == {}


  RULE SimplifyRelRaaXY.19
	{}|>>u == {}


  RULE SimplifyRelRaaXY.20
	r|>>{} == r


  RULE SimplifyRelRaaXY.21
	{a|->b}|>>{b} == {}



THEORY SimplifyRelRanXY IS



  RULE SimplifyRelRanXY.1
	(binhyp(r~: s +-> t)) &
	(blvar(Q)) &
	(Q\(r~: s +-> t))
	=>
	ran(u<<|r) == ran(r)-r[u]


  RULE SimplifyRelRanXY.2
	(binhyp(not(u = {}))) &
	(blvar(Q)) &
	(Q\u)
	=>
	ran(u*v) == v


  RULE SimplifyRelRanXY.3
	(binhyp(g: POW(f))) &
	(binhyp(f~: b +-> a)) &
	(blvar(Q)) &
	(Q\(f~: b +-> a & g: POW(f)))
	=>
	ran(f-g) == ran(f)-ran(g)


  RULE SimplifyRelRanXY.4
	(binhyp(not(B = {}))) &
	(blvar(Q)) &
	(Q\B)
	=>
	ran(prj1(A,B)) == A


  RULE SimplifyRelRanXY.5
	(binhyp(not(A = {}))) &
	(blvar(Q)) &
	(Q\A)
	=>
	ran(prj2(A,B)) == B


  RULE SimplifyRelRanXY.6
	ran(succ) == INTEGER


  RULE SimplifyRelRanXY.7
	ran(pred) == INTEGER


  RULE SimplifyRelRanXY.8
	ran(r;s) == s[ran(r)]


  RULE SimplifyRelRanXY.9
	ran(id(u)) == u


  RULE SimplifyRelRanXY.10
	ran(r|>u) == ran(r)/\u


  RULE SimplifyRelRanXY.11
	ran(r|>>u) == ran(r)-u


  RULE SimplifyRelRanXY.12
	ran(r~) == dom(r)


  RULE SimplifyRelRanXY.13
	ran(r<+s) == ran(dom(s)<<|r)\/ran(s)


  RULE SimplifyRelRanXY.14
	ran({a}*v) == v


  RULE SimplifyRelRanXY.15
	ran(r || s) == ran(r)*ran(s)


  RULE SimplifyRelRanXY.16
	ran(f>b}) == {b}


  RULE SimplifyRelRanXY.19
	ran({}) == {}


  RULE SimplifyRelRanXY.20
	ran(u<|r) == r[u]



THEORY SimplifyRelRarLongXY IS



  RULE SimplifyRelRarLongXY.1
	r<+s|>a == dom(s)<<|r|>a\/(s|>a)


  RULE SimplifyRelRarLongXY.2
	r/\s|>a == r|>a/\(s|>a)


  RULE SimplifyRelRarLongXY.3
	r\/s|>a == r|>a\/(s|>a)


  RULE SimplifyRelRarLongXY.4
	r|>a-b == (r|>a)-(r|>b)


  RULE SimplifyRelRarLongXY.5
	r|>(a/\b) == r|>a/\(r|>b)


  RULE SimplifyRelRarLongXY.6
	r|>(a\/b) == r|>a\/(r|>b)



THEORY SimplifyRelRarXY IS



  RULE SimplifyRelRarXY.1
	(binhyp(not(b: ran(f)))) &
	(blvar(Q)) &
	(Q\(b: ran(f)))
	=>
	f\/{a|->b}|>{b} == {a|->b}


  RULE SimplifyRelRarXY.2
	(binhyp(r: POW(s))) &
	(blvar(Q)) &
	(Q\(r: POW(s)))
	=>
	r|>ran(s) == r


  RULE SimplifyRelRarXY.3
	(binhyp(w: POW(v))) &
	(blvar(Q)) &
	(Q\(w: POW(v)))
	=>
	u*v|>w == u*w


  RULE SimplifyRelRarXY.4
	(binhyp(v: POW(w))) &
	(blvar(Q)) &
	(Q\(v: POW(w)))
	=>
	u*v|>w == u*v


  RULE SimplifyRelRarXY.5
	(binhyp(v/\w = {})) &
	(blvar(Q)) &
	(Q\(v/\w = {}))
	=>
	u*v|>w == {}


  RULE SimplifyRelRarXY.6
	(binhyp(v/\ran(s) = {})) &
	(blvar(Q)) &
	(Q\(v/\ran(s) = {}))
	=>
	(r;s)|>v == {}


  RULE SimplifyRelRarXY.7
	(binhyp(v: POW(u))) &
	(blvar(Q)) &
	(Q\(v: POW(u)))
	=>
	id(u)|>v == id(v)


  RULE SimplifyRelRarXY.8
	(binhyp(u/\v = {})) &
	(blvar(Q)) &
	(Q\(u/\v = {}))
	=>
	id(u)|>v == {}


  RULE SimplifyRelRarXY.9
	(binhyp(b: v)) &
	(blvar(Q)) &
	(Q\(b: v))
	=>
	{a|->b}|>v == {a|->b}


  RULE SimplifyRelRarXY.10
	(binhyp(not(b: v))) &
	(blvar(Q)) &
	(Q\not(b: v))
	=>
	{a|->b}|>v == {}


  RULE SimplifyRelRarXY.11
	(binhyp(ran(r): POW(v))) &
	(blvar(Q)) &
	(Q\(ran(r): POW(v)))
	=>
	r|>v == r


  RULE SimplifyRelRarXY.12
	(binhyp(v/\ran(r) = {})) &
	(blvar(Q)) &
	(Q\(v/\ran(r) = {}))
	=>
	r|>v == {}


  RULE SimplifyRelRarXY.13
	(binhyp(ran(r)/\v = {})) &
	(blvar(Q)) &
	(Q\(ran(r)/\v = {}))
	=>
	r|>v == {}


  RULE SimplifyRelRarXY.14
	(bguard(Fast_Prove_Difference: not(b = c))) &
	(blvar(Q)) &
	(Q\not(b = c))
	=>
	{a|->b}|>{c} == {}


  RULE SimplifyRelRarXY.15
	(binhyp(f~: v +-> u)) &
	(binhyp(b: ran(f))) &
	(blvar(Q)) &
	(Q\(b,f))
	=>
	f|>{b} == {f~(b)|->b}


  RULE SimplifyRelRarXY.16
	(binhyp(f~: v +-> u)) &
	(blvar(Q)) &
	(Q\(f~: v +-> u))
	=>
	f|>{f(a)} == {a|->f(a)}


  RULE SimplifyRelRarXY.17
	(binhyp(not(a: ran(r)))) &
	(blvar(Q)) &
	(Q\not(a: ran(r)))
	=>
	r|>{a} == {}


  RULE SimplifyRelRarXY.18
	(binhyp(not(a: dom(r)))) &
	(blvar(Q)) &
	(Q\not(a: dom(r)))
	=>
	r~|>{a} == {}


  RULE SimplifyRelRarXY.19
	(binhyp(f~: v +-> u)) &
	(blvar(Q)) &
	(Q\(f~: v +-> u))
	=>
	f|>f[w] == w<|f


  RULE SimplifyRelRarXY.20
	((x,y)\u)
	=>
	SET(x,y).(x: S & y: T & P)|>u == SET(x,y).(x: S & y: T/\u & P)


  RULE SimplifyRelRarXY.21
	id(u)|>v == id(u/\v)


  RULE SimplifyRelRarXY.22
	u*v|>w == u*(v/\w)


  RULE SimplifyRelRarXY.23
	r|>v|>w == r|>(v/\w)


  RULE SimplifyRelRarXY.24
	r|>>v|>w == r|>w-v


  RULE SimplifyRelRarXY.25
	r>u*v == r|>u><(s|>v)


  RULE SimplifyRelRarXY.26
	(r || s)|>u*v == (r|>u || s|>v)


  RULE SimplifyRelRarXY.27
	r-s|>v == (r|>v)-s


  RULE SimplifyRelRarXY.28
	r~|>dom(r) == r~


  RULE SimplifyRelRarXY.29
	r|>ran(r) == r


  RULE SimplifyRelRarXY.30
	u*v|>v == u*v


  RULE SimplifyRelRarXY.31
	{a|->b}|>{b} == {a|->b}


  RULE SimplifyRelRarXY.32
	{}|>a == {}


  RULE SimplifyRelRarXY.33
	r|>{} == {}



THEORY SimplifySeqDomXY IS



  RULE SimplifySeqDomXY.1
	dom(s/|\n) == 1..n


  RULE SimplifySeqDomXY.2
	(bfresh(xx,s,y))
	=>
	dom(conc(s)) == 1..SIGMA(y).(y: 1..size(s) | size(s(y)))


  RULE SimplifySeqDomXY.3
	(binhyp(f: s --> seq(t))) &
	(blvar(Q)) &
	(Q\(f: s --> seq(t)))
	=>
	dom(f(x)) == 1..size(f(x))


  RULE SimplifySeqDomXY.4
	(binhyp(s: seq(e))) &
	(blvar(Q)) &
	(Q\(s: seq(e)))
	=>
	dom(s) == 1..size(s)


  RULE SimplifySeqDomXY.5
	dom(tail(s)) == 1..size(s)-1


  RULE SimplifySeqDomXY.6
	dom(s\|/n) == 1..size(s)-n


  RULE SimplifySeqDomXY.7
	dom(front(s)) == 1..size(s)-1


  RULE SimplifySeqDomXY.8
	dom(s^t) == 1..size(s)+size(t)


  RULE SimplifySeqDomXY.9
	dom(rev(s)) == dom(s)


  RULE SimplifySeqDomXY.10
	dom(a->s) == 1..size(s)+1


  RULE SimplifySeqDomXY.11
	dom(s<-a) == 1..size(s)+1



THEORY SimplifySeqOpeXY IS



  RULE SimplifySeqOpeXY.1
	(binhyp(size(a)<=n)) &
	(blvar(Q)) &
	(Q\(size(a)<=n))
	=>
	a/|\n == a


  RULE SimplifySeqOpeXY.2
	(binhyp(size(a) = n)) &
	(blvar(Q)) &
	(Q\(size(a) = n))
	=>
	a\|/n == {}


  RULE SimplifySeqOpeXY.3
	band((binhyp(n<=size(a))), 
	(btest(n>0))) &
	(blvar(Q)) &
	(Q\(n<=size(a)))
	=>
	tail(a<-b) == tail(a)<-b


  RULE SimplifySeqOpeXY.4
	(binhyp(not(a = {}))) &
	(blvar(Q)) &
	(Q\a)
	=>
	tail(a^b) == tail(a)^b


  RULE SimplifySeqOpeXY.5
	band((binhyp(n<=size(s))), 
	(btest(n>0))) &
	(blvar(Q)) &
	(Q\(n<=size(s)))
	=>
	s<+{1|->b} == b->tail(s)


  RULE SimplifySeqOpeXY.6
	band((binhyp(n<=size(b))), 
	(btest(n>0))) &
	(blvar(Q)) &
	(Q\(n<=size(b)))
	=>
	front(a->b) == a->front(b)


  RULE SimplifySeqOpeXY.7
	(binhyp(not(b = {}))) &
	(blvar(Q)) &
	(Q\b)
	=>
	front(a^b) == a^front(b)


  RULE SimplifySeqOpeXY.8
	(binhyp(not(a = {}))) &
	(blvar(Q)) &
	(Q\(a^b))
	=>
	first(a^b) == first(a)


  RULE SimplifySeqOpeXY.9
	band((binhyp(n<=size(a))), 
	(btest(n>0))) &
	(blvar(Q)) &
	(Q\(n<=size(a)))
	=>
	first(a<-b) == first(a)


  RULE SimplifySeqOpeXY.10
	(binhyp(not(b = {}))) &
	(blvar(Q)) &
	(Q\not(b = {}))
	=>
	last(a^b) == last(b)


  RULE SimplifySeqOpeXY.11
	band((binhyp(s: seq(e))), 
	band((binhyp(n<=size(s))), 
	(btest(n>0)))) &
	(blvar(Q)) &
	(Q\(s: seq(e))) &
	(Q\(n<=size(s)))
	=>
	last(s<+{size(s)|->b}) == b


  RULE SimplifySeqOpeXY.12
	band((binhyp(n<=size(b))), 
	(btest(n>0))) &
	(blvar(Q)) &
	(Q\(n<=size(b)))
	=>
	last(a->b) == last(b)


  RULE SimplifySeqOpeXY.13
	(binhyp(n: 1..size(s))) &
	(blvar(Q)) &
	(Q\(n: 1..size(s)))
	=>
	(s<-b)(n) == s(n)


  RULE SimplifySeqOpeXY.14
	(binhyp(not(s = {}))) &
	(binhyp(n: 2..size(s)+1)) &
	(blvar(Q)) &
	(Q\(not(s) = {})) &
	(Q\(n: 2..size(s)+1))
	=>
	(a->s)(n) == s(n-1)


  RULE SimplifySeqOpeXY.15
	(binhyp(s: seq(a))) &
	(binhyp(t: 1..size(s) +-> b)) &
	(blvar(Q)) &
	(Q\(s: seq(a))) &
	(Q\(t: 1..size(s) +-> b))
	=>
	s<+t<-r == s<-r<+t


  RULE SimplifySeqOpeXY.16
	a^{} == a


  RULE SimplifySeqOpeXY.17
	{}^a == a


  RULE SimplifySeqOpeXY.18
	tail(s) == s\|/1


  RULE SimplifySeqOpeXY.19
	tail(a->b) == b


  RULE SimplifySeqOpeXY.20
	(bnot(bpattern(a,(u,v))))
	=>
	tail([a]) == {}


  RULE SimplifySeqOpeXY.21
	tail([a,b]) == tail([a])<-b


  RULE SimplifySeqOpeXY.22
	front(s) == s/|\size(s)-1


  RULE SimplifySeqOpeXY.23
	front(a<-b) == a


  RULE SimplifySeqOpeXY.24
	(bnot(bpattern(a,(u,v))))
	=>
	front([a]) == {}


  RULE SimplifySeqOpeXY.25
	front([a,b]) == [a]


  RULE SimplifySeqOpeXY.26
	(bnot(bpattern(a,(u,v))))
	=>
	first([a]) == a


  RULE SimplifySeqOpeXY.27
	first([a,b]) == first([a])


  RULE SimplifySeqOpeXY.28
	first(s<+{1|->b}) == b


  RULE SimplifySeqOpeXY.29
	first(a->b) == a


  RULE SimplifySeqOpeXY.30
	(bnot(bpattern(a,(u,v))))
	=>
	last([a]) == a


  RULE SimplifySeqOpeXY.31
	last([a,b]) == b


  RULE SimplifySeqOpeXY.32
	last(a<-b) == b


  RULE SimplifySeqOpeXY.33
	(bnot(bpattern(a,(u,v))))
	=>
	rev([a]) == [a]


  RULE SimplifySeqOpeXY.34
	rev([a,b]) == b->rev([a])


  RULE SimplifySeqOpeXY.35
	(bnot(bpattern(a,(x,y))))
	=>
	{}<-a == [a]


  RULE SimplifySeqOpeXY.36
	[a]<-b == [a,b]


  RULE SimplifySeqOpeXY.37
	(bnot(bpattern(a,(x,y))))
	=>
	a->{} == [a]


  RULE SimplifySeqOpeXY.38
	(bnot(bpattern(a,(x,y)))) &
	(bguard((FLAT;RES): bresult(bflat(a,b)),l))
	=>
	a->[b] == [l]


  RULE SimplifySeqOpeXY.39
	a->[b,c] == a->[b]<-c


  RULE SimplifySeqOpeXY.40
	(s<-b)(size(s)+1) == b


  RULE SimplifySeqOpeXY.41
	(a->s)(2) == first(s)


  RULE SimplifySeqOpeXY.42
	(a->s)(1) == a



THEORY SimplifySeqRanXY IS



  RULE SimplifySeqRanXY.1
	ran(s/|\n) == s[1..n]


  RULE SimplifySeqRanXY.2
	ran(s\|/n) == s[n+1..size(s)]


  RULE SimplifySeqRanXY.3
	(bfresh(xx,s,y))
	=>
	ran(conc(s)) == UNION(y).(y: ran(s) | ran(y))


  RULE SimplifySeqRanXY.4
	band((binhyp(s: seq(A))), 
	(binhyp(s~: A +-> NATURAL))) &
	(blvar(Q)) &
	(Q\(s: seq(A)))
	=>
	ran(tail(s)) == ran(s)-{first(s)}


  RULE SimplifySeqRanXY.5
	band((binhyp(s: seq(A))), 
	(binhyp(s~: A +-> NATURAL))) &
	(blvar(Q)) &
	(Q\(s: seq(A)))
	=>
	ran(front(s)) == ran(s)-{last(s)}


  RULE SimplifySeqRanXY.6
	ran({}) == {}


  RULE SimplifySeqRanXY.7
	ran(s^t) == ran(s)\/ran(t)


  RULE SimplifySeqRanXY.8
	ran(rev(s)) == ran(s)


  RULE SimplifySeqRanXY.9
	(bnot(bpattern(a,(x,y))))
	=>
	ran(a->s) == {a}\/ran(s)


  RULE SimplifySeqRanXY.10
	(bnot(bpattern(a,(x,y))))
	=>
	ran(s<-a) == {a}\/ran(s)



THEORY SimplifySeqSizXY IS



  RULE SimplifySeqSizXY.1
	size(tail(s)) == size(s)-1


  RULE SimplifySeqSizXY.2
	size(front(s)) == size(s)-1


  RULE SimplifySeqSizXY.3
	size(s/|\n) == n


  RULE SimplifySeqSizXY.4
	band((binhyp(s: seq(e))), 
	band((binhyp(n<=size(s))), 
	(btest(n>0)))) &
	(blvar(Q)) &
	(Q\(s: seq(e))) &
	(Q\(n<=size(s)))
	=>
	size(s<+{n|->a}) == size(s)


  RULE SimplifySeqSizXY.5
	(binhyp(n: dom(s))) &
	(binhyp(s: seq(A))) &
	(blvar(Q)) &
	(Q\(n: dom(s)))
	=>
	size(s<+{n|->a}) == size(s)


  RULE SimplifySeqSizXY.6
	band((binhyp(s: seq(e))), 
	band((binhyp(n<=size(s))), 
	(btest(n>0)))) &
	(blvar(Q)) &
	(Q\(s: seq(e))) &
	(Q\(n<=size(s)))
	=>
	size(s<+{size(s)|->n}) == size(s)


  RULE SimplifySeqSizXY.7
	(btest(2<1))
	=>
	(__blankrule)


  RULE SimplifySeqSizXY.8
	size(s\|/n) == size(s)-n


  RULE SimplifySeqSizXY.9
	(binhyp(0<=n)) &
	(blvar(Q)) &
	(Q\n) &
	(x\n)
	=>
	size(%x.(x: 1..n | E)) == n


  RULE SimplifySeqSizXY.10
	(binhyp(s: seq(a))) &
	(binhyp(t: dom(s) +-> b)) &
	(blvar(Q)) &
	(Q\(s: seq(a))) &
	(Q\(t: dom(s) +-> b))
	=>
	size(s<+t) == size(s)


  RULE SimplifySeqSizXY.11
	(binhyp(s: seq(a))) &
	(binhyp(t: 1..size(s) +-> b)) &
	(blvar(Q)) &
	(Q\(s: seq(a))) &
	(Q\(t: 1..size(s) +-> b))
	=>
	size(s<+t) == size(s)


  RULE SimplifySeqSizXY.12
	(bnot(bpattern(a,(u,v))))
	=>
	size([a]) == 1


  RULE SimplifySeqSizXY.13
	size(s<-x) == size(s)+1


  RULE SimplifySeqSizXY.14
	size(x->s) == size(s)+1


  RULE SimplifySeqSizXY.15
	size(s^t) == size(s)+size(t)


  RULE SimplifySeqSizXY.16
	size(rev(s)) == size(s)


  RULE SimplifySeqSizXY.17
	size([a,b]) == size([a])+1


  RULE SimplifySeqSizXY.18
	size({1|->b}) == 1


  RULE SimplifySeqSizXY.19
	size({}) == 0



THEORY SimplifyTryEnsCard IS



  RULE SimplifyTryEnsCard.1
	band((binhyp(f~: a +-> b)), 
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(ran(f): FIN(a) | Curr)))) &
	(blvar(Q)) &
	(Q\(f~: a +-> b))
	=>
	card(f|>>u) == card(ran(f))-card(ran(f)/\u)


  RULE SimplifyTryEnsCard.2
	band((binhyp(f: a +-> b)), 
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(dom(f): FIN(a) | Curr)))) &
	(blvar(Q)) &
	(Q\(f: a +-> b))
	=>
	card(u<<|f) == card(dom(f))-card(u/\dom(f))


  RULE SimplifyTryEnsCard.3
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(A: FIN(A) | Curr))) &
	(blvar(Q)) &
	(Q\(A: FIN(A)))
	=>
	card(A-B) == card(A)-card(A/\B)



THEORY SimplifyEnsCard IS



  RULE SimplifyEnsCard.1
	(bguard(CardStructMakeProdX: CardStructMakeProdG(L),R))
	=>
	card(struct(L)) == R


  RULE SimplifyEnsCard.2
	(binhyp(s: seq(e))) &
	(blvar(Q)) &
	(Q\(s: seq(e)))
	=>
	card(dom(s)) == size(s)


  RULE SimplifyEnsCard.3
	(binhyp(f: a +-> b)) &
	(blvar(Q)) &
	(Q\(f: a +-> b))
	=>
	card(f) == card(dom(f))


  RULE SimplifyEnsCard.4
	(binhyp(f: a +-> b)) &
	(blvar(Q)) &
	(Q\(f: a +-> b))
	=>
	card(u<|f) == card(u/\dom(f))


  RULE SimplifyEnsCard.5
	(binhyp(f~: a +-> b)) &
	(blvar(Q)) &
	(Q\(f~: a +-> b))
	=>
	card(f|>u) == card(ran(f)/\u)


  RULE SimplifyEnsCard.6
	band((binhyp(f: a +-> b)), 
	(binhyp(f~: b +-> a))) &
	(blvar(Q)) &
	(Q\(f: a +-> b))
	=>
	card(f~[C]) == card(ran(f)/\C)


  RULE SimplifyEnsCard.7
	band((binhyp(f: a +-> b)), 
	(binhyp(f~: b +-> a))) &
	(blvar(Q)) &
	(Q\(f: a +-> b))
	=>
	card(f[C]) == card(dom(f)/\C)


  RULE SimplifyEnsCard.8
	card(A\/B) == card(A)+card(B)-card(A/\B)


  RULE SimplifyEnsCard.9
	(binhyp(not(b: a))) &
	(blvar(Q)) &
	(Q\not(b: a))
	=>
	card(a\/{b}) == card(a)+1


  RULE SimplifyEnsCard.10
	(bguard(Fast_Prove_Order: m<=n)) &
	(blvar(Q)) &
	(Q\(m<=n))
	=>
	card(m..n) == n-m+1


  RULE SimplifyEnsCard.11
	(binhyp(0<=m)) &
	(blvar(Q)) &
	(Q\m)
	=>
	card(1..m) == m


  RULE SimplifyEnsCard.12
	(binhyp(not(A = {}))) &
	(binhyp(not(B = {}))) &
	(blvar(Q)) &
	(Q\(A,B))
	=>
	card(A*B) == card(A)*card(B)


  RULE SimplifyEnsCard.13
	(a\A)
	=>
	card(%a.(a: A | E)) == card(A)


  RULE SimplifyEnsCard.14
	card(id(s)) == card(s)


  RULE SimplifyEnsCard.15
	card(r~) == card(r)


  RULE SimplifyEnsCard.16
	card({a}) == 1


  RULE SimplifyEnsCard.17
	card({}) == 0



THEORY SimplifySetComXY IS



  RULE SimplifySetComXY.1
	(bfresh(yy,(x,P,Q),y)) &
	(x\Q)
	=>
	SET(x).P*Q == SET(x,y).(P & y: Q)


  RULE SimplifySetComXY.2
	(bfresh(xx,(y,P,Q),x)) &
	(bnot(bpattern(y,(u,v)))) &
	(y\Q)
	=>
	Q*SET(y).P == SET(x,y).(x: Q & P)


  RULE SimplifySetComXY.3
	(btest(b
	a..b == {}


  RULE SimplifySetComXY.4
	(binhyp(b+1<=a)) &
	(blvar(Q)) &
	(Q\(b+1<=a))
	=>
	a..b == {}


  RULE SimplifySetComXY.5
	p..p-1 == {}


  RULE SimplifySetComXY.6
	p+1..p == {}


  RULE SimplifySetComXY.7
	(bsearch(i>>{},(L,l>>E),R))
	=>
	struct(L,l>>E) == {}


  RULE SimplifySetComXY.8
	struct(l>>{}) == {}


  RULE SimplifySetComXY.9
	p..p == {p}


  RULE SimplifySetComXY.10
	SET(x).bfalse == {}


  RULE SimplifySetComXY.11
	(x\S)
	=>
	SET(x).(x: S) == S


  RULE SimplifySetComXY.12
	SET(x).(x: {}) == {}


  RULE SimplifySetComXY.13
	POW({}) == {{}}


  RULE SimplifySetComXY.14
	POW({a}) == {{}}\/{{a}}


  RULE SimplifySetComXY.15
	a*{} == {}


  RULE SimplifySetComXY.16
	{}*a == {}


  RULE SimplifySetComXY.17
	(A\/B)*C == A*C\/B*C


  RULE SimplifySetComXY.18
	(A/\B)*C == A*C/\B*C


  RULE SimplifySetComXY.19
	A*(B\/C) == A*B\/A*C


  RULE SimplifySetComXY.20
	A*(B/\C) == A*B/\A*C


  RULE SimplifySetComXY.21
	(a/\b)*A == a*A/\b*A


  RULE SimplifySetComXY.22
	(a\/b)*A == a*A\/b*A


  RULE SimplifySetComXY.23
	{a}*{b} == {a|->b}


  RULE SimplifySetComXY.24
	{} <-> s == POW({})


  RULE SimplifySetComXY.25
	s <-> {} == POW({})


  RULE SimplifySetComXY.26
	{} +-> s == POW({})


  RULE SimplifySetComXY.27
	s +-> {} == POW({})



THEORY SimplifySetIntXY IS



  RULE SimplifySetIntXY.1
	(bguard(Fast_Prove_Order: a<=b)) &
	(bguard(Fast_Prove_Order: c<=d))
	=>
	a..b/\c..d == max({a}\/{c})..min({b}\/{d})


  RULE SimplifySetIntXY.2
	(binhyp(A/\B = C)) &
	(blvar(Q)) &
	(Q\(A,B,C))
	=>
	B/\A == C


  RULE SimplifySetIntXY.3
	band((bsearch(d,a\/b,e)), 
	(binhyp(d/\c = {}))) &
	(blvar(Q)) &
	(Q\(d/\c = {}))
	=>
	a\/b/\c == e/\c


  RULE SimplifySetIntXY.4
	(bguard(Fast_Prove_Order: r<=q)) &
	(bguard(Fast_Prove_Order: p<=r)) &
	(blvar(Q)) &
	(Q\(p,q,r))
	=>
	p..q/\{r} == {r}


  RULE SimplifySetIntXY.5
	(bguard(Fast_Prove_Order: p<=q)) &
	(blvar(Q)) &
	(Q\(p,q))
	=>
	p..q/\{q} == {q}


  RULE SimplifySetIntXY.6
	(bguard(Fast_Prove_Order: p<=q)) &
	(blvar(Q)) &
	(Q\(p<=q))
	=>
	p..q/\{p} == {p}


  RULE SimplifySetIntXY.7
	band((bsearch(a-{b},c/\d,x)), 
	band((bsearch(g\/{b},c/\d,h/\i,g)), 
	(binhyp(b: a)))) &
	(blvar(Q)) &
	(Q\(b: a))
	=>
	c/\d == h/\i


  RULE SimplifySetIntXY.8
	band((bsearch({a},b/\c,x)), 
	band((binhyp(not(a: d))), 
	(bsearch(d,b/\c,y)))) &
	(blvar(Q)) &
	(Q\not(a: d))
	=>
	b/\c == {}


  RULE SimplifySetIntXY.9
	(binhyp(not(a: b))) &
	(blvar(Q)) &
	(Q\(a: b))
	=>
	{a}/\b == {}


  RULE SimplifySetIntXY.10
	(binhyp(not(a: b))) &
	(blvar(Q)) &
	(Q\not(a: b))
	=>
	b/\{a} == {}


  RULE SimplifySetIntXY.11
	band((bsearch({a},b/\c,x/\z)), 
	band((binhyp(a: d)), 
	(bsearch(d,x/\z,y)))) &
	(blvar(Q)) &
	(Q\(a: d))
	=>
	b/\c == y/\{a}


  RULE SimplifySetIntXY.12
	(binhyp(b: a)) &
	(blvar(Q)) &
	(Q\(b: a))
	=>
	{b}/\a == {b}


  RULE SimplifySetIntXY.13
	(binhyp(b: a)) &
	(blvar(Q)) &
	(Q\(b: a))
	=>
	a/\{b} == {b}


  RULE SimplifySetIntXY.14
	(binhyp(ran(a)/\ran(b) = {})) &
	(blvar(Q)) &
	(Q\(ran(a)/\ran(b) = {}))
	=>
	a/\b == {}


  RULE SimplifySetIntXY.15
	(binhyp(dom(a)/\dom(b) = {})) &
	(blvar(Q)) &
	(Q\(dom(a)/\dom(b) = {}))
	=>
	a/\b == {}


  RULE SimplifySetIntXY.16
	(bguard(Fast_Prove_Difference: not(a = b))) &
	(blvar(Q)) &
	(Q\not(a = b))
	=>
	{a|->c}/\{b|->d} == {}


  RULE SimplifySetIntXY.17
	(bguard(Fast_Prove_Difference: not(c = d))) &
	(blvar(Q)) &
	(Q\not(c = d))
	=>
	{a|->c}/\{b|->d} == {}


  RULE SimplifySetIntXY.18
	(bguard(Fast_Prove_Difference: not(a = b))) &
	(blvar(Q)) &
	(Q\not(a = b))
	=>
	{a}/\{b} == {}


  RULE SimplifySetIntXY.19
	band((binhyp(c: POW(x))), 
	(bsearch(x,a/\b,r))) &
	(blvar(Q)) &
	(Q\(c: POW(x)))
	=>
	a/\b/\c == r/\c


  RULE SimplifySetIntXY.20
	(binhyp(a: POW(b))) &
	(blvar(Q)) &
	(Q\(a: POW(b)))
	=>
	a/\b == a


  RULE SimplifySetIntXY.21
	(binhyp(b: POW(a))) &
	(blvar(Q)) &
	(Q\(b: POW(a)))
	=>
	a/\b == b


  RULE SimplifySetIntXY.22
	(binhyp(not(a: b))) &
	(blvar(Q)) &
	(Q\not(a: b))
	=>
	b/\(c\/{a}) == b/\c


  RULE SimplifySetIntXY.23
	(binhyp(not(a: b))) &
	(blvar(Q)) &
	(Q\not(a: b))
	=>
	c\/{a}/\b == c/\b


  RULE SimplifySetIntXY.24
	(a\A)
	=>
	A/\SET(a).(a: b & c) == SET(a).(a: A/\b & c)


  RULE SimplifySetIntXY.25
	a..b/\INTEGER == a..b


  RULE SimplifySetIntXY.26
	x..y/\C-{x} == x+1..y/\C


  RULE SimplifySetIntXY.27
	x..y/\C-{y} == x..y-1/\C


  RULE SimplifySetIntXY.28
	a/\b-c == (a/\b)-c


  RULE SimplifySetIntXY.29
	a/\b-a == {}


  RULE SimplifySetIntXY.30
	a-b/\c == (a/\c)-b


  RULE SimplifySetIntXY.31
	a-b/\b == {}


  RULE SimplifySetIntXY.32
	p..q/\o..q == max({p}\/{o})..q


  RULE SimplifySetIntXY.33
	p..q/\p..r == p..min({q}\/{r})


  RULE SimplifySetIntXY.34
	p..q/\{p-1} == {}


  RULE SimplifySetIntXY.35
	p+1..q/\{p} == {}


  RULE SimplifySetIntXY.36
	p..q/\{q+1} == {}


  RULE SimplifySetIntXY.37
	n..m-1/\{m} == {}


  RULE SimplifySetIntXY.38
	a\/b/\b == b


  RULE SimplifySetIntXY.39
	a/\b/\b == a/\b


  RULE SimplifySetIntXY.40
	a/\b/\a == a/\b


  RULE SimplifySetIntXY.41
	a/\a == a


  RULE SimplifySetIntXY.42
	{}/\a == {}


  RULE SimplifySetIntXY.43
	a/\{} == {}



THEORY SimplifyTrySetSubXY IS



  RULE SimplifyTrySetSubXY.1
	(blvar(Q)) &
	(Q\(b: a)) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(not(b: a) | Curr)))
	=>
	a-{b} == a



THEORY SimplifySetSubXY IS



  RULE SimplifySetSubXY.1
	(binhyp(A/\B = {})) &
	(blvar(Q)) &
	(Q\(A/\B)) &
	(a\B)
	=>
	A-SET(a).(a: B & P) == A


  RULE SimplifySetSubXY.2
	(binhyp(ran(r)/\A = {})) &
	(blvar(Q)) &
	(Q\(ran(r)/\A))
	=>
	A-r[B] == A


  RULE SimplifySetSubXY.3
	band((binhyp(ran(r): POW(B))), 
	band((binhyp(A/\B = {})), 
	(binhyp(a: dom(r))))) &
	(blvar(Q)) &
	(Q\(ran(r): POW(B) & A/\B = {} & a: dom(r)))
	=>
	A-{r(a)} == A


  RULE SimplifySetSubXY.4
	band((binhyp(f: A +-> B)), 
	(binhyp(g: POW(f)))) &
	(blvar(Q)) &
	(Q\(g: POW(f)))
	=>
	f-g == dom(g)<<|f


  RULE SimplifySetSubXY.5
	(binhyp(a: POW(e))) &
	(blvar(Q)) &
	(Q\(a: POW(e)))
	=>
	a-b-(c-b) == a-b-c


  RULE SimplifySetSubXY.6
	(binhyp(b: POW(c))) &
	(blvar(Q)) &
	(Q\(b: POW(c)))
	=>
	a-(b-a) == a


  RULE SimplifySetSubXY.7
	(binhyp(a: POW(c))) &
	(blvar(Q)) &
	(Q\(a: POW(c)))
	=>
	a-(b-a) == a


  RULE SimplifySetSubXY.8
	(binhyp(b: POW(c))) &
	(blvar(Q)) &
	(Q\(b: POW(c)))
	=>
	a-(a-b) == a/\b


  RULE SimplifySetSubXY.9
	(binhyp(a: POW(c))) &
	(blvar(Q)) &
	(Q\(a: POW(c)))
	=>
	a-(a-b) == a/\b


  RULE SimplifySetSubXY.10
	(binhyp(b: POW(c))) &
	(blvar(Q)) &
	(Q\(b: POW(c)))
	=>
	a-b-b == a-b


  RULE SimplifySetSubXY.11
	(binhyp(a: POW(c))) &
	(blvar(Q)) &
	(Q\(a: POW(c)))
	=>
	a-b-b == a-b


  RULE SimplifySetSubXY.12
	(bguard(Fast_Prove_Order: a<=c)) &
	(bguard(Fast_Prove_Order: d<=b)) &
	(bguard(Fast_Prove_Order: c<=d)) &
	(blvar(Q)) &
	(Q\(a,b,c,d))
	=>
	(a..b)-(c..d) == a..c-1\/d+1..b


  RULE SimplifySetSubXY.13
	(bguard(Fast_Prove_Order: a<=b)) &
	(blvar(Q)) &
	(Q\(a<=b))
	=>
	(a..b)-(a..b-1) == {b}


  RULE SimplifySetSubXY.14
	(bguard(Fast_Prove_Order: a<=b)) &
	(blvar(Q)) &
	(Q\(a<=b))
	=>
	(a..b)-(a+1..b) == {a}


  RULE SimplifySetSubXY.15
	(bguard(Fast_Prove_Order: a<=b)) &
	(bguard(Fast_Prove_Order: a<=c)) &
	(blvar(Q)) &
	(Q\(a,b,c))
	=>
	(a..b)-(a..c) == c+1..b


  RULE SimplifySetSubXY.16
	(bguard(Fast_Prove_Order: r+1<=p)) &
	(blvar(Q)) &
	(Q\(r+1<=p))
	=>
	(p..q)-{r} == p..q


  RULE SimplifySetSubXY.17
	(bguard(Fast_Prove_Order: q+1<=r)) &
	(blvar(Q)) &
	(Q\(q+1<=r))
	=>
	(p..q)-{r} == p..q


  RULE SimplifySetSubXY.18
	(binhyp(a: POW(b))) &
	(blvar(Q)) &
	(Q\(a: POW(b)))
	=>
	a-b == {}


  RULE SimplifySetSubXY.19
	(binhyp(a/\b = {})) &
	(blvar(Q)) &
	(Q\(a/\b))
	=>
	a-b == a


  RULE SimplifySetSubXY.20
	(bguard(Fast_Prove_Difference: not(a = b))) &
	(blvar(Q)) &
	(Q\not(a = b))
	=>
	{a}-{b} == {a}


  RULE SimplifySetSubXY.21
	band((binhyp(not(x: a))), 
	(bsearch({x},b\/c,r))) &
	(blvar(Q)) &
	(Q\(x: a))
	=>
	a-(b\/c) == a-r


  RULE SimplifySetSubXY.22
	(binhyp(not(a: b))) &
	(blvar(Q)) &
	(Q\not(a: b))
	=>
	b-{a} == b


  RULE SimplifySetSubXY.23
	(binhyp(not(a: b))) &
	(blvar(Q)) &
	(Q\not(a: b))
	=>
	{a}-b == {a}


  RULE SimplifySetSubXY.24
	(binhyp(a: b)) &
	(blvar(Q)) &
	(Q\(a: b))
	=>
	{a}-b == {}


  RULE SimplifySetSubXY.25
	(binhyp(a: POW(b))) &
	(blvar(Q)) &
	(Q\(a: POW(b)))
	=>
	a-a == {}


  RULE SimplifySetSubXY.26
	(bsearch(c,a\/b,r))
	=>
	(a\/b)-c == r-c


  RULE SimplifySetSubXY.27
	(bsearch(c,a/\b,r))
	=>
	(a/\b)-c == {}


  RULE SimplifySetSubXY.28
	(a\A)
	=>
	SET(a).(a: b & c)-A == SET(a).(a: b-A & c)


  RULE SimplifySetSubXY.29
	(p..q)-{p-1} == p..q


  RULE SimplifySetSubXY.30
	(p..q)-{p} == p+1..q


  RULE SimplifySetSubXY.31
	(p..q)-{q} == p..q-1


  RULE SimplifySetSubXY.32
	(p+1..q)-{p} == p+1..q


  RULE SimplifySetSubXY.33
	(p..q-1)-{q} == p..q-1


  RULE SimplifySetSubXY.34
	(p..q)-{q+1} == p..q


  RULE SimplifySetSubXY.35
	a-{b}-{b} == a-{b}


  RULE SimplifySetSubXY.36
	(a\/c)-(b-c) == a-b\/c


  RULE SimplifySetSubXY.37
	a-(b\/c) == a-b-c


  RULE SimplifySetSubXY.38
	a-{} == a


  RULE SimplifySetSubXY.39
	{}-a == {}


  RULE SimplifySetSubXY.40
	{a}-{a} == {}



THEORY SimplifySetUniXY IS



  RULE SimplifySetUniXY.1
	(binhyp(A: POW(B))) &
	(blvar(Q)) &
	(Q\(A: POW(B))) &
	(a\A)
	=>
	B\/SET(a).(a: A & P) == B


  RULE SimplifySetUniXY.2
	(binhyp(ran(r): POW(A))) &
	(blvar(Q)) &
	(Q\(ran(r): POW(A)))
	=>
	A\/r[B] == A


  RULE SimplifySetUniXY.3
	band((binhyp(ran(r): POW(A))), 
	(binhyp(a: dom(r)))) &
	(blvar(Q)) &
	(Q\(a: dom(r) & ran(r): POW(A)))
	=>
	A\/{r(a)} == A


  RULE SimplifySetUniXY.4
	(bguard(Fast_Prove_Order: a<=b)) &
	(bguard(Fast_Prove_Order: c<=d)) &
	(bguard(Fast_Prove_Order: a<=c)) &
	(bguard(Fast_Prove_Order: c<=b)) &
	(blvar(Q)) &
	(Q\(a<=b & c<=d))
	=>
	a..b\/c..d == min({a}\/{c})..max({b}\/{d})


  RULE SimplifySetUniXY.5
	band((binhyp(s: seq(a))), 
	(binhyp(s~: a +-> NATURAL))) &
	(blvar(Q)) &
	(Q\(s: seq(a)))
	=>
	s[1..m]\/s[n..size(s)] == ran(s)-s[m+1..n-1]


  RULE SimplifySetUniXY.6
	(bguard(Fast_Prove_Order: p<=n)) &
	(bguard(Fast_Prove_Order: n<=q)) &
	(blvar(Q)) &
	(Q\(n: p..q))
	=>
	p..q\/{n} == p..q


  RULE SimplifySetUniXY.7
	(bguard(Fast_Prove_Order: p<=q)) &
	(blvar(Q)) &
	(Q\(p<=q))
	=>
	p..q-1\/{q} == p..q


  RULE SimplifySetUniXY.8
	(bguard(Fast_Prove_Order: p<=q)) &
	(blvar(Q)) &
	(Q\(p<=q))
	=>
	p+1..q\/{p} == p..q


  RULE SimplifySetUniXY.9
	(bguard(Fast_Prove_Order: p<=q)) &
	(blvar(Q)) &
	(Q\(p<=q))
	=>
	p..q\/{p-1} == p-1..q


  RULE SimplifySetUniXY.10
	(bguard(Fast_Prove_Order: p<=q)) &
	(blvar(Q)) &
	(Q\(p<=q))
	=>
	p..q\/{q+1} == p..q+1


  RULE SimplifySetUniXY.11
	(binhyp(q: INTEGER)) &
	(binhyp(0<=q)) &
	(blvar(Q)) &
	(Q\(q: INTEGER))
	=>
	1..q\/{q+1} == 1..q+1


  RULE SimplifySetUniXY.12
	(bguard(Fast_Prove_Order: p<=q)) &
	(blvar(Q)) &
	(Q\(p<=q))
	=>
	p..q\/{q} == p..q


  RULE SimplifySetUniXY.13
	(bguard(Fast_Prove_Order: p<=q)) &
	(blvar(Q)) &
	(Q\(p<=q))
	=>
	p..q\/{p} == p..q


  RULE SimplifySetUniXY.14
	band((binhyp(c: POW(x))), 
	(bsearch(x,a\/b,r))) &
	(blvar(Q)) &
	(Q\(c: POW(x)))
	=>
	a\/b\/c == a\/b


  RULE SimplifySetUniXY.15
	(binhyp(a: POW(b))) &
	(blvar(Q)) &
	(Q\(a: POW(b)))
	=>
	a\/b == b


  RULE SimplifySetUniXY.16
	(binhyp(b: POW(a))) &
	(blvar(Q)) &
	(Q\(b: POW(a)))
	=>
	a\/b == a


  RULE SimplifySetUniXY.17
	band((bsearch({a},b\/c,x\/z)), 
	band((binhyp(a: d)), 
	(bsearch(d,x\/z,y)))) &
	(blvar(Q)) &
	(Q\(a: d))
	=>
	b\/c == x\/z


  RULE SimplifySetUniXY.18
	(binhyp(a: b)) &
	(blvar(Q)) &
	(Q\(a: b))
	=>
	b\/{a} == b


  RULE SimplifySetUniXY.19
	(binhyp(a: b)) &
	(blvar(Q)) &
	(Q\(a: b))
	=>
	{a}\/b == b


  RULE SimplifySetUniXY.20
	(bsearch(x/\c,a\/b,r))
	=>
	a\/b\/c == r\/c


  RULE SimplifySetUniXY.21
	(bsearch(d,a\/b,x))
	=>
	a\/b\/c-d == a\/b\/c


  RULE SimplifySetUniXY.22
	(bsearch(x-c,a\/b,r,x))
	=>
	a\/b\/c == r\/c


  RULE SimplifySetUniXY.23
	(bsearch(c,a\/b,x))
	=>
	a\/b\/c == a\/b


  RULE SimplifySetUniXY.24
	(bguard((ARI;RES): bresult(b+1),r)) &
	(btest(r = c)) &
	(bguard(Fast_Prove_Order: a<=c)) &
	(blvar(Q)) &
	(Q\a)
	=>
	a..b\/{c} == a..c


  RULE SimplifySetUniXY.25
	(bguard((ARI;RES): bresult(a-1),r)) &
	(btest(r = c)) &
	(bguard(Fast_Prove_Order: c<=b)) &
	(blvar(Q)) &
	(Q\b)
	=>
	a..b\/{c} == c..b


  RULE SimplifySetUniXY.26
	ran({x}<<|f)\/{f(x)} == ran(f)


  RULE SimplifySetUniXY.27
	dom(r-s)\/dom(s) == dom(r)\/dom(s)


  RULE SimplifySetUniXY.28
	{x}*v\/{x|->y} == {x}*(v\/{y})


  RULE SimplifySetUniXY.29
	u*{y}\/{x|->y} == (u\/{x})*{y}


  RULE SimplifySetUniXY.30
	ran(u<<|r)\/r[u] == ran(r)


  RULE SimplifySetUniXY.31
	r[u]\/ran(u<<|r) == ran(r)


  RULE SimplifySetUniXY.32
	a/\b\/b == b


  RULE SimplifySetUniXY.33
	a-b\/b == a\/b


  RULE SimplifySetUniXY.34
	a\/a == a


  RULE SimplifySetUniXY.35
	{}\/a == a


  RULE SimplifySetUniXY.36
	a\/{} == a



THEORY SimplifyStructXY IS



  RULE SimplifyStructXY.1
	(bnot(bpattern(b,d)))
	=>
	(a<<<{b = c})'d == a'd


  RULE SimplifyStructXY.2
	(a<<<{b = c})'b == c


  RULE SimplifyStructXY.3
	a<<<{b = c}<<<{b = d} == a<<<{b = d}



THEORY ContradictionTryXY IS



  RULE ContradictionTryXY.1
	band((binhyp(not(c: d[{l}]))), 
	band((binhyp(d(l) = c)), 
	(binhyp(d: s +-> t)))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(l: dom(d) | Curr)))
	=>
	(P)


  RULE ContradictionTryXY.2
	band((binhyp(n: a)), 
	(binhyp(not(n: b)))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(a: POW(b) | Curr)))
	=>
	(P)



THEORY ContradictionXY IS



  RULE ContradictionXY.1
	band((binhyp(not(v = a))), 
	band((binhyp(not(v = b))), 
	band((bnot(bpattern(a,b))), 
	band((binhyp(v: (i..j)*{E})), 
	band((bnum(i)), 
	band((btest(j>=i)), 
	(bguard((ContraEnumAllNotX;ARI~): ContraEnumAllNotG(i | j | v | E)))))))))
	=>
	(p)


  RULE ContradictionXY.2
	band((binhyp(not(v = a))), 
	band((binhyp(not(v = b))), 
	band((bnot(bpattern(a,b))), 
	band((binhyp(v: L\/{e})), 
	(bguard(ContraExtAllNotX: ContraExtAllNotG(L\/{e} | v)))))))
	=>
	(p)


  RULE ContradictionXY.3
	band((binhyp(a+1<=card({}))), 
	(bnum(a)))
	=>
	(P)


  RULE ContradictionXY.4
	band((binhyp(a = b)), 
	band((bnum(a)), 
	band((bnum(b)), 
	(btest(a/=b)))))
	=>
	(P)


  RULE ContradictionXY.5
	band((binhyp(a = b)), 
	band((binhyp(c<=a)), 
	(btest(b
	(P)


  RULE ContradictionXY.6
	band((binhyp(not(a = b))), 
	band((bnum(a)), 
	band((bnum(b)), 
	(btest(a = b)))))
	=>
	(P)


  RULE ContradictionXY.7
	band((binhyp(x = x+a)), 
	(btest(a>0)))
	=>
	(P)


  RULE ContradictionXY.8
	band((binhyp(x+a = x)), 
	(btest(a>0)))
	=>
	(P)


  RULE ContradictionXY.9
	band((binhyp(x+a = b)), 
	band((bnum(x)), 
	(btest(a>b))))
	=>
	(P)


  RULE ContradictionXY.10
	band((binhyp(a+x = b)), 
	band((bnum(x)), 
	(btest(a>b))))
	=>
	(P)


  RULE ContradictionXY.11
	band((binhyp(n<=m)), 
	(btest(m
	(P)


  RULE ContradictionXY.12
	band((binhyp(n<=size({}))), 
	(btest(0
	(P)


  RULE ContradictionXY.13
	band((binhyp(m<=n)), 
	band((binhyp(n<=p)), 
	(btest(p
	(P)


  RULE ContradictionXY.14
	band((binhyp(1<=size(s))), 
	band((binhyp(not(a = first(s)))), 
	band((binhyp(2<=n)), 
	(binhyp(card(ran(a->s/|\n)) = 1)))))
	=>
	(P)


  RULE ContradictionXY.15
	band((binhyp(m = n+p)), 
	band((btest(m
	(P)


  RULE ContradictionXY.16
	band((binhyp(m = n+p)), 
	band((btest(m
	(P)


  RULE ContradictionXY.17
	band((binhyp(m = n+p)), 
	band((binhyp(m+1<=p)), 
	band((binhyp(n: a..b)), 
	(btest(0<=a)))))
	=>
	(P)


  RULE ContradictionXY.18
	band((binhyp(m = n+p)), 
	band((binhyp(m+1<=p)), 
	band((binhyp(0<=a)), 
	(binhyp(n: a..b)))))
	=>
	(P)


  RULE ContradictionXY.19
	band((binhyp(m = n+p)), 
	band((btest(m
	(P)


  RULE ContradictionXY.20
	band((binhyp(m = n+p)), 
	band((binhyp(m+1<=p)), 
	band((binhyp(n: INTEGER)), 
	(binhyp(0<=n)))))
	=>
	(P)


  RULE ContradictionXY.21
	band((binhyp(m+n<=p)), 
	band((binhyp(p<=m)), 
	(btest(0
	(P)


  RULE ContradictionXY.22
	band((binhyp(m+n<=p)), 
	band((binhyp(p<=n)), 
	(btest(0
	(P)


  RULE ContradictionXY.23
	band((binhyp(m+n<=p)), 
	band((btest(p<=m)), 
	(btest(0
	(P)


  RULE ContradictionXY.24
	band((binhyp(m+n<=p)), 
	band((btest(p<=n)), 
	(btest(0
	(P)


  RULE ContradictionXY.25
	band((binhyp(m+n<=p)), 
	band((binhyp(p<=m)), 
	(binhyp(1<=n))))
	=>
	(P)


  RULE ContradictionXY.26
	band((binhyp(m+n<=p)), 
	band((binhyp(p<=n)), 
	(binhyp(1<=m))))
	=>
	(P)


  RULE ContradictionXY.27
	band((binhyp(m+n<=p)), 
	band((btest(p<=m)), 
	(binhyp(1<=n))))
	=>
	(P)


  RULE ContradictionXY.28
	band((binhyp(m+n<=p)), 
	band((btest(p<=n)), 
	(binhyp(1<=m))))
	=>
	(P)


  RULE ContradictionXY.29
	band((binhyp(n = m)), 
	band((bnum(n)), 
	band((bnum(m)), 
	(btest(m/=n)))))
	=>
	(P)


  RULE ContradictionXY.30
	band((binhyp(a = n)), 
	band((bnum(n)), 
	band((binhyp(a = m)), 
	band((bnum(m)), 
	(btest(m/=n))))))
	=>
	(P)


  RULE ContradictionXY.31
	band((binhyp(n/p = n)), 
	band((btest(n>0)), 
	(btest(p>1))))
	=>
	(P)


  RULE ContradictionXY.32
	band((binhyp(n = n/p)), 
	band((btest(n>0)), 
	(btest(p>1))))
	=>
	(P)


  RULE ContradictionXY.33
	band((binhyp(n*p = n)), 
	band((btest(n>1)), 
	(btest(p>1))))
	=>
	(P)


  RULE ContradictionXY.34
	band((binhyp(n = n*p)), 
	band((btest(n>1)), 
	(btest(p>1))))
	=>
	(P)


  RULE ContradictionXY.35
	band((binhyp(n+p = n)), 
	band((btest(p>0)), 
	(binhyp(n: INTEGER))))
	=>
	(P)


  RULE ContradictionXY.36
	band((binhyp(n+p = n)), 
	band((btest(p>0)), 
	(bnum(n))))
	=>
	(P)


  RULE ContradictionXY.37
	band((binhyp(n = n+p)), 
	band((btest(p>0)), 
	(binhyp(n: INTEGER))))
	=>
	(P)


  RULE ContradictionXY.38
	band((binhyp(n = n+p)), 
	band((btest(p>0)), 
	(bnum(n))))
	=>
	(P)


  RULE ContradictionXY.39
	band((binhyp(m = n+p)), 
	band((binhyp(n: INTEGER)), 
	band((binhyp(0<=n)), 
	(btest(m
	(P)


  RULE ContradictionXY.40
	band((binhyp(n: INTEGER)), 
	band((binhyp(n<0)), 
	(bnum(n))))
	=>
	(P)


  RULE ContradictionXY.41
	band((binhyp(x: dom(r))), 
	band((binhyp(r: a <-> b)), 
	(binhyp(not(x: a)))))
	=>
	(P)


  RULE ContradictionXY.42
	(binhyp(not(b: (r<+{a|->b})[{a}])))
	=>
	(P)


  RULE ContradictionXY.43
	band((binhyp(not(A & B))), 
	band((binhyp(A)), 
	(binhyp(B))))
	=>
	(P)



THEORY ContraEnumAllNotX IS



  RULE ContraEnumAllNotX.1
	(binhyp(not(v = i|->E))) &
	(ContraEnumAllNotG(i+1 | j | v | E))
	=>
	(ContraEnumAllNotG(i | j | v | E))


  RULE ContraEnumAllNotX.2
	(binhyp(not(v = j|->E)))
	=>
	(ContraEnumAllNotG(j | j | v | E))



THEORY ContraExtAllNotX IS



  RULE ContraExtAllNotX.1
	(binhyp(not(v = e))) &
	(ContraExtAllNotG(L | v))
	=>
	(ContraExtAllNotG(L\/{e} | v))


  RULE ContraExtAllNotX.2
	(binhyp(not(v = e)))
	=>
	(ContraExtAllNotG({e} | v))



THEORY DifferenceTryXY IS



  RULE DifferenceTryXY.1
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(n: INTEGER & 0<=n | Curr))) &
	(1<=n)
	=>
	(not(n = 0))



THEORY DifferenceXY IS



  RULE DifferenceXY.1
	(binhyp(s: seq(e))) &
	(1<=size(s))
	=>
	(not(s = {}))


  RULE DifferenceXY.2
	(x = FALSE)
	=>
	(not(x = TRUE))


  RULE DifferenceXY.3
	(x = TRUE)
	=>
	(not(x = FALSE))


  RULE DifferenceXY.4
	(binhyp(a: b..c)) &
	(bguard(Fast_Prove_All_Order: b<=c)) &
	(bguard(Fast_Prove_All_Order: 1<=b))
	=>
	(not(a = 0))


  RULE DifferenceXY.5
	(binhyp(a: b..c)) &
	(bguard(Fast_Prove_All_Order: b<=c)) &
	(bguard(Fast_Prove_All_Order: c+1<=0))
	=>
	(not(a = 0))


  RULE DifferenceXY.6
	(binhyp(b<=a)) &
	(binhyp(1<=b))
	=>
	(not(a = 0))


  RULE DifferenceXY.7
	(binhyp(a<=b)) &
	(binhyp(b+1<=0))
	=>
	(not(a = 0))


  RULE DifferenceXY.8
	(binhyp(not(a: ran(f))))
	=>
	(not(a = f(x)))


  RULE DifferenceXY.9
	(binhyp(not(a: ran(f))))
	=>
	(not(f(x) = a))


  RULE DifferenceXY.10
	band((binhyp(b: POW(a))), 
	(binhyp(not(b = {}))))
	=>
	(not(a = {}))


  RULE DifferenceXY.11
	(binhyp(not(a/\b = {})))
	=>
	(not(a = {}))


  RULE DifferenceXY.12
	(binhyp(not(b/\a = {})))
	=>
	(not(a = {}))


  RULE DifferenceXY.13
	(binhyp(not(card(A) = card(B))))
	=>
	(not(A = B))


  RULE DifferenceXY.14
	(binhyp(not(b = a)))
	=>
	(not(a = b))


  RULE DifferenceXY.15
	band((binhyp(a: c)), 
	(binhyp(not(b: c))))
	=>
	(not(a = b))


  RULE DifferenceXY.16
	band((binhyp(b: c)), 
	(binhyp(not(a: c))))
	=>
	(not(a = b))


  RULE DifferenceXY.17
	band((binhyp(a: c)), 
	(binhyp(not(b: c))))
	=>
	(not(a = b))


  RULE DifferenceXY.18
	band((binhyp(b: c)), 
	(binhyp(not(a: c))))
	=>
	(not(a = b))


  RULE DifferenceXY.19
	band((binhyp(not(f(a) = f(b)))), 
	(binhyp(f~: t +-> s)))
	=>
	(not(a = b))


  RULE DifferenceXY.20
	band((binhyp(x: A)), 
	(binhyp(x: B)))
	=>
	(not(A/\B = {}))


  RULE DifferenceXY.21
	not(BOOL = {})


  RULE DifferenceXY.22
	not(INTEGER = {})


  RULE DifferenceXY.23
	not(INT = {})


  RULE DifferenceXY.24
	not(NATURAL = {})


  RULE DifferenceXY.25
	not(NAT = {})



THEORY EqualityXY IS



  RULE EqualityXY.1
	(bguard(RecordMakeListX: RecordMakeListG(Eg,L,X),R)) &
	(R)
	=>
	(rec(L) = X)


  RULE EqualityXY.2
	(binhyp(dom(f) = s)) &
	(binhyp(f: a +-> b)) &
	(ran(f): POW(dom(g)))
	=>
	(dom(f;g) = s)


  RULE EqualityXY.3
	(binhyp(a<=b)) &
	(binhyp(c<=d)) &
	(c<=b => d+1<=a)
	=>
	(a..b/\c..d = {})


  RULE EqualityXY.4
	(a..b/\c..d = {})
	=>
	(a+e..b+e/\c+e..d+e = {})


  RULE EqualityXY.5
	(binhyp(b: A)) &
	(binhyp(not(a..b = {}))) &
	(bfalse)
	=>
	(a..b/\A = {})


  RULE EqualityXY.6
	(binhyp(a: A)) &
	(binhyp(not(a..b = {}))) &
	(bfalse)
	=>
	(a..b/\A = {})


  RULE EqualityXY.7
	(binhyp(not(b+1: A))) &
	(a..b/\A = {})
	=>
	(a..b+1/\A = {})


  RULE EqualityXY.8
	(binhyp(not(a-1: A))) &
	(a..b/\A = {})
	=>
	(a-1..b/\A = {})


  RULE EqualityXY.9
	(binhyp(a<=b+1)) &
	(binhyp(a..b/\A = {})) &
	(not(b+1: A))
	=>
	(a..b+1/\A = {})


  RULE EqualityXY.10
	(binhyp(a-1<=b)) &
	(binhyp(a..b/\A = {})) &
	(not(a-1: A))
	=>
	(a-1..b/\A = {})


  RULE EqualityXY.11
	(bguard(Fast_Prove_Order: a<=b)) &
	(bguard(Fast_Prove_Order: c<=d)) &
	(binhyp(a..b/\c..d = {})) &
	(not(d+1 = a))
	=>
	(c..d+1/\a..b = {})


  RULE EqualityXY.12
	(bguard(Fast_Prove_Order: a<=b)) &
	(bguard(Fast_Prove_Order: c<=d)) &
	(binhyp(c..d/\a..b = {})) &
	(not(d+1 = a))
	=>
	(c..d+1/\a..b = {})


  RULE EqualityXY.13
	(bguard(Fast_Prove_Order: a<=b)) &
	(a = c) &
	(b = d)
	=>
	(a..b = c..d)


  RULE EqualityXY.14
	(bguard(Fast_Prove_Order: c<=d)) &
	(a = c) &
	(b = d)
	=>
	(a..b = c..d)


  RULE EqualityXY.15
	(b+1<=a)
	=>
	(a..b = {})


  RULE EqualityXY.16
	(P => b = TRUE) &
	(b = TRUE => P)
	=>
	(b = bool(P))


  RULE EqualityXY.17
	(P => b = TRUE) &
	(b = TRUE => P)
	=>
	(bool(P) = b)


  RULE EqualityXY.18
	(not(a))
	=>
	(bool(a) = FALSE)


  RULE EqualityXY.19
	(a)
	=>
	(bool(a) = TRUE)


  RULE EqualityXY.20
	(a => b) &
	(b => a)
	=>
	(bool(a) = bool(b))


  RULE EqualityXY.21
	(a => b) &
	(b => a)
	=>
	(bool(not(a)) = bool(not(b)))


  RULE EqualityXY.22
	(a = FALSE)
	=>
	(FALSE = a)


  RULE EqualityXY.23
	(a = TRUE)
	=>
	(TRUE = a)


  RULE EqualityXY.24
	(bfalse)
	=>
	(TRUE = FALSE)


  RULE EqualityXY.25
	(bfalse)
	=>
	(FALSE = TRUE)


  RULE EqualityXY.26
	(t = {})
	=>
	(s^t = s)


  RULE EqualityXY.27
	(t = {})
	=>
	(t^s = s)


  RULE EqualityXY.28
	(a^b = c)
	=>
	(c = a^b)


  RULE EqualityXY.29
	(a = b\|/c)
	=>
	(b\|/c = a)


  RULE EqualityXY.30
	(a = b/|\c)
	=>
	(b/|\c = a)


  RULE EqualityXY.31
	(a->b = c)
	=>
	(c = a->b)


  RULE EqualityXY.32
	(a<-b = c)
	=>
	(c = a<-b)


  RULE EqualityXY.33
	(a = [b])
	=>
	([b] = a)


  RULE EqualityXY.34
	(binhyp(s: iseq(A))) &
	(s = {})
	=>
	(s/|\n = s\|/n)


  RULE EqualityXY.35
	(binhyp(s: iseq(A))) &
	(s = {})
	=>
	(s\|/n = s/|\n)


  RULE EqualityXY.36
	(size(b) = 0 => a = c) &
	(1<=size(b) => last(b) = c)
	=>
	(last(a->b) = c)


  RULE EqualityXY.37
	(size(a) = 0 => b = c) &
	(1<=size(a) => first(a) = c)
	=>
	(first(a<-b) = c)


  RULE EqualityXY.38
	band((binhyp(n<=size(a))), 
	(btest(n>0))) &
	(size(a) = 1 => b = c) &
	(2<=size(a) => first(a) = c)
	=>
	(first(a<+{size(a)|->b}) = c)


  RULE EqualityXY.39
	(size(s) = 1)
	=>
	(front(s) = {})


  RULE EqualityXY.40
	(size(s) = 1)
	=>
	(tail(s) = {})


  RULE EqualityXY.41
	(1<=n => s = {})
	=>
	(s/|\n = {})


  RULE EqualityXY.42
	(size(s)<=n)
	=>
	(s\|/n = {})


  RULE EqualityXY.43
	(a = b => c = d)
	=>
	({a}<|{b|->c} = {b}<|{a|->d})


  RULE EqualityXY.44
	(bsearch(a,b/\c,r)) &
	(a: POW(r))
	=>
	(a = b/\c)


  RULE EqualityXY.45
	(bsearch(a,b/\c,r)) &
	(a: POW(r))
	=>
	(b/\c = a)


  RULE EqualityXY.46
	(bsearch(a,b\/c,r)) &
	(r: POW(a))
	=>
	(b\/c = a)


  RULE EqualityXY.47
	(bsearch(a,b\/c,r)) &
	(r: POW(a))
	=>
	(a = b\/c)


  RULE EqualityXY.48
	(binhyp(g~: u +-> v)) &
	(binhyp(ran(g) = t)) &
	(dom(g): POW(a))
	=>
	(g[a] = t)


  RULE EqualityXY.49
	(binhyp(f: u +-> v)) &
	(binhyp(dom(f) = s)) &
	(ran(f): POW(a))
	=>
	(f~[a] = s)


  RULE EqualityXY.50
	(binhyp(f~: A +-> B)) &
	(u/\v/\dom(f) = {})
	=>
	(f[u]/\f[v] = {})


  RULE EqualityXY.51
	(binhyp(g: s +-> t)) &
	(dom(f)/\dom(g)<|f = dom(f)/\dom(g)<|g)
	=>
	(f<+g = f\/g)


  RULE EqualityXY.52
	(dom(f) = {})
	=>
	(ran(f) = {})


  RULE EqualityXY.53
	(u/\dom(r) = {})
	=>
	(r[u] = {})


  RULE EqualityXY.54
	(u/\dom(f) = {})
	=>
	(u<|f = {})


  RULE EqualityXY.55
	(dom(f): POW(u))
	=>
	(u<<|f = {})


  RULE EqualityXY.56
	(u/\ran(f) = {})
	=>
	(f|>u = {})


  RULE EqualityXY.57
	(ran(f): POW(u))
	=>
	(f|>>u = {})


  RULE EqualityXY.58
	(dom(g)<<|f = {}) &
	(g = {})
	=>
	(f<+g = {})


  RULE EqualityXY.59
	(not(a = 0) => b = 0)
	=>
	(a*b = 0)


  RULE EqualityXY.60
	(bnum(n)) &
	(a = n)
	=>
	(n = a)


  RULE EqualityXY.61
	(binhyp(A: POW(B))) &
	(not(B-A = {}) => min(A)<=min(B-A))
	=>
	(min(A) = min(B))


  RULE EqualityXY.62
	(binhyp(B: POW(A))) &
	(min(B) = min(A))
	=>
	(min(A) = min(B))


  RULE EqualityXY.63
	(binhyp(A: POW(B))) &
	(not(B-A = {}) => max(B-A)<=max(A))
	=>
	(max(A) = max(B))


  RULE EqualityXY.64
	(binhyp(B: POW(A))) &
	(max(B) = max(A))
	=>
	(max(A) = max(B))


  RULE EqualityXY.65
	(A = {})
	=>
	(card(A) = 0)


  RULE EqualityXY.66
	(A = {})
	=>
	(size(A) = 0)


  RULE EqualityXY.67
	(binhyp(a+b<=c)) &
	(btest(b>0)) &
	(bfalse)
	=>
	(a = c)


  RULE EqualityXY.68
	(binhyp(c+b<=a)) &
	(btest(b>0)) &
	(bfalse)
	=>
	(a = c)


  RULE EqualityXY.69
	(binhyp(m<=a)) &
	(btest(n
	(a = n)


  RULE EqualityXY.70
	(bnum(a)) &
	(bnum(b)) &
	(btest(a/=b)) &
	(bfalse)
	=>
	(a = b)


  RULE EqualityXY.71
	(A = {}) &
	(B = {})
	=>
	(A\/B = {})


  RULE EqualityXY.72
	(A/\B = {}) &
	(A/\C = {})
	=>
	(A/\(B\/C) = {})


  RULE EqualityXY.73
	(B/\A = {}) &
	(C/\A = {})
	=>
	(B\/C/\A = {})


  RULE EqualityXY.74
	(binhyp(A: POW(C))) &
	(A/\B = {})
	=>
	(A-B = A)


  RULE EqualityXY.75
	(binhyp(A: POW(C))) &
	(A/\B = {})
	=>
	(A = A-B)


  RULE EqualityXY.76
	(A/\{a} = {})
	=>
	(A = A-{a})


  RULE EqualityXY.77
	(A/\{a} = {})
	=>
	(A-{a} = A)


  RULE EqualityXY.78
	(A/\{a} = {})
	=>
	({a}-A = {a})


  RULE EqualityXY.79
	(A: POW(B))
	=>
	(A-B = {})


  RULE EqualityXY.80
	(A: POW(B))
	=>
	(A\/B = B)


  RULE EqualityXY.81
	(B: POW(A))
	=>
	(A\/B = A)


  RULE EqualityXY.82
	(A: POW(B))
	=>
	(A/\B = A)


  RULE EqualityXY.83
	(B: POW(A))
	=>
	(A/\B = B)


  RULE EqualityXY.84
	(A: POW(B))
	=>
	(B = A\/B)


  RULE EqualityXY.85
	(B: POW(A))
	=>
	(A = A\/B)


  RULE EqualityXY.86
	(A: POW(B))
	=>
	(A = A/\B)


  RULE EqualityXY.87
	(B: POW(A))
	=>
	(B = A/\B)


  RULE EqualityXY.88
	(A/\C = {})
	=>
	((A\/B)-C = A\/B-C)


  RULE EqualityXY.89
	(A/\C = {})
	=>
	(A\/B-C = (A\/B)-C)


  RULE EqualityXY.90
	(B/\C = {})
	=>
	((A\/B)-C = A-C\/B)


  RULE EqualityXY.91
	(B/\C = {})
	=>
	(A-C\/B = (A\/B)-C)


  RULE EqualityXY.92
	(binhyp(not(a: A))) &
	(a = b)
	=>
	(A\/{a} = A\/{b})


  RULE EqualityXY.93
	(binhyp(not(b: A))) &
	(a = b)
	=>
	(A\/{a} = A\/{b})


  RULE EqualityXY.94
	(binhyp(f~: t +-> s)) &
	(a = b)
	=>
	(f(a) = f(b))


  RULE EqualityXY.95
	(x = w) &
	(y = z)
	=>
	(x|->y = w|->z)


  RULE EqualityXY.96
	(btest(2<1))
	=>
	(__blankrule)


  RULE EqualityXY.97
	(btest(2<1))
	=>
	(__blankrule)


  RULE EqualityXY.98
	(bsearch({x},A/\B,R)) &
	(not(x: R))
	=>
	(A/\B = {})


  RULE EqualityXY.99
	(x\A) &
	(!x.not(P & x: A))
	=>
	(A/\SET(x).P = {})


  RULE EqualityXY.100
	(bfalse)
	=>
	({a} = {})


  RULE EqualityXY.101
	(bsearch((x: a),(P & Q),R)) &
	(!x.(x: a => not(R)))
	=>
	(SET(x).(P & Q) = {})


  RULE EqualityXY.102
	(bsearch((x = a),(P & Q),R)) &
	(!x.(x = a => not(R)))
	=>
	(SET(x).(P & Q) = {})


  RULE EqualityXY.103
	(bfalse)
	=>
	([a] = {})


  RULE EqualityXY.104
	(s = {}) &
	(t = {})
	=>
	(s^t = {})


  RULE EqualityXY.105
	(binhyp(A: POW({a}))) &
	(not(A = {}))
	=>
	(A = {a})


  RULE EqualityXY.106
	(bfresh(x,(A = SET(x).P),y)) &
	(binhyp(A: POW(SET(x).P))) &
	(!y.([x:=y]P => y: A))
	=>
	(A = SET(x).P)


  RULE EqualityXY.107
	(binhyp(1<=card(A))) &
	(bfalse)
	=>
	(A = {})


  RULE EqualityXY.108
	(binhyp(x: A)) &
	(bfalse)
	=>
	(A = {})


  RULE EqualityXY.109
	(A = {a})
	=>
	({a} = A)


  RULE EqualityXY.110
	(a = b)
	=>
	({a} = {b})


  RULE EqualityXY.111
	(bfalse)
	=>
	(BOOL = {})


  RULE EqualityXY.112
	(bfalse)
	=>
	(NATURAL = {})


  RULE EqualityXY.113
	(bfalse)
	=>
	(INTEGER = {})


  RULE EqualityXY.114
	(bfalse)
	=>
	({a} = {})


  RULE EqualityXY.115
	(A = {})
	=>
	({} = A)


  RULE EqualityXY.116
	(binhyp(d+1<=a))
	=>
	(a..b/\c..d = {})


  RULE EqualityXY.117
	(binhyp(b+1<=c))
	=>
	(a..b/\c..d = {})


  RULE EqualityXY.118
	band((binhyp(c..b/\A = {})), 
	(binhyp(c<=a)))
	=>
	(a..b/\A = {})


  RULE EqualityXY.119
	band((binhyp(a..c/\A = {})), 
	(binhyp(b<=c)))
	=>
	(a..b/\A = {})


  RULE EqualityXY.120
	(binhyp(ran(f)/\a = {}))
	=>
	(f[b]/\a = {})


  RULE EqualityXY.121
	(binhyp(ran(f)/\a = {}))
	=>
	(ran(b<<|f)/\a = {})


  RULE EqualityXY.122
	(binhyp(a/\dom(f) = {}))
	=>
	(a/\f~[c] = {})


  RULE EqualityXY.123
	(binhyp(a/\dom(f) = {}))
	=>
	(a/\dom(f|>>c) = {})


  RULE EqualityXY.124
	band((binhyp(A: POW(C))), 
	(binhyp(B/\C = {})))
	=>
	(A/\B = {})


  RULE EqualityXY.125
	band((binhyp(B: POW(C))), 
	(binhyp(A/\C = {})))
	=>
	(A/\B = {})


  RULE EqualityXY.126
	band((binhyp(x|->y: t)), 
	band((binhyp(x|->z: t)), 
	(binhyp(t: a +-> b))))
	=>
	(z = y)


  RULE EqualityXY.127
	band((binhyp(x|->y: t)), 
	band((binhyp(x|->z: t)), 
	(binhyp(t: a +-> b))))
	=>
	(y = z)


  RULE EqualityXY.128
	(binhyp(A: POW(B))) &
	(binhyp(B: POW(A)))
	=>
	(A = B)


  RULE EqualityXY.129
	(binhyp(A: POW(B))) &
	(binhyp(card(A) = card(B)))
	=>
	(A = B)


  RULE EqualityXY.130
	(binhyp(B: POW(A))) &
	(binhyp(card(A) = card(B)))
	=>
	(A = B)


  RULE EqualityXY.131
	(binhyp(B/\A = C))
	=>
	(A/\B = C)


  RULE EqualityXY.132
	(binhyp(B\/A = C))
	=>
	(A\/B = C)


  RULE EqualityXY.133
	(binhyp(f(a) = f(b))) &
	(binhyp(f~: t +-> s))
	=>
	(a = b)


  RULE EqualityXY.134
	a = a-0


  RULE EqualityXY.135
	(binhyp({a} = {b}))
	=>
	(a = b)


  RULE EqualityXY.136
	A/\(B\/C) = A/\B\/(A/\C)


  RULE EqualityXY.137
	B\/C/\A = B/\A\/(C/\A)


  RULE EqualityXY.138
	A/\B\/C = A\/C/\(B\/C)


  RULE EqualityXY.139
	A\/(B/\C) = A\/B/\(A\/C)


  RULE EqualityXY.140
	A/\B\/(A/\C) = A/\(B\/C)


  RULE EqualityXY.141
	B/\A\/(C/\A) = B\/C/\A


  RULE EqualityXY.142
	A\/C/\(B\/C) = A/\B\/C


  RULE EqualityXY.143
	A\/B/\(A\/C) = A\/(B/\C)


  RULE EqualityXY.144
	band((binhyp(U*V = U*A)), 
	(binhyp(not(U = {}))))
	=>
	(V = A)


  RULE EqualityXY.145
	band((binhyp(V*U = A*U)), 
	(binhyp(not(U = {}))))
	=>
	(V = A)


  RULE EqualityXY.146
	(binhyp(not(T = {})))
	=>
	(dom(S*T) = S)


  RULE EqualityXY.147
	(binhyp(not(S = {})))
	=>
	(ran(S*T) = T)


  RULE EqualityXY.148
	POW(A)/\POW(B) = POW(A/\B)


  RULE EqualityXY.149
	(binhyp(ran(p): POW(dom(q))))
	=>
	(dom(p;q) = dom(p))


  RULE EqualityXY.150
	(binhyp(dom(q): POW(ran(p))))
	=>
	(ran(p;q) = ran(q))


  RULE EqualityXY.151
	dom(A*A) = A


  RULE EqualityXY.152
	A\/B = B\/A


  RULE EqualityXY.153
	A/\B = B/\A


  RULE EqualityXY.154
	A\/B\/C = A\/C\/B


  RULE EqualityXY.155
	A\/B\/C = C\/A\/B


  RULE EqualityXY.156
	A\/B\/C = B\/A\/C


  RULE EqualityXY.157
	A\/B\/C = B\/C\/A


  RULE EqualityXY.158
	A\/B\/C = C\/B\/A


  RULE EqualityXY.159
	A/\B/\C = A/\C/\B


  RULE EqualityXY.160
	A/\B/\C = C/\A/\B


  RULE EqualityXY.161
	A/\B/\C = B/\A/\C


  RULE EqualityXY.162
	A/\B/\C = B/\C/\A


  RULE EqualityXY.163
	A/\B/\C = C/\B/\A


  RULE EqualityXY.164
	a = a


  RULE EqualityXY.165
	a-a = 0



THEORY ExistTryXY IS



  RULE ExistTryXY.1
	band((bsearch((x: s),(P & btrue),(Q & btrue))), 
	band((x\s), 
	band((binhyp(y: s)), 
	(y\s)))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e([x:=y]Q | Curr)))
	=>
	(#x.P)



THEORY ExistXY IS



  RULE ExistXY.1
	band((bsearch(Q,(P & btrue),S)), 
	band((L\S), 
	(v\Q))) &
	(#L.Q) &
	(#v.S)
	=>
	(#(L,v).P)


  RULE ExistXY.2
	(bsearch((x: INTEGER),(P & btrue),R)) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e([x:=0]P | Curr)))
	=>
	(#x.P)


  RULE ExistXY.3
	(x\P) &
	(P) &
	(#x.Q)
	=>
	(#x.(P & Q))


  RULE ExistXY.4
	(x\Q) &
	(#x.P) &
	(Q)
	=>
	(#x.(P & Q))


  RULE ExistXY.5
	(y\P) &
	(#x.(P & #y.Q))
	=>
	(#(x,y).(P & Q))


  RULE ExistXY.6
	(#x.P or #x.Q)
	=>
	(#x.(P or Q))


  RULE ExistXY.7
	(x\P) &
	(P or #x.Q)
	=>
	(#x.(P or Q))


  RULE ExistXY.8
	(x\Q) &
	(#x.P or Q)
	=>
	(#x.(P or Q))


  RULE ExistXY.9
	(y\P) &
	(#x.(P or #y.Q))
	=>
	(#(x,y).(P or Q))


  RULE ExistXY.10
	(B = {} => A = {}) &
	(f\(A,B))
	=>
	(#f.(f: A +-> B & dom(f) = A))


  RULE ExistXY.11
	(bsearch((x = E),(P & btrue),(Q & btrue))) &
	(x\E) &
	(WD(expr(E),Z)) &
	([x:=E]Q)
	=>
	(#x.P)


  RULE ExistXY.12
	(bsearch((E = x),(P & btrue),(Q & btrue))) &
	(x\E) &
	(WD(expr(E),Z)) &
	([x:=E]Q)
	=>
	(#x.P)


  RULE ExistXY.13
	(bsearch((y = E),(P & btrue),(Q & btrue))) &
	(y\E) &
	(bsearch(y,(w,x),z)) &
	(WD(expr(E),Z)) &
	(#z.[y:=E]Q)
	=>
	(#(w,x).P)


  RULE ExistXY.14
	(bsearch((E = y),(P & btrue),(Q & btrue))) &
	(y\E) &
	(bsearch(y,(w,x),z)) &
	(WD(expr(E),Z)) &
	(#z.[y:=E]Q)
	=>
	(#(w,x).P)


  RULE ExistXY.15
	(not(#x.P) => #x.Q)
	=>
	(#x.(not(P) => Q))


  RULE ExistXY.16
	(a\A) &
	(not(A = {}))
	=>
	(#a.(a: A))


  RULE ExistXY.17
	#x.(x: POW(A))


  RULE ExistXY.18
	(x\E)
	=>
	(#x.(x = E))


  RULE ExistXY.19
	(btest(2<1))
	=>
	(__blankrule)


  RULE ExistXY.20
	(btest(2<1))
	=>
	(__blankrule)


  RULE ExistXY.21
	(btest(2<1))
	=>
	(__blankrule)


  RULE ExistXY.22
	(btest(2<1))
	=>
	(__blankrule)


  RULE ExistXY.23
	(btest(2<1))
	=>
	(__blankrule)


  RULE ExistXY.24
	(btest(2<1))
	=>
	(__blankrule)


  RULE ExistXY.25
	(btest(2<1))
	=>
	(__blankrule)


  RULE ExistXY.26
	#x.(x: INTEGER)


  RULE ExistXY.27
	#x.(x: BOOL)


  RULE ExistXY.28
	#f.(f: A +-> B & f~: B +-> A)


  RULE ExistXY.29
	#f.(f: A +-> B)


  RULE ExistXY.30
	#x.(x: INTEGER & 0<=x & 1<=x)


  RULE ExistXY.31
	#x.btrue



THEORY ForAllX IS



  RULE ForAllX.1
	(bsearch((a = b),(P & btrue),R)) &
	(a\b) &
	(WD(expr(b),Z)) &
	([a:=b](R => Q))
	=>
	(!a.(P => Q))


  RULE ForAllX.2
	(bsearch((b = a),(P & btrue),R)) &
	(a\b) &
	(WD(expr(b),Z)) &
	([a:=b](R => Q))
	=>
	(!a.(P => Q))


  RULE ForAllX.3
	(a\A) &
	(A = {})
	=>
	(!a.not(a: A))


  RULE ForAllX.4
	(bfalse)
	=>
	(!a.bfalse)


  RULE ForAllX.5
	!a.btrue



THEORY ImplicationXY IS



  RULE ImplicationXY.1
	(binhyp(not(Q))) &
	(P => bfalse)
	=>
	(P => Q)


  RULE ImplicationXY.2
	(not(A))
	=>
	(A => not(A))


  RULE ImplicationXY.3
	(A)
	=>
	(not(A) => A)


  RULE ImplicationXY.4
	(P)
	=>
	(btrue => P)



THEORY b1 IS



  RULE b1.1
	(btest(2<1))
	=>
	(__blankrule)


  RULE b1.2
	(btest(2<1))
	=>
	(__blankrule)


  RULE b1.3
	(a: E => a: A & b: B)
	=>
	(E<|{a|->b}: A +-> B)


  RULE b1.4
	(X<<|f: POW(A)) &
	(X<<|g: POW(A))
	=>
	(X<<|(f\/g): POW(A))


  RULE b1.5
	(X<|f: POW(A)) &
	(X<|g: POW(A))
	=>
	(X<|(f\/g): POW(A))


  RULE b1.6
	(A <: C) &
	({b} <: C)
	=>
	(A\/{b} <: C)


  RULE b1.7
	(not(a: A)) &
	(not(a = b))
	=>
	(not(a: A\/{b}))


  RULE b1.8
	(not(a: A[c])) &
	(not(a: {b}[c]))
	=>
	(not(a: (A\/{b})[c]))


  RULE b1.9
	(not(a = {})) &
	(not(b = {}))
	=>
	(not(a*b = {}))


  RULE b1.10
	band((binhyp(max(A)<=a)), 
	band((binhyp(max(B)<=b)), 
	band((bguard(Fast_Prove_Order: a<=c)), 
	(bguard(Fast_Prove_Order: b<=c)))))
	=>
	(max(A\/B)<=c)


  RULE b1.11
	band((binhyp(a<=min(A))), 
	band((binhyp(b<=min(B))), 
	band((bguard(Fast_Prove_Order: c<=a)), 
	(bguard(Fast_Prove_Order: c<=b)))))
	=>
	(c<=min(A\/B))


  RULE b1.12
	band((binhyp(g = v)), 
	band((bnum(v)), 
	band((binhyp(g = w)), 
	band((bnum(w)), 
	(bnot(btest(v = w)))))))
	=>
	(P)


  RULE b1.13
	band((binhyp(c)), 
	(bsearch(c,(a or b),d)))
	=>
	(a or b)


  RULE b1.14
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(x: A | Curr)))
	=>
	(x: f<+A)


  RULE b1.15
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(ran(f): POW(t) | Curr)))
	=>
	(f(x): t)


  RULE b1.16
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(f: A +-> B | Curr))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(a: A +-> B | Curr)))
	=>
	(f<+a: A +-> B)


  RULE b1.17
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(x: f~[{y}] | Curr)))
	=>
	(x|->y: f)


  RULE b1.18
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(x: dom(f) | Curr))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(x: X | Curr)))
	=>
	(f(x): f[X])


  RULE b1.19
	(binhyp(f: POW(E)))
	=>
	(A<<|f|>B: POW(E))


  RULE b1.20
	(binhyp(f: POW(E)))
	=>
	(f|>B: POW(E))


  RULE b1.21
	(binhyp(f: POW(E)))
	=>
	(A<|f: POW(E))


  RULE b1.22
	(binhyp(f: POW(E)))
	=>
	(f|>>B: POW(E))


  RULE b1.23
	(binhyp(f: POW(E)))
	=>
	(A<<|f: POW(E))


  RULE b1.24
	(bsearch(B,C\/D,E))
	=>
	(A/\B: POW(C\/D))


  RULE b1.25
	(bsearch(A,C\/D,E))
	=>
	(A/\B: POW(C\/D))


  RULE b1.26
	(binhyp(f: POW(E)))
	=>
	(A<|f|>>B: POW(E))


  RULE b1.27
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(1..n: POW(S) | Curr)))
	=>
	(id(1..n): seq(S))


  RULE b1.28
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(f: POW(A) | Curr))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(f: POW(B) | Curr)))
	=>
	(id(f): A +-> B)


  RULE b1.29
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(E: POW(F) | Curr)))
	=>
	(min(E): F)


  RULE b1.30
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(E: POW(F) | Curr)))
	=>
	(max(E): F)


  RULE b1.31
	(bsearch({a|->b},E\/F,R))
	=>
	(a,b: E\/F)


  RULE b1.32
	(binhyp(dom(A)/\dom(B) = {}))
	=>
	(dom(B)<|A = dom(A)<|B)


  RULE b1.33
	(binhyp(dom(B)/\dom(A) = {}))
	=>
	(dom(B)<|A = dom(A)<|B)


  RULE b1.34
	(binhyp(f: A +-> B)) &
	(binhyp(x: f~[{y}]))
	=>
	(f(x) = y)


  RULE b1.35
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(f = g | Curr)))
	=>
	(f<+h = g<+h)


  RULE b1.36
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e({h}<<|f = {} | Curr)))
	=>
	(f<+{h|->i} = {h|->i})


  RULE b1.37
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e({h}\/H<<|f = {} | Curr))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(not(h: H) | Curr)))
	=>
	(H<<|(f<+{h|->i}) = {h|->i})


  RULE b1.38
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e({h}<<|f = g | Curr)))
	=>
	(f<+{h|->i} = g\/{h|->i})


  RULE b1.39
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e({h}\/H<<|f = g | Curr))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(not(h: H) | Curr)))
	=>
	(H<<|(f<+{h|->i}) = g\/{h|->i})


  RULE b1.40
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(dom(d<|f) <: dom(g) | Curr))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(dom(g) <: d | Curr)))
	=>
	(d<|(f<+g) = g)


  RULE b1.41
	(binhyp(A<<|f = A<<|g)) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(not(x: A) | Curr)))
	=>
	(f(x) = g(x))


  RULE b1.42
	(binhyp(A<|f = A<|g)) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(x: A | Curr)))
	=>
	(f(x) = g(x))


  RULE b1.43
	(binhyp(b = {}))
	=>
	(not(a: b))


  RULE b1.44
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(not(x: dom(f)) | Curr)))
	=>
	(not(x|->y: f))


  RULE b1.45
	(bsearch({V|->v},A\/{b},R))
	=>
	(not((A\/{b})[{V}] = {}))


  RULE b1.46
	(bguard(Fast_Prove_Order: b<=c))
	=>
	(a mod b<=c)


  RULE b1.47
	(j\(a,b,f)) &
	(binhyp(f: A +-> B)) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(a<=b | Curr))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(not(B = {}) | Curr))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(B: FIN(B) | Curr))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(N<=(b-a+1)*min(B) | Curr)))
	=>
	(N<=SIGMA(j).(j: a..b | f(j)))


  RULE b1.48
	(j\(a,b,f)) &
	(binhyp(f: A +-> B)) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(a<=b | Curr))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(not(B = {}) | Curr))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(B: FIN(B) | Curr))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e((b-a+1)*max(B)<=N | Curr)))
	=>
	(SIGMA(j).(j: a..b | f(j))<=N)


  RULE b1.49
	(binhyp(f: A +-> B)) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(not(B = {}) | Curr))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(B: FIN(B) | Curr))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(a<=min(B) | Curr)))
	=>
	(a<=f(x))


  RULE b1.50
	(binhyp(f: A +-> B)) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(not(B = {}) | Curr))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(B: FIN(B) | Curr))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(max(B)<=b | Curr)))
	=>
	(f(x)<=b)


  RULE b1.51
	(bguard(Fast_Prove_Order: 1<=b)) &
	(binhyp(a: 0..n)) &
	(bguard(Fast_Prove_Order: n<=MAXINT))
	=>
	(a/b<=MAXINT)


  RULE b1.52
	(bguard(Fast_Prove_Order: c<=0)) &
	(bguard(Fast_Prove_Order: 1<=b)) &
	(binhyp(a: 0..n))
	=>
	(c<=a/b)


  RULE b1.53
	(binhyp(E <: NATURAL))
	=>
	(0<=max(E))


  RULE b1.54
	(bsearch({a},A\/B,C))
	=>
	(a<=max(A\/B))


  RULE b1.55
	(bsearch({b},A\/B,C))
	=>
	(min(A\/B)<=b)


  RULE b1.56
	f~[A]: POW(dom(f))


  RULE b1.57
	A<<|f|>>B: POW(f)


  RULE b1.58
	min({a}\/{b})+c = min({a+c}\/{b+c})


  RULE b1.59
	0<=a mod b


  RULE b1.60
	a mod b+1<=b


  RULE b1.61
	a mod b: INTEGER


  RULE b1.62
	a/b: INTEGER



THEORY s1 IS



  RULE s1.1
	SIGMA(x).(A | b+c) == SIGMA(x).(A | b)+SIGMA(x).(A | c)


  RULE s1.2
	SIGMA(x).(A | b-c) == SIGMA(x).(A | b)-SIGMA(x).(A | c)


  RULE s1.3
	(binhyp(a/\b = {})) &
	(blvar(Q)) &
	(Q\(b,a))
	=>
	SIGMA(x).(x: a\/b | e) == SIGMA(x).(x: a | e)+SIGMA(x).(x: b | e)


  RULE s1.4
	(bnot(bpattern(x,(y,z)))) &
	(x\b)
	=>
	SIGMA(x).(x = b | P) == [x:=b]P


  RULE s1.5
	SIGMA(x).(P | 0) == 0


  RULE s1.6
	SIGMA(x).(bfalse | e) == 0


  RULE s1.7
	PI(x).(bfalse | e) == 1


  RULE s1.8
	PI(x).(P | 1) == 1


  RULE s1.9
	(binhyp(H)) &
	(blvar(Q)) &
	(Q\H)
	=>
	bool(H) == TRUE


  RULE s1.10
	(binhyp(not(H))) &
	(blvar(Q)) &
	(Q\H)
	=>
	bool(H) == FALSE


  RULE s1.11
	(bsearch({x|->y},A\/B,C))
	=>
	(A\/B)(x) == y


  RULE s1.12
	(binhyp(F: A +-> B)) &
	(bguard(Fast_Prove_Difference: not(x = a))) &
	(blvar(Q)) &
	(Q\(x = a,A,B,F))
	=>
	(F<+{x|->y})(a) == F(a)


  RULE s1.13
	(F<+{a|->b})(a) == b


  RULE s1.14
	(bguard(Fast_Prove_Order: a<=b)) &
	(bguard(Fast_Prove_All_Order: c+1<=a)) &
	(blvar(Q)) &
	(Q\(c,a,b))
	=>
	a..b<|(f<+{c|->d}) == a..b<|f


  RULE s1.15
	(bguard(Fast_Prove_Order: a<=b)) &
	(bguard(Fast_Prove_All_Order: b+1<=c)) &
	(blvar(Q)) &
	(Q\(c,a,b))
	=>
	a..b<|(f<+{c|->d}) == a..b<|f


  RULE s1.16
	(bguard(Fast_Prove_Difference: not(b = a))) &
	(blvar(Q)) &
	(Q\(a,b))
	=>
	{a}<|{b|->c} == {}


  RULE s1.17
	(bsearch({x|->y},A\/B,C))
	=>
	{x}<<|(A\/B) == {x}<<|C


  RULE s1.18
	f<+{a|->b}|>>{b} == {a}<<|f|>>{b}


  RULE s1.19
	(binhyp(a: ran(f))) &
	(binhyp(f~: A +-> B)) &
	(blvar(Q)) &
	(Q\(f,a))
	=>
	f~[{a}] == {f~(a)}


  RULE s1.20
	(bsearch({a|->b},A\/B,C))
	=>
	(A\/B)[{a}] == C[{a}]\/{b}


  RULE s1.21
	(band(binhyp(not(x: dom(f)),bsearch({x},A\/B,C)))) &
	(blvar(Q)) &
	(Q\(x,f))
	=>
	f[A\/B] == f[C]


  RULE s1.22
	{(x,y)|->z}~[{z}] == {x|->y}


  RULE s1.23
	(a\/{(x,y)|->z})~[{z}] == a~[{z}]\/{x|->y}


  RULE s1.24
	(bguard(Fast_Prove_Order: 0<=a)) &
	(blvar(Q)) &
	(Q\a)
	=>
	(a+b) mod b == a mod b


  RULE s1.25
	(bguard(Fast_Prove_Order: a+1<=b)) &
	(blvar(Q)) &
	(Q\(a,b))
	=>
	a mod b == a



THEORY f1 IS



  RULE f1.1
	(A or a => B) &
	(bnot(binhyp(B))) &
	band((bsearch(X,(A or a),R)), 
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(X | Curr))))
	=>
	(B)


  RULE f1.2
	(A & a => B) &
	(bnot(binhyp(B))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(a | Curr))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(A | Curr)))
	=>
	(B)


  RULE f1.3
	(H) &
	band((binhyp(P or R => Q)), 
	band((bsearch(H,(P or R),S)), 
	(bnot(binhyp(S => Q)))))
	=>
	(S => Q)



THEORY InFINXY IS



  RULE InFINXY.1
	(bguard(RecordMakeListX: RecordMakeListG(InFin,L,M),R)) &
	(R)
	=>
	(struct(M): FIN(struct(L)))


  RULE InFINXY.2
	(A: POW(B)) &
	(A: POW(B) => A: FIN(B))
	=>
	(A: FIN(B))


  RULE InFINXY.3
	(a = {})
	=>
	(a: FIN({}))


  RULE InFINXY.4
	(a: POW({b}))
	=>
	(a: FIN({b}))


  RULE InFINXY.5
	band((binhyp(b: FIN(B))), 
	(binhyp(c: FIN(C)))) &
	(a: POW(b\/c))
	=>
	(a: FIN(b\/c))


  RULE InFINXY.6
	(binhyp(c: FIN(C))) &
	(a: POW(b/\c))
	=>
	(a: FIN(b/\c))


  RULE InFINXY.7
	(binhyp(b: FIN(B))) &
	(a: POW(b/\c))
	=>
	(a: FIN(b/\c))


  RULE InFINXY.8
	(binhyp(b: FIN(B))) &
	(a: POW(b-c))
	=>
	(a: FIN(b-c))


  RULE InFINXY.9
	(r: POW((a..b)*(c..d)))
	=>
	(r: FIN((a..b)*(c..d)))


  RULE InFINXY.10
	band((binhyp(r: B <-> C)), 
	(binhyp(B: FIN(D)))) &
	(a: POW(dom(r)))
	=>
	(a: FIN(dom(r)))


  RULE InFINXY.11
	band((binhyp(r: B <-> C)), 
	(binhyp(dom(r): FIN(D)))) &
	(a: POW(dom(r)))
	=>
	(a: FIN(dom(r)))


  RULE InFINXY.12
	band((binhyp(r~: C +-> B)), 
	(binhyp(C: FIN(D)))) &
	(a: POW(dom(r)))
	=>
	(a: FIN(dom(r)))


  RULE InFINXY.13
	band((binhyp(r~: C +-> B)), 
	(binhyp(ran(r): FIN(D)))) &
	(a: POW(dom(r)))
	=>
	(a: FIN(dom(r)))


  RULE InFINXY.14
	band((binhyp(r: B +-> C)), 
	(binhyp(B: FIN(D)))) &
	(a: POW(ran(r)))
	=>
	(a: FIN(ran(r)))


  RULE InFINXY.15
	band((binhyp(r: B +-> C)), 
	(binhyp(dom(r): FIN(D)))) &
	(a: POW(ran(r)))
	=>
	(a: FIN(ran(r)))


  RULE InFINXY.16
	band((binhyp(r: B <-> C)), 
	(binhyp(C: FIN(D)))) &
	(a: POW(ran(r)))
	=>
	(a: FIN(ran(r)))


  RULE InFINXY.17
	band((binhyp(r: B <-> C)), 
	(binhyp(ran(r): FIN(D)))) &
	(a: POW(ran(r)))
	=>
	(a: FIN(ran(r)))


  RULE InFINXY.18
	band((binhyp(r: B +-> C)), 
	(binhyp(B: FIN(D)))) &
	(a: POW(u<|r))
	=>
	(a: FIN(u<|r))


  RULE InFINXY.19
	band((binhyp(r: B +-> C)), 
	(binhyp(dom(r): FIN(B)))) &
	(a: POW(u<|r))
	=>
	(a: FIN(u<|r))


  RULE InFINXY.20
	band((binhyp(r~: C +-> B)), 
	(binhyp(C: FIN(D)))) &
	(a: POW(u<|r))
	=>
	(a: FIN(u<|r))


  RULE InFINXY.21
	band((binhyp(r~: C +-> B)), 
	(binhyp(ran(r): FIN(D)))) &
	(a: POW(u<|r))
	=>
	(a: FIN(u<|r))


  RULE InFINXY.22
	band((binhyp(r: B +-> C)), 
	(binhyp(dom(r)/\u: FIN(D)))) &
	(a: POW(u<|r))
	=>
	(a: FIN(u<|r))


  RULE InFINXY.23
	band((binhyp(r: B +-> C)), 
	(binhyp(u/\dom(r): FIN(D)))) &
	(a: POW(u<|r))
	=>
	(a: FIN(u<|r))


  RULE InFINXY.24
	band((binhyp(r: B +-> C)), 
	(binhyp(u: FIN(D)))) &
	(a: POW(u<|r))
	=>
	(a: FIN(u<|r))


  RULE InFINXY.25
	band((binhyp(r: B +-> C)), 
	(binhyp(B: FIN(D)))) &
	(a: POW(u<<|r))
	=>
	(a: FIN(u<<|r))


  RULE InFINXY.26
	band((binhyp(r: B +-> C)), 
	(binhyp(dom(r): FIN(B)))) &
	(a: POW(u<<|r))
	=>
	(a: FIN(u<<|r))


  RULE InFINXY.27
	band((binhyp(r~: C +-> B)), 
	(binhyp(C: FIN(D)))) &
	(a: POW(u<<|r))
	=>
	(a: FIN(u<<|r))


  RULE InFINXY.28
	band((binhyp(r~: C +-> B)), 
	(binhyp(ran(r): FIN(D)))) &
	(a: POW(u<<|r))
	=>
	(a: FIN(u<<|r))


  RULE InFINXY.29
	band((binhyp(r: B +-> C)), 
	(binhyp(dom(r)-u: FIN(D)))) &
	(a: POW(u<<|r))
	=>
	(a: FIN(u<<|r))


  RULE InFINXY.30
	band((binhyp(r: B +-> C)), 
	(binhyp(B: FIN(D)))) &
	(a: POW(r|>u))
	=>
	(a: FIN(r|>u))


  RULE InFINXY.31
	band((binhyp(r: B +-> C)), 
	(binhyp(dom(r): FIN(B)))) &
	(a: POW(r|>u))
	=>
	(a: FIN(r|>u))


  RULE InFINXY.32
	band((binhyp(r~: C +-> B)), 
	(binhyp(C: FIN(D)))) &
	(a: POW(r|>u))
	=>
	(a: FIN(r|>u))


  RULE InFINXY.33
	band((binhyp(r~: C +-> B)), 
	(binhyp(ran(r): FIN(D)))) &
	(a: POW(r|>u))
	=>
	(a: FIN(r|>u))


  RULE InFINXY.34
	band((binhyp(r~: C +-> B)), 
	(binhyp(ran(r)/\u: FIN(D)))) &
	(a: POW(r|>u))
	=>
	(a: FIN(r|>u))


  RULE InFINXY.35
	band((binhyp(r~: C +-> B)), 
	(binhyp(u/\ran(r): FIN(D)))) &
	(a: POW(r|>u))
	=>
	(a: FIN(r|>u))


  RULE InFINXY.36
	band((binhyp(r~: C +-> B)), 
	(binhyp(u: FIN(D)))) &
	(a: POW(r|>u))
	=>
	(a: FIN(r|>u))


  RULE InFINXY.37
	band((binhyp(r: B +-> C)), 
	(binhyp(B: FIN(D)))) &
	(a: POW(r|>>u))
	=>
	(a: FIN(r|>>u))


  RULE InFINXY.38
	band((binhyp(r: B +-> C)), 
	(binhyp(dom(r): FIN(B)))) &
	(a: POW(r|>>u))
	=>
	(a: FIN(r|>>u))


  RULE InFINXY.39
	band((binhyp(r~: C +-> B)), 
	(binhyp(C: FIN(D)))) &
	(a: POW(r|>>u))
	=>
	(a: FIN(r|>>u))


  RULE InFINXY.40
	band((binhyp(r~: C +-> B)), 
	(binhyp(ran(r): FIN(D)))) &
	(a: POW(r|>>u))
	=>
	(a: FIN(r|>>u))


  RULE InFINXY.41
	band((binhyp(r~: C +-> B)), 
	(binhyp(ran(r)-u: FIN(D)))) &
	(a: POW(r|>>u))
	=>
	(a: FIN(r|>>u))


  RULE InFINXY.42
	band((binhyp(r: B +-> C)), 
	(binhyp(B: FIN(D)))) &
	(a: POW(r<+{x}))
	=>
	(a: FIN(r<+{x}))


  RULE InFINXY.43
	band((binhyp(r: B +-> C)), 
	(binhyp(dom(r): FIN(D)))) &
	(a: POW(r<+{x}))
	=>
	(a: FIN(r<+{x}))


  RULE InFINXY.44
	band((binhyp(r~: C +-> B)), 
	(binhyp(C: FIN(D)))) &
	(a: POW(r<+{x}))
	=>
	(a: FIN(r<+{x}))


  RULE InFINXY.45
	band((binhyp(r~: C +-> B)), 
	(binhyp(ran(r): FIN(D)))) &
	(a: POW(r<+{x}))
	=>
	(a: FIN(r<+{x}))


  RULE InFINXY.46
	(x: POW(a..b))
	=>
	(x: FIN(a..b))


  RULE InFINXY.47
	band((binhyp(r: B +-> C)), 
	(binhyp(B: FIN(D)))) &
	(a: POW(r[u]))
	=>
	(a: FIN(r[u]))


  RULE InFINXY.48
	band((binhyp(r: B +-> C)), 
	(binhyp(dom(r): FIN(D)))) &
	(a: POW(r[u]))
	=>
	(a: FIN(r[u]))


  RULE InFINXY.49
	band((binhyp(r: B <-> C)), 
	(binhyp(C: FIN(D)))) &
	(a: POW(r[u]))
	=>
	(a: FIN(r[u]))


  RULE InFINXY.50
	band((binhyp(r: B <-> C)), 
	(binhyp(ran(r): FIN(D)))) &
	(a: POW(r[u]))
	=>
	(a: FIN(r[u]))


  RULE InFINXY.51
	band((binhyp(r: B +-> C)), 
	(binhyp(u: FIN(D)))) &
	(a: POW(r[u]))
	=>
	(a: FIN(r[u]))


  RULE InFINXY.52
	band((binhyp(r: B +-> C)), 
	(binhyp(dom(r)/\u: FIN(D)))) &
	(a: POW(r[u]))
	=>
	(a: FIN(r[u]))


  RULE InFINXY.53
	band((binhyp(r: B +-> C)), 
	(binhyp(u/\dom(r): FIN(D)))) &
	(a: POW(r[u]))
	=>
	(a: FIN(r[u]))


  RULE InFINXY.54
	(a: S)
	=>
	({a}: FIN(S))


  RULE InFINXY.55
	(b: S) &
	(a: FIN(S))
	=>
	(a\/{b}: FIN(S))


  RULE InFINXY.56
	(x\T) &
	(T: FIN(S))
	=>
	(SET(x).(x: T): FIN(S))


  RULE InFINXY.57
	(a: FIN(S)) &
	(b: FIN(S))
	=>
	(a\/b: FIN(S))


  RULE InFINXY.58
	(s/\{a}: POW(S))
	=>
	(s/\{a}: FIN(S))


  RULE InFINXY.59
	(s/\{a}: POW(S))
	=>
	({a}/\s: FIN(S))


  RULE InFINXY.60
	(binhyp(t: FIN(T))) &
	(s/\t: POW(S))
	=>
	(s/\t: FIN(S))


  RULE InFINXY.61
	(binhyp(s: FIN(S))) &
	(s/\t: POW(T))
	=>
	(s/\t: FIN(T))


  RULE InFINXY.62
	({a}-t: POW(S))
	=>
	({a}-t: FIN(S))


  RULE InFINXY.63
	((n..p)-t: POW(S))
	=>
	((n..p)-t: FIN(S))


  RULE InFINXY.64
	(binhyp(s: FIN(S))) &
	(s-t: POW(T))
	=>
	(s-t: FIN(T))


  RULE InFINXY.65
	(btest(2<1))
	=>
	(__blankrule)


  RULE InFINXY.66
	(binhyp(r: n..p <-> B)) &
	(dom(r): POW(S))
	=>
	(dom(r): FIN(S))


  RULE InFINXY.67
	band((binhyp(r: A <-> B)), 
	(binhyp(A: FIN(D)))) &
	(dom(r): POW(S))
	=>
	(dom(r): FIN(S))


  RULE InFINXY.68
	band((binhyp(r: A <-> B)), 
	(binhyp(dom(r): FIN(D)))) &
	(dom(r): POW(S))
	=>
	(dom(r): FIN(S))


  RULE InFINXY.69
	band((binhyp(r~: B +-> A)), 
	(binhyp(B: FIN(D)))) &
	(dom(r): POW(S))
	=>
	(dom(r): FIN(S))


  RULE InFINXY.70
	band((binhyp(r~: B +-> A)), 
	(binhyp(ran(r): FIN(D)))) &
	(dom(r): POW(S))
	=>
	(dom(r): FIN(S))


  RULE InFINXY.71
	(binhyp(r: A <-> n..p)) &
	(ran(r): POW(S))
	=>
	(ran(r): FIN(S))


  RULE InFINXY.72
	band((binhyp(r: A +-> B)), 
	(binhyp(A: FIN(D)))) &
	(ran(r): POW(S))
	=>
	(ran(r): FIN(S))


  RULE InFINXY.73
	band((binhyp(r: A +-> B)), 
	(binhyp(dom(r): FIN(D)))) &
	(ran(r): POW(S))
	=>
	(ran(r): FIN(S))


  RULE InFINXY.74
	band((binhyp(r: A <-> B)), 
	(binhyp(B: FIN(D)))) &
	(ran(r): POW(S))
	=>
	(ran(r): FIN(S))


  RULE InFINXY.75
	band((binhyp(r: A <-> B)), 
	(binhyp(ran(r): FIN(D)))) &
	(ran(r): POW(S))
	=>
	(ran(r): FIN(S))


  RULE InFINXY.76
	band((binhyp(r: B +-> C)), 
	(binhyp(B: FIN(D)))) &
	(u<|r: POW(S))
	=>
	(u<|r: FIN(S))


  RULE InFINXY.77
	band((binhyp(r: B +-> C)), 
	(binhyp(dom(r): FIN(B)))) &
	(u<|r: POW(S))
	=>
	(u<|r: FIN(S))


  RULE InFINXY.78
	band((binhyp(r~: C +-> B)), 
	(binhyp(C: FIN(D)))) &
	(u<|r: POW(S))
	=>
	(u<|r: FIN(S))


  RULE InFINXY.79
	band((binhyp(r~: C +-> B)), 
	(binhyp(ran(r): FIN(D)))) &
	(u<|r: POW(S))
	=>
	(u<|r: FIN(S))


  RULE InFINXY.80
	band((binhyp(r: B +-> C)), 
	(binhyp(dom(r)/\u: FIN(D)))) &
	(u<|r: POW(S))
	=>
	(u<|r: FIN(S))


  RULE InFINXY.81
	band((binhyp(r: B +-> C)), 
	(binhyp(u/\dom(r): FIN(D)))) &
	(u<|r: POW(S))
	=>
	(u<|r: FIN(S))


  RULE InFINXY.82
	band((binhyp(r: B +-> C)), 
	(binhyp(u: FIN(D)))) &
	(u<|r: POW(S))
	=>
	(u<|r: FIN(S))


  RULE InFINXY.83
	band((binhyp(r: B +-> C)), 
	(binhyp(B: FIN(D)))) &
	(u<<|r: POW(S))
	=>
	(u<<|r: FIN(S))


  RULE InFINXY.84
	band((binhyp(r: B +-> C)), 
	(binhyp(dom(r): FIN(B)))) &
	(u<<|r: POW(S))
	=>
	(u<<|r: FIN(S))


  RULE InFINXY.85
	band((binhyp(r~: C +-> B)), 
	(binhyp(C: FIN(D)))) &
	(u<<|r: POW(S))
	=>
	(u<<|r: FIN(S))


  RULE InFINXY.86
	band((binhyp(r~: C +-> B)), 
	(binhyp(ran(r): FIN(D)))) &
	(u<<|r: POW(S))
	=>
	(u<<|r: FIN(S))


  RULE InFINXY.87
	band((binhyp(r: B +-> C)), 
	(binhyp(dom(r)-u: FIN(D)))) &
	(u<<|r: POW(S))
	=>
	(u<<|r: FIN(S))


  RULE InFINXY.88
	band((binhyp(r: B +-> C)), 
	(binhyp(B: FIN(D)))) &
	(r|>u: POW(S))
	=>
	(r|>u: FIN(S))


  RULE InFINXY.89
	band((binhyp(r: B +-> C)), 
	(binhyp(dom(r): FIN(B)))) &
	(r|>u: POW(S))
	=>
	(r|>u: FIN(S))


  RULE InFINXY.90
	band((binhyp(r~: C +-> B)), 
	(binhyp(C: FIN(D)))) &
	(r|>u: POW(S))
	=>
	(r|>u: FIN(S))


  RULE InFINXY.91
	band((binhyp(r~: C +-> B)), 
	(binhyp(ran(r): FIN(D)))) &
	(r|>u: POW(S))
	=>
	(r|>u: FIN(S))


  RULE InFINXY.92
	band((binhyp(r~: C +-> B)), 
	(binhyp(ran(r)/\u: FIN(D)))) &
	(r|>u: POW(S))
	=>
	(r|>u: FIN(S))


  RULE InFINXY.93
	band((binhyp(r~: C +-> B)), 
	(binhyp(u/\ran(r): FIN(D)))) &
	(r|>u: POW(S))
	=>
	(r|>u: FIN(S))


  RULE InFINXY.94
	band((binhyp(r~: C +-> B)), 
	(binhyp(u: FIN(D)))) &
	(r|>u: POW(S))
	=>
	(r|>u: FIN(S))


  RULE InFINXY.95
	band((binhyp(r: B +-> C)), 
	(binhyp(B: FIN(D)))) &
	(r|>>u: POW(S))
	=>
	(r|>>u: FIN(S))


  RULE InFINXY.96
	band((binhyp(r: B +-> C)), 
	(binhyp(dom(r): FIN(B)))) &
	(r|>>u: POW(S))
	=>
	(r|>>u: FIN(S))


  RULE InFINXY.97
	band((binhyp(r~: C +-> B)), 
	(binhyp(C: FIN(D)))) &
	(r|>>u: POW(S))
	=>
	(r|>>u: FIN(S))


  RULE InFINXY.98
	band((binhyp(r~: C +-> B)), 
	(binhyp(ran(r): FIN(D)))) &
	(r|>>u: POW(S))
	=>
	(r|>>u: FIN(S))


  RULE InFINXY.99
	band((binhyp(r~: C +-> B)), 
	(binhyp(ran(r)-u: FIN(D)))) &
	(r|>>u: POW(S))
	=>
	(r|>>u: FIN(S))


  RULE InFINXY.100
	band((binhyp(r: B +-> C)), 
	(binhyp(B: FIN(D)))) &
	(r<+{x|->y}: POW(S))
	=>
	(r<+{x|->y}: FIN(S))


  RULE InFINXY.101
	band((binhyp(r: B +-> C)), 
	(binhyp(dom(r): FIN(D)))) &
	(r<+{x|->y}: POW(S))
	=>
	(r<+{x|->y}: FIN(S))


  RULE InFINXY.102
	band((binhyp(r~: C +-> B)), 
	(binhyp(C: FIN(D)))) &
	(r<+{x|->y}: POW(S))
	=>
	(r<+{x|->y}: FIN(S))


  RULE InFINXY.103
	band((binhyp(r~: C +-> B)), 
	(binhyp(ran(r): FIN(D)))) &
	(r<+{x|->y}: POW(S))
	=>
	(r<+{x|->y}: FIN(S))


  RULE InFINXY.104
	band((binhyp(r: B +-> C)), 
	(binhyp(B: FIN(D)))) &
	(r~: POW(S))
	=>
	(r~: FIN(S))


  RULE InFINXY.105
	band((binhyp(r: B +-> C)), 
	(binhyp(dom(r): FIN(D)))) &
	(r~: POW(S))
	=>
	(r~: FIN(S))


  RULE InFINXY.106
	band((binhyp(r~: C +-> B)), 
	(binhyp(C: FIN(D)))) &
	(r~: POW(S))
	=>
	(r~: FIN(S))


  RULE InFINXY.107
	band((binhyp(r~: C +-> B)), 
	(binhyp(ran(r): FIN(D)))) &
	(r~: POW(S))
	=>
	(r~: FIN(S))


  RULE InFINXY.108
	(n..p: POW(S))
	=>
	(n..p: FIN(S))


  RULE InFINXY.109
	band((binhyp(r: B +-> C)), 
	(binhyp(B: FIN(D)))) &
	(r[u]: POW(S))
	=>
	(r[u]: FIN(S))


  RULE InFINXY.110
	band((binhyp(r: B +-> C)), 
	(binhyp(dom(r): FIN(D)))) &
	(r[u]: POW(S))
	=>
	(r[u]: FIN(S))


  RULE InFINXY.111
	band((binhyp(r: B <-> C)), 
	(binhyp(C: FIN(D)))) &
	(r[u]: POW(S))
	=>
	(r[u]: FIN(S))


  RULE InFINXY.112
	band((binhyp(r: B <-> C)), 
	(binhyp(ran(r): FIN(D)))) &
	(r[u]: POW(S))
	=>
	(r[u]: FIN(S))


  RULE InFINXY.113
	band((binhyp(r: B +-> C)), 
	(binhyp(u: FIN(D)))) &
	(r[u]: POW(S))
	=>
	(r[u]: FIN(S))


  RULE InFINXY.114
	band((binhyp(r: B +-> C)), 
	(binhyp(dom(r)/\u: FIN(D)))) &
	(r[u]: POW(S))
	=>
	(r[u]: FIN(S))


  RULE InFINXY.115
	band((binhyp(r: B +-> C)), 
	(binhyp(u/\dom(r): FIN(D)))) &
	(r[u]: POW(S))
	=>
	(r[u]: FIN(S))


  RULE InFINXY.116
	(binhyp(B: FIN(C))) &
	(a: POW(B))
	=>
	(a: FIN(B))


  RULE InFINXY.117
	(binhyp(a: FIN(A))) &
	(a: POW(B))
	=>
	(a: FIN(B))


  RULE InFINXY.118
	(a: INTEGER)
	=>
	({a}: FIN(INTEGER))


  RULE InFINXY.119
	{}: FIN(S)


  RULE InFINXY.120
	band((binhyp(a: FIN(b))), 
	(binhyp(b: FIN(c))))
	=>
	(a: FIN(c))


  RULE InFINXY.121
	band((binhyp(b: FIN(c))), 
	(binhyp(a: FIN(b))))
	=>
	(a: FIN(c))


  RULE InFINXY.122
	band((binhyp(a: FIN(b))), 
	(binhyp(b: POW(c))))
	=>
	(a: FIN(c))


  RULE InFINXY.123
	band((binhyp(b: POW(c))), 
	(binhyp(a: FIN(b))))
	=>
	(a: FIN(c))


  RULE InFINXY.124
	band((binhyp(a: POW(b))), 
	(binhyp(b: FIN(c))))
	=>
	(a: FIN(c))


  RULE InFINXY.125
	band((binhyp(b: FIN(c))), 
	(binhyp(a: POW(b))))
	=>
	(a: FIN(c))


  RULE InFINXY.126
	(binhyp(s: POW(a..b)))
	=>
	(s: FIN(INTEGER))


  RULE InFINXY.127
	p..q: FIN(INTEGER)


  RULE InFINXY.128
	BOOL: FIN(BOOL)


  RULE InFINXY.129
	NAT: FIN(INTEGER)


  RULE InFINXY.130
	INT: FIN(INTEGER)



THEORY InFunctionTryXY IS



  RULE InFunctionTryXY.1
	band((binhyp(f: s +-> (t --> u))), 
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(t: POW(a) & u: POW(b) | Curr))))
	=>
	(f(x): a +-> b)



THEORY InFunctionXY IS



  RULE InFunctionXY.1
	(binhyp(f: s +-> t)) &
	(dom(f): POW(u)) &
	(ran(f): POW(v))
	=>
	(f: u +-> v)


  RULE InFunctionXY.2
	(btest(2<1))
	=>
	(__blankrule)


  RULE InFunctionXY.3
	(f~: s +-> NATURAL) &
	(e: s) &
	(not(e: ran(f)))
	=>
	((f<-e)~: s +-> NATURAL)


  RULE InFunctionXY.4
	(f~: s +-> NATURAL) &
	(e: s) &
	(not(e: ran(f)))
	=>
	((e->f)~: s +-> NATURAL)


  RULE InFunctionXY.5
	(binhyp(not(a = {}))) &
	(binhyp(b: FIN(b))) &
	(a: POW(c)) &
	(b: POW(d)) &
	(card(b)<=1)
	=>
	(a*b: c +-> d)


  RULE InFunctionXY.6
	(binhyp(f: s +-> t)) &
	(ran(f)<|g: t +-> u)
	=>
	((f;g): s +-> u)


  RULE InFunctionXY.7
	(binhyp(f: s +-> t)) &
	(binhyp(g: u +-> v)) &
	(dom(f;g): POW(w)) &
	(ran(f;g): POW(x))
	=>
	((f;g): w +-> x)


  RULE InFunctionXY.8
	(binhyp(f: u +-> v)) &
	(dom(f)/\a: POW(s)) &
	(f[a]: POW(t))
	=>
	(a<|f: s +-> t)


  RULE InFunctionXY.9
	(binhyp(f: u +-> v)) &
	(dom(f|>a): POW(s)) &
	(ran(f)/\a: POW(t))
	=>
	(f|>a: s +-> t)


  RULE InFunctionXY.10
	(binhyp(f: u +-> v)) &
	(dom(f)-a: POW(s)) &
	(ran(a<<|f): POW(t))
	=>
	(a<<|f: s +-> t)


  RULE InFunctionXY.11
	(binhyp(f: u +-> v)) &
	(dom(f|>>a): POW(s)) &
	(ran(f)-a: POW(t))
	=>
	(f|>>a: s +-> t)


  RULE InFunctionXY.12
	(a: s +-> t) &
	(b: s +-> t) &
	(dom(a)<|b = dom(b)<|a)
	=>
	(a\/b: s +-> t)


  RULE InFunctionXY.13
	(binhyp(f: u +-> v)) &
	(dom(f-g): POW(s)) &
	(ran(f-g): POW(t))
	=>
	(f-g: s +-> t)


  RULE InFunctionXY.14
	(dom(g)<<|f: s +-> t) &
	(g: s +-> t)
	=>
	(f<+g: s +-> t)


  RULE InFunctionXY.15
	(dom(f)<|g: s +-> V) &
	(dom(g)<|f: s +-> U)
	=>
	(f> U*V)


  RULE InFunctionXY.16
	(binhyp(not(f = {}))) &
	(binhyp(not(g = {}))) &
	(f: s +-> U) &
	(g: t +-> V)
	=>
	((f || g): s*t +-> U*V)


  RULE InFunctionXY.17
	(a: s) &
	(b: t)
	=>
	({a|->b}: s +-> t)


  RULE InFunctionXY.18
	(bfresh(xx,(fnc(r): s +-> t),x)) &
	(dom(r): POW(s)) &
	(!x.(x: dom(r) => r[{x}]: t))
	=>
	(fnc(r): s +-> t)


  RULE InFunctionXY.19
	(x\(s +-> t)) &
	(!x.(p => x: s & e: t))
	=>
	(%x.(p | e): s +-> t)


  RULE InFunctionXY.20
	(binhyp(f: s +-> t)) &
	(a/\dom(f) = {})
	=>
	(f: s-a +-> t)


  RULE InFunctionXY.21
	(binhyp(f: s +-> t)) &
	(a/\ran(f) = {})
	=>
	(f: s +-> t-a)


  RULE InFunctionXY.22
	(binhyp(f: s +-> t)) &
	(g: s +-> t)
	=>
	(f<+g: s +-> t)


  RULE InFunctionXY.23
	(binhyp(f~: s +-> NATURAL))
	=>
	(tail(f)~: s +-> NATURAL)


  RULE InFunctionXY.24
	(binhyp(f~: s +-> NATURAL))
	=>
	(front(f)~: s +-> NATURAL)


  RULE InFunctionXY.25
	(binhyp(f~: s +-> NATURAL))
	=>
	((f/|\n)~: s +-> NATURAL)


  RULE InFunctionXY.26
	(binhyp(f~: s +-> NATURAL))
	=>
	((f\|/n)~: s +-> NATURAL)


  RULE InFunctionXY.27
	(binhyp(f: s +-> t)) &
	(binhyp(g: u +-> v))
	=>
	((f;g): s +-> v)


  RULE InFunctionXY.28
	(binhyp(g: s +-> t)) &
	(binhyp(f: u <-> v))
	=>
	(f/\g: s +-> t)


  RULE InFunctionXY.29
	(binhyp(f: s +-> t)) &
	(binhyp(g: u <-> v))
	=>
	(f/\g: s +-> t)


  RULE InFunctionXY.30
	(binhyp(f: s +-> t))
	=>
	(f|>a: s +-> t)


  RULE InFunctionXY.31
	(binhyp(f: s +-> t))
	=>
	(f|>>a: s +-> t)


  RULE InFunctionXY.32
	(binhyp(f: s +-> t))
	=>
	(a<|f: s +-> t)


  RULE InFunctionXY.33
	(binhyp(f: s +-> t))
	=>
	(a<<|f: s +-> t)


  RULE InFunctionXY.34
	(binhyp(f: s +-> t)) &
	(binhyp(a: u <-> v))
	=>
	(f-a: s +-> t)


  RULE InFunctionXY.35
	(binhyp(f: s +-> t)) &
	(binhyp(not(a: s)))
	=>
	(f\/{a|->b}: s\/{a} +-> t\/{b})


  RULE InFunctionXY.36
	{}: s +-> t



THEORY InINTEGERTryXY IS



  RULE InINTEGERTryXY.1
	(binhyp(n: T)) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(T: POW(INTEGER) | Curr)))
	=>
	(n: INTEGER)



THEORY InINTEGERXY IS



  RULE InINTEGERXY.1
	(btest(2<1))
	=>
	(__blankrule)


  RULE InINTEGERXY.2
	(n: INTEGER) &
	(m: INTEGER)
	=>
	(n*m: INTEGER)


  RULE InINTEGERXY.3
	(n: INTEGER) &
	(m: INTEGER)
	=>
	(n-m: INTEGER)


  RULE InINTEGERXY.4
	(n: INTEGER) &
	(m: INTEGER)
	=>
	(n+m: INTEGER)


  RULE InINTEGERXY.5
	(binhyp(n: a..b))
	=>
	(n: INTEGER)


  RULE InINTEGERXY.6
	(bnum(n))
	=>
	(n: INTEGER)


  RULE InINTEGERXY.7
	(bnum(n))
	=>
	(-n: INTEGER)


  RULE InINTEGERXY.8
	(binhyp(n: INTEGER))
	=>
	(n-p: INTEGER)


  RULE InINTEGERXY.9
	(binhyp(p: INTEGER))
	=>
	(n-p: INTEGER)


  RULE InINTEGERXY.10
	n**p: INTEGER


  RULE InINTEGERXY.11
	(btest(2<1))
	=>
	(__blankrule)


  RULE InINTEGERXY.12
	(binhyp(n: INTEGER))
	=>
	(n*p: INTEGER)


  RULE InINTEGERXY.13
	(binhyp(p: INTEGER))
	=>
	(n*p: INTEGER)


  RULE InINTEGERXY.14
	n/p: INTEGER


  RULE InINTEGERXY.15
	PI(x).(P | E): INTEGER


  RULE InINTEGERXY.16
	(binhyp(S: FIN(T)))
	=>
	(PI(x).(x: S | E): INTEGER)


  RULE InINTEGERXY.17
	band((bsearch((x: p..q),(P & btrue),r)), 
	(x\(p,q)))
	=>
	(SIGMA(x).(P | E): INTEGER)


  RULE InINTEGERXY.18
	(bpattern(P,(u & v))) &
	band((bsearch(x<=q,(P & btrue),r)), 
	band((bsearch(p<=x,(P & btrue),s)), 
	(x\(p,q))))
	=>
	(SIGMA(x).(P | E): INTEGER)


  RULE InINTEGERXY.19
	max(S): INTEGER


  RULE InINTEGERXY.20
	min(S): INTEGER


  RULE InINTEGERXY.21
	card(S): INTEGER


  RULE InINTEGERXY.22
	size(s): INTEGER


  RULE InINTEGERXY.23
	card(n..p): INTEGER


  RULE InINTEGERXY.24
	band((binhyp(n: T)), 
	(binhyp(T: POW(NATURAL))))
	=>
	(n: INTEGER)


  RULE InINTEGERXY.25
	band((binhyp(s: seq(T))), 
	(binhyp(T: POW(NATURAL))))
	=>
	(s(a): INTEGER)


  RULE InINTEGERXY.26
	band((binhyp(s: S +-> T)), 
	(binhyp(T: POW(NATURAL))))
	=>
	(s(a): INTEGER)


  RULE InINTEGERXY.27
	succ(n): INTEGER


  RULE InINTEGERXY.28
	pred(n): INTEGER


  RULE InINTEGERXY.29
	n+p: INTEGER


  RULE InINTEGERXY.30
	PI(x).(x: p..q | E): INTEGER



THEORY InREALTryXY IS



  RULE InREALTryXY.1
	(binhyp(n: T)) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(T: POW(REAL) | Curr)))
	=>
	(n: REAL)



THEORY InREALXY IS



  RULE InREALXY.1
	(breal(n))
	=>
	(n: REAL)


  RULE InREALXY.2
	band((binhyp(s: seq(T))), 
	(binhyp(T: POW(REAL))))
	=>
	(s(a): REAL)


  RULE InREALXY.3
	band((binhyp(s: S +-> T)), 
	(binhyp(T: POW(REAL))))
	=>
	(s(a): REAL)


  RULE InREALXY.4
	n rplus p: REAL


  RULE InREALXY.5
	n rminus p: REAL


  RULE InREALXY.6
	n rmul p: REAL


  RULE InREALXY.7
	n rdiv p: REAL


  RULE InREALXY.8
	n rpow p: REAL


  RULE InREALXY.9
	n rdiv p: REAL


  RULE InREALXY.10
	rPI(x).(P | E): REAL


  RULE InREALXY.11
	rSIGMA(x).(P | E): REAL


  RULE InREALXY.12
	rmax(S): REAL


  RULE InREALXY.13
	rmin(S): REAL



THEORY InPOWTryXY IS



  RULE InPOWTryXY.1
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(s: POW(a) | Curr))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(t: POW(b) | Curr)))
	=>
	(s +-> t: POW(a +-> b))


  RULE InPOWTryXY.2
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(a: POW(b) | Curr)))
	=>
	(a: POW(b\/c))


  RULE InPOWTryXY.3
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(a: POW(c) | Curr)))
	=>
	(a: POW(b\/c))


  RULE InPOWTryXY.4
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(a: POW(b) | Curr)))
	=>
	(dom(a): POW(dom(b)))


  RULE InPOWTryXY.5
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(a: POW(b) | Curr)))
	=>
	(ran(a): POW(ran(b)))



THEORY InPOWXY IS



  RULE InPOWXY.1
	(a = {})
	=>
	(a: POW({}))


  RULE InPOWXY.2
	(not(a = {}) => a = {b})
	=>
	(a: POW({b}))


  RULE InPOWXY.3
	(binhyp(not(c: a))) &
	(a: POW(b))
	=>
	(a: POW(b\/{c}))


  RULE InPOWXY.4
	(bfresh(x,(a: POW(SET(x).p)),y)) &
	(!y.(y: a => [x:=y]p))
	=>
	(a: POW(SET(x).p))


  RULE InPOWXY.5
	(a: POW(c)) &
	(a: POW(b))
	=>
	(a: POW(b/\c))


  RULE InPOWXY.6
	(a: POW(b)) &
	(a/\c = {})
	=>
	(a: POW(b-c))


  RULE InPOWXY.7
	(dom(r): POW(A)) &
	(ran(r): POW(B))
	=>
	(r: POW(A*B))


  RULE InPOWXY.8
	(a: POW(r)) &
	(dom(a): POW(u))
	=>
	(a: POW(u<|r))


  RULE InPOWXY.9
	(a: POW(r)) &
	(dom(a)/\u = {})
	=>
	(a: POW(u<<|r))


  RULE InPOWXY.10
	(a: POW(r)) &
	(ran(a): POW(u))
	=>
	(a: POW(r|>u))


  RULE InPOWXY.11
	(a: POW(r)) &
	(ran(a)/\u = {})
	=>
	(a: POW(r|>>u))


  RULE InPOWXY.12
	(not(a = {}) => a: FIN(INTEGER) & p<=min(a) & max(a)<=q)
	=>
	(a: POW(p..q))


  RULE InPOWXY.13
	(a: b)
	=>
	({a}: POW(b))


  RULE InPOWXY.14
	(x\a) &
	(!x.(p => x: a))
	=>
	(SET(x).p: POW(a))


  RULE InPOWXY.15
	(a: POW(c)) &
	(b: POW(c))
	=>
	(a\/b: POW(c))


  RULE InPOWXY.16
	(b: a => b: c)
	=>
	(a/\{b}: POW(c))


  RULE InPOWXY.17
	(not(b: a))
	=>
	(a/\{b}: POW({}))


  RULE InPOWXY.18
	(a: b => a: c)
	=>
	({a}/\b: POW(c))


  RULE InPOWXY.19
	(not(a: b))
	=>
	({a}/\b: POW({}))


  RULE InPOWXY.20
	(a/\b: POW(d)) &
	(a/\c: POW(d))
	=>
	(a/\(b\/c): POW(d))


  RULE InPOWXY.21
	(b/\c: POW(d)) &
	(a/\c: POW(d))
	=>
	(a\/b/\c: POW(d))


  RULE InPOWXY.22
	(not(c: a)) &
	(a/\b: POW({}))
	=>
	(a/\(b\/{c}): POW({}))


  RULE InPOWXY.23
	(x\a) &
	(!x.(P => not(x: a)))
	=>
	(a/\SET(x).P: POW({}))


  RULE InPOWXY.24
	(a: POW(c\/b))
	=>
	(a-b: POW(c))


  RULE InPOWXY.25
	(binhyp(b/\a = {})) &
	(a: POW(c))
	=>
	(a-b: POW(c))


  RULE InPOWXY.26
	(binhyp(a/\b = {})) &
	(a: POW(c))
	=>
	(a-b: POW(c))


  RULE InPOWXY.27
	(ran(r)/\dom(s): POW({}))
	=>
	((r;s): POW({}))


  RULE InPOWXY.28
	(b: r[{a}] => a: c)
	=>
	(dom(r/\{a|->b}): POW(c))


  RULE InPOWXY.29
	(b: r[{a}] => b: c)
	=>
	(ran(r/\{a|->b}): POW(c))


  RULE InPOWXY.30
	(dom(r)/\u: POW({}))
	=>
	(u<|r: POW({}))


  RULE InPOWXY.31
	(dom(r): POW(u))
	=>
	(u<<|r: POW({}))


  RULE InPOWXY.32
	(ran(r)/\u: POW({}))
	=>
	(r|>u: POW({}))


  RULE InPOWXY.33
	(ran(r): POW(u))
	=>
	(r|>>u: POW({}))


  RULE InPOWXY.34
	(bfresh(xx,(p..q: POW(a)),x)) &
	(!x.(x: INTEGER & p<=x & x<=q => x: a))
	=>
	(p..q: POW(a))


  RULE InPOWXY.35
	(p<=q => a<=p & q<=b)
	=>
	(p..q: POW(a..b))


  RULE InPOWXY.36
	(p<=q => p: INTEGER & 0<=p)
	=>
	(p..q: POW(NATURAL))


  RULE InPOWXY.37
	(a: POW(b))
	=>
	(POW(a): POW(POW(b)))


  RULE InPOWXY.38
	(A<|f: POW(g)) &
	({a}<|f: POW(g))
	=>
	(A\/{a}<|f: POW(g))


  RULE InPOWXY.39
	(f|>A: POW(g)) &
	(f|>{a}: POW(g))
	=>
	(f|>(A\/{a}): POW(g))


  RULE InPOWXY.40
	(dom(g)<|f: POW(g)) &
	(a: dom(g) => b: g[{a}])
	=>
	(dom(g)<|(f\/{a|->b}): POW(g))


  RULE InPOWXY.41
	(f|>ran(g): POW(g)) &
	(b: ran(g) => a: g~[{b}])
	=>
	(f\/{a|->b}|>ran(g): POW(g))


  RULE InPOWXY.42
	(dom(g)<|f: POW(g\/{a|->b}))
	=>
	(dom(g)<|(f\/{a|->b}): POW(g\/{a|->b}))


  RULE InPOWXY.43
	(f|>ran(g): POW(g\/{a|->b}))
	=>
	(f\/{a|->b}|>ran(g): POW(g\/{a|->b}))


  RULE InPOWXY.44
	(bguard(StructDecompX: StructDecompG(Inc,E,F),R)) &
	(R)
	=>
	(struct(E): POW(struct(F)))



THEORY InPOWLeavesXY IS



  RULE InPOWLeavesXY.1
	band((binhyp(a: POW(r))), 
	(binhyp(dom(s)/\dom(a) = {})))
	=>
	(a: POW(r<+s))


  RULE InPOWLeavesXY.2
	band((binhyp(a: POW(r))), 
	(binhyp(dom(a)/\dom(s) = {})))
	=>
	(a: POW(r<+s))


  RULE InPOWLeavesXY.3
	(binhyp(a: POW(s)))
	=>
	(a: POW(r<+s))


  RULE InPOWLeavesXY.4
	(binhyp(a: POW(b..c)))
	=>
	(a: POW(b..c+1))


  RULE InPOWLeavesXY.5
	{}: POW(a)


  RULE InPOWLeavesXY.6
	a/\b: POW(a)


  RULE InPOWLeavesXY.7
	a/\b: POW(b)


  RULE InPOWLeavesXY.8
	band((binhyp(a: POW(c))), 
	(binhyp(b: POW(d))))
	=>
	(a/\b: POW(c/\d))


  RULE InPOWLeavesXY.9
	band((binhyp(a: POW(d))), 
	(binhyp(b: POW(c))))
	=>
	(a/\b: POW(c/\d))


  RULE InPOWLeavesXY.10
	(binhyp(b: POW(d)))
	=>
	(a/\b: POW(a/\d))


  RULE InPOWLeavesXY.11
	(binhyp(b: POW(d)))
	=>
	(a/\b: POW(d/\a))


  RULE InPOWLeavesXY.12
	(binhyp(a: POW(d)))
	=>
	(a/\b: POW(b/\d))


  RULE InPOWLeavesXY.13
	(binhyp(a: POW(d)))
	=>
	(a/\b: POW(d/\b))


  RULE InPOWLeavesXY.14
	(binhyp(a\/d = c))
	=>
	(a/\b: POW(c))


  RULE InPOWLeavesXY.15
	(binhyp(b: POW(c-d)))
	=>
	(a/\b: POW(c))


  RULE InPOWLeavesXY.16
	(binhyp(b\/d = c))
	=>
	(a/\b: POW(c))


  RULE InPOWLeavesXY.17
	(binhyp(a: POW(c)))
	=>
	(a/\b: POW(c))


  RULE InPOWLeavesXY.18
	(binhyp(b: POW(c)))
	=>
	(a/\b: POW(c))


  RULE InPOWLeavesXY.19
	(binhyp(b/\a: POW(c)))
	=>
	(a/\b: POW(c))


  RULE InPOWLeavesXY.20
	r[u]-s[u]: POW((r-s)[u])


  RULE InPOWLeavesXY.21
	r[u]-r[v]: POW(r[u-v])


  RULE InPOWLeavesXY.22
	(r;s)-(r;t): POW(r;s-t)


  RULE InPOWLeavesXY.23
	(r;t)-(s;t): POW(r-s;t)


  RULE InPOWLeavesXY.24
	dom(r)-dom(s): POW(dom(r-s))


  RULE InPOWLeavesXY.25
	ran(r)-ran(s): POW(ran(r-s))


  RULE InPOWLeavesXY.26
	(r;s/\t): POW((r;s)/\(r;t))


  RULE InPOWLeavesXY.27
	(r/\s;t): POW((r;t)/\(s;t))


  RULE InPOWLeavesXY.28
	(binhyp(dom(r): POW(a)))
	=>
	(dom(r-s): POW(a))


  RULE InPOWLeavesXY.29
	(binhyp(a: POW(b)))
	=>
	(dom(a): POW(dom(b)))


  RULE InPOWLeavesXY.30
	(binhyp(dom(r): POW(b)))
	=>
	(dom(r|>a): POW(b))


  RULE InPOWLeavesXY.31
	(binhyp(dom(r): POW(b)))
	=>
	(dom(r|>>a): POW(b))


  RULE InPOWLeavesXY.32
	(binhyp(a: POW(b)))
	=>
	(ran(a): POW(ran(b)))


  RULE InPOWLeavesXY.33
	(binhyp(r: u +-> v))
	=>
	(ran(r): POW(v))


  RULE InPOWLeavesXY.34
	(binhyp(ran(r): POW(b)))
	=>
	(r[a]: POW(b))


  RULE InPOWLeavesXY.35
	(binhyp(ran(r): POW(b)))
	=>
	(ran(a<<|r): POW(b))


  RULE InPOWLeavesXY.36
	(binhyp(ran(r): POW(b)))
	=>
	(ran(r-s): POW(b))


  RULE InPOWLeavesXY.37
	band((binhyp(v<|r: POW(s))), 
	(binhyp(u: POW(v))))
	=>
	(u<|r: POW(s))


  RULE InPOWLeavesXY.38
	u<|r: POW(r)


  RULE InPOWLeavesXY.39
	band((binhyp(v<<|r: POW(s))), 
	(binhyp(v: POW(u))))
	=>
	(u<<|r: POW(s))


  RULE InPOWLeavesXY.40
	u<<|r: POW(r)


  RULE InPOWLeavesXY.41
	band((binhyp(r|>v: POW(s))), 
	(binhyp(u: POW(v))))
	=>
	(r|>u: POW(s))


  RULE InPOWLeavesXY.42
	r|>u: POW(r)


  RULE InPOWLeavesXY.43
	band((binhyp(r|>>v: POW(s))), 
	(binhyp(v: POW(u))))
	=>
	(r|>>u: POW(s))


  RULE InPOWLeavesXY.44
	r|>>u: POW(r)


  RULE InPOWLeavesXY.45
	(binhyp(r[u] = v))
	=>
	(r[u-A]: POW(v))


  RULE InPOWLeavesXY.46
	(binhyp(ran(r): POW(b)))
	=>
	(r[u]: POW(b))


  RULE InPOWLeavesXY.47
	(binhyp(r: a <-> b))
	=>
	(r[u]: POW(b))


  RULE InPOWLeavesXY.48
	(binhyp(u: POW(v)))
	=>
	(r[u]: POW(r[v]))


  RULE InPOWLeavesXY.49
	(binhyp(r: POW(s)))
	=>
	(r[u]: POW(s[u]))


  RULE InPOWLeavesXY.50
	(binhyp(r[u]: POW(a)))
	=>
	(r[u-v]: POW(a))


  RULE InPOWLeavesXY.51
	(binhyp(A: POW(C)))
	=>
	(A/\B: POW(C\/D))


  RULE InPOWLeavesXY.52
	(binhyp(A: POW(D)))
	=>
	(A/\B: POW(C\/D))


  RULE InPOWLeavesXY.53
	(binhyp(B: POW(C)))
	=>
	(A/\B: POW(C\/D))


  RULE InPOWLeavesXY.54
	(binhyp(B: POW(D)))
	=>
	(A/\B: POW(C\/D))


  RULE InPOWLeavesXY.55
	(bsearch(a,c\/b,r))
	=>
	(a: POW(c\/b))


  RULE InPOWLeavesXY.56
	(binhyp(a\/d = c))
	=>
	(a: POW(b\/c))


  RULE InPOWLeavesXY.57
	(binhyp(a: POW(c)))
	=>
	(a: POW(b\/c))


  RULE InPOWLeavesXY.58
	(binhyp(a\/d = b))
	=>
	(a: POW(b\/c))


  RULE InPOWLeavesXY.59
	(binhyp(a: POW(b)))
	=>
	(a: POW(b\/c))


  RULE InPOWLeavesXY.60
	(binhyp(a: POW(c\/b)))
	=>
	(a: POW(b\/c))


  RULE InPOWLeavesXY.61
	(binhyp(a = SET(x).(x: s & p & q)))
	=>
	(a: POW(SET(x).(x: s & p)))


  RULE InPOWLeavesXY.62
	(binhyp(a = SET(x).(x: s & p & q)))
	=>
	(a: POW(SET(x).(x: s & q)))


  RULE InPOWLeavesXY.63
	(binhyp(a: POW(SET(x).(x: s & p & q))))
	=>
	(a: POW(SET(x).(x: s & p)))


  RULE InPOWLeavesXY.64
	(binhyp(a: POW(SET(x).(x: s & p & q))))
	=>
	(a: POW(SET(x).(x: s & q)))


  RULE InPOWLeavesXY.65
	a: POW(a)


  RULE InPOWLeavesXY.66
	(binhyp(a: FIN(b)))
	=>
	(a: POW(b))


  RULE InPOWLeavesXY.67
	band((binhyp(b = c)), 
	(binhyp(a: POW(b))))
	=>
	(a: POW(c))


  RULE InPOWLeavesXY.68
	band((binhyp(a: POW(b))), 
	(binhyp(b: POW(c))))
	=>
	(a: POW(c))


  RULE InPOWLeavesXY.69
	band((binhyp(b: POW(c))), 
	(binhyp(a: POW(b))))
	=>
	(a: POW(c))


  RULE InPOWLeavesXY.70
	band((binhyp(a = b)), 
	(binhyp(b = c)))
	=>
	(a: POW(c))


  RULE InPOWLeavesXY.71
	band((binhyp(b = c)), 
	(binhyp(a = b)))
	=>
	(a: POW(c))


  RULE InPOWLeavesXY.72
	(binhyp(u<|r = a))
	=>
	(a: POW(r))


  RULE InPOWLeavesXY.73
	(binhyp(x: POW(s)))
	=>
	(x: POW(s<-r))


  RULE InPOWLeavesXY.74
	(binhyp(s: POW(a..b))) &
	(bguard(Fast_Prove_Positif: a))
	=>
	(s: POW(NATURAL))


  RULE InPOWLeavesXY.75
	s: POW(INTEGER)


  RULE InPOWLeavesXY.76
	s: POW(INTEGER*INTEGER)


  RULE InPOWLeavesXY.77
	(binhyp(f: s +-> t))
	=>
	(dom(f): POW(s))


  RULE InPOWLeavesXY.78
	(binhyp(f: s +-> t))
	=>
	(ran(f): POW(t))


  RULE InPOWLeavesXY.79
	(binhyp(a = b))
	=>
	(a: POW(b))


  RULE InPOWLeavesXY.80
	(binhyp(b = a))
	=>
	(a: POW(b))


  RULE InPOWLeavesXY.81
	(binhyp(a: POW(b/\a)))
	=>
	(a: POW(b))


  RULE InPOWLeavesXY.82
	(binhyp(a: POW(a/\b)))
	=>
	(a: POW(b))


  RULE InPOWLeavesXY.83
	(binhyp(not(c: a))) &
	(binhyp(a: POW(b)))
	=>
	(a: POW(b\/{c}))


  RULE InPOWLeavesXY.84
	(binhyp(dom(r): POW(b)))
	=>
	(dom(a<|r): POW(b))


  RULE InPOWLeavesXY.85
	(binhyp(dom(r): POW(b)))
	=>
	(dom(a<<|r): POW(b))


  RULE InPOWLeavesXY.86
	(binhyp(ran(r): POW(b)))
	=>
	(ran(r|>a): POW(b))


  RULE InPOWLeavesXY.87
	(binhyp(ran(r): POW(b)))
	=>
	(ran(r|>>a): POW(b))


  RULE InPOWLeavesXY.88
	(binhyp(a: POW(c)))
	=>
	(a-b: POW(c))


  RULE InPOWLeavesXY.89
	(x\a)
	=>
	(SET(x).(x: a & p): POW(a))


  RULE InPOWLeavesXY.90
	dom(r/\s): POW(dom(r)/\dom(s))


  RULE InPOWLeavesXY.91
	ran(r/\s): POW(ran(r)/\ran(s))


  RULE InPOWLeavesXY.92
	r[u/\v]: POW(r[u]/\r[v])



THEORY InRelationXY IS



  RULE InRelationXY.1
	(dom(a): POW(s)) &
	(ran(a): POW(t))
	=>
	(a: s <-> t)


  RULE InRelationXY.2
	(not(a = {}) & not(b = {}) => a: POW(s) & b: POW(t))
	=>
	(a*b: s <-> t)


  RULE InRelationXY.3
	(a: t <-> s)
	=>
	(a~: s <-> t)


  RULE InRelationXY.4
	(a: s <-> t) &
	(b: s <-> t)
	=>
	(a\/b: s <-> t)


  RULE InRelationXY.5
	(bfresh(xx,yy,(a/\b: s <-> t),(x,y))) &
	(!(x,y).(x|->y: a/\b => x|->y: s*t))
	=>
	(a/\b: s <-> t)


  RULE InRelationXY.6
	(bfresh(xx,yy,(a-b: s <-> t),(x,y))) &
	(!(x,y).(x|->y: a-b => x|->y: s*t))
	=>
	(a-b: s <-> t)


  RULE InRelationXY.7
	(dom(b)<<|a: s <-> t) &
	(b: s <-> t)
	=>
	(a<+b: s <-> t)


  RULE InRelationXY.8
	(binhyp(r: s <-> t)) &
	(q: s <-> t)
	=>
	(r<+q: s <-> t)


  RULE InRelationXY.9
	(bfresh(xx,(fnc(r): s <-> t),x)) &
	(dom(r): POW(s)) &
	(!x.(x: dom(r) => r[{x}]: t))
	=>
	(fnc(r): s <-> t)


  RULE InRelationXY.10
	(x\(s,t)) &
	(!x.(p => x: s & e: t))
	=>
	(%x.(p | e): s <-> t)


  RULE InRelationXY.11
	(binhyp(r: s <-> t)) &
	(a/\dom(r) = {})
	=>
	(r: s-a <-> t)


  RULE InRelationXY.12
	(binhyp(r: s <-> t)) &
	(a/\ran(r) = {})
	=>
	(r: s <-> t-a)


  RULE InRelationXY.13
	(binhyp(r: s <-> t)) &
	(binhyp(q: s <-> t))
	=>
	(r/\q: s <-> t)


  RULE InRelationXY.14
	(binhyp(r: a <-> b))
	=>
	(r-s: a <-> b)


  RULE InRelationXY.15
	{}: a <-> b


  RULE InRelationXY.16
	(binhyp(r: s <-> v))
	=>
	(r: s\/u <-> t\/v)


  RULE InRelationXY.17
	(binhyp(r: u <-> t))
	=>
	(r: s\/u <-> t\/v)


  RULE InRelationXY.18
	(binhyp(r: u <-> v))
	=>
	(r: s\/u <-> t\/v)


  RULE InRelationXY.19
	(binhyp(r: s <-> t))
	=>
	(r: s\/u <-> t\/v)


  RULE InRelationXY.20
	(binhyp(r: s <-> t))
	=>
	(r: s\/u <-> t)


  RULE InRelationXY.21
	(binhyp(r: u <-> t))
	=>
	(r: s\/u <-> t)


  RULE InRelationXY.22
	(binhyp(r: s <-> t))
	=>
	(r: s <-> t\/v)


  RULE InRelationXY.23
	(binhyp(r: s <-> v))
	=>
	(r: s <-> t\/v)



THEORY InSequenceXY IS



  RULE InSequenceXY.1
	(!x.(x: 1..m => E: S)) &
	(x\S)
	=>
	(%x.(x: 1..m | E): seq(S))


  RULE InSequenceXY.2
	(btest(2<1))
	=>
	(__blankrule)


  RULE InSequenceXY.3
	(x = 1) &
	(a: S)
	=>
	({x|->a}: seq(S))


  RULE InSequenceXY.4
	(bnot(bpattern(a,(u,v)))) &
	(a: S)
	=>
	([a]: seq(S))


  RULE InSequenceXY.5
	([a]: seq(S)) &
	(b: S)
	=>
	([a,b]: seq(S))


  RULE InSequenceXY.6
	(btest(2<1))
	=>
	(__blankrule)


  RULE InSequenceXY.7
	(a[1..n]: POW(S))
	=>
	(a/|\n: seq(S))


  RULE InSequenceXY.8
	(btest(2<1))
	=>
	(__blankrule)


  RULE InSequenceXY.9
	(a[n+1..size(a)]: POW(S))
	=>
	(a\|/n: seq(S))


  RULE InSequenceXY.10
	(a: seq(S)) &
	(b: S)
	=>
	(a<-b: seq(S))


  RULE InSequenceXY.11
	(b: seq(S)) &
	(a: S)
	=>
	(a->b: seq(S))


  RULE InSequenceXY.12
	(a: seq(S))
	=>
	(rev(a): seq(S))


  RULE InSequenceXY.13
	(a: seq(S)) &
	(b: seq(S))
	=>
	(a^b: seq(S))


  RULE InSequenceXY.14
	(a[2..size(a)]: POW(S))
	=>
	(tail(a): seq(S))


  RULE InSequenceXY.15
	(a[1..size(a)-1]: POW(S))
	=>
	(front(a): seq(S))


  RULE InSequenceXY.16
	(btest(2<1))
	=>
	(__blankrule)


  RULE InSequenceXY.17
	(binhyp(s: seq(E))) &
	(s[1..n]: POW(S))
	=>
	(1..n<|s: seq(S))


  RULE InSequenceXY.18
	(binhyp(s: seq(A))) &
	(1<=a) &
	(a<=size(s)+1) &
	(b: A)
	=>
	(s<+{a|->b}: seq(A))


  RULE InSequenceXY.19
	{}: seq(S)


  RULE InSequenceXY.20
	(binhyp(s: seq(S))) &
	(b: S)
	=>
	(s<+{size(s)+1|->b}: seq(S))


  RULE InSequenceXY.21
	(binhyp(a: seq(S)))
	=>
	(a/|\n: seq(S))


  RULE InSequenceXY.22
	(binhyp(a: seq(S)))
	=>
	(a\|/n: seq(S))


  RULE InSequenceXY.23
	(binhyp(a: seq(S)))
	=>
	(tail(a): seq(S))


  RULE InSequenceXY.24
	(binhyp(a: seq(S)))
	=>
	(front(a): seq(S))


  RULE InSequenceXY.25
	(binhyp(t: seq(S)))
	=>
	((1..n<|succ;t): seq(S))


  RULE InSequenceXY.26
	(binhyp(s: seq(S)))
	=>
	(1..n<|s: seq(S))


  RULE InSequenceXY.27
	(binhyp(s: seq(S)))
	=>
	({size(s)}<<|s: seq(S))


  RULE InSequenceXY.28
	(binhyp(f: seq(s))) &
	(binhyp(g: dom(f) +-> s))
	=>
	(f<+g: seq(s))


  RULE InSequenceXY.29
	(binhyp(f: seq(s))) &
	(binhyp(g: 1..size(f) +-> s))
	=>
	(f<+g: seq(s))



THEORY InSetTryXY IS



  RULE InSetTryXY.1
	(binhyp(x: s)) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(s: POW(t) | Curr)))
	=>
	(x: t)



THEORY InSetXY IS



  RULE InSetXY.1
	(x|->y: f)
	=>
	(y: f[{x}])


  RULE InSetXY.2
	(bnot(bpattern(x,(y,z)))) &
	(x: a) &
	(not(ran({x}): POW(b)))
	=>
	(x: a|>>b)


  RULE InSetXY.3
	(bnot(bpattern(x,(y,z)))) &
	(x: b) &
	(not(dom({x}): POW(a)))
	=>
	(x: a<<|b)


  RULE InSetXY.4
	(bnot(bpattern(x,(y,z)))) &
	(x: a) &
	(ran({x}): POW(b))
	=>
	(x: a|>b)


  RULE InSetXY.5
	(bnot(bpattern(x,(y,z)))) &
	(x: b) &
	(dom({x}): POW(a))
	=>
	(x: a<|b)


  RULE InSetXY.6
	(y|->x: a)
	=>
	(x|->y: a~)


  RULE InSetXY.7
	(y,x: a)
	=>
	(x,y: a~)


  RULE InSetXY.8
	(x = y) &
	(x: a)
	=>
	(x|->y: id(a))


  RULE InSetXY.9
	(x = y) &
	(x: a)
	=>
	(x,y: id(a))


  RULE InSetXY.10
	(a: dom(p|>dom(q|>{b})))
	=>
	(a|->b: (p;q))


  RULE InSetXY.11
	(a: S) &
	(b: T)
	=>
	(a|->b: S*T)


  RULE InSetXY.12
	(a: S) &
	(b: T)
	=>
	(a,b: S*T)


  RULE InSetXY.13
	(n<=a) &
	(a<=p)
	=>
	(a: n..p)


  RULE InSetXY.14
	(n<=p)
	=>
	(p: n..p)


  RULE InSetXY.15
	(n<=p)
	=>
	(n: n..p)


  RULE InSetXY.16
	(a: S) &
	(not(a: T))
	=>
	(a: S-T)


  RULE InSetXY.17
	(not(a: T) => a: S)
	=>
	(a: S\/T)


  RULE InSetXY.18
	(bguard(Fast_Prove_Difference: not(a = c))) &
	(a: b)
	=>
	(a: b\/{c})


  RULE InSetXY.19
	(a: S) &
	(a: T)
	=>
	(a: S/\T)


  RULE InSetXY.20
	(bfresh(xx,(a: S),x)) &
	(#x.(x: S & a: x))
	=>
	(a: union(S))


  RULE InSetXY.21
	(bfresh(xx,(a: S),x)) &
	(!x.(x: S => a: x))
	=>
	(a: inter(S))


  RULE InSetXY.22
	(x\a) &
	(#x.(P & a: E))
	=>
	(a: UNION(x).(P | E))


  RULE InSetXY.23
	(x\a) &
	(!x.(P => a: E))
	=>
	(a: INTER(x).(P | E))


  RULE InSetXY.24
	(a = b)
	=>
	(a: {b})


  RULE InSetXY.25
	(bguard((SUB;RES): bresult([x:=a]P),R)) &
	(bnot(bpattern(R,[y:=z]S))) &
	(R)
	=>
	(a: SET(x).P)


  RULE InSetXY.26
	(bnot(bpattern(y,(u,v)))) &
	(x\b) &
	(bguard((SUB;RES): bresult([y:=b]P),R)) &
	(bnot(bpattern(R,[t:=z]S))) &
	(a: SET(x).R)
	=>
	(a|->b: SET(x,y).P)


  RULE InSetXY.27
	(s(1): A)
	=>
	(first(s): A)


  RULE InSetXY.28
	(s(size(s)): A)
	=>
	(last(s): A)


  RULE InSetXY.29
	(binhyp(f: a +-> b)) &
	(binhyp(x: dom(f))) &
	(f(x) = l)
	=>
	(x: dom(f|>{l}))


  RULE InSetXY.30
	(binhyp(f: A +-> B)) &
	(a: dom(f)) &
	(f(a): u)
	=>
	(a: f~[u])


  RULE InSetXY.31
	(binhyp(ran(f)/\A = {})) &
	(bfalse)
	=>
	(f(a): A)


  RULE InSetXY.32
	(binhyp(A/\ran(f) = {})) &
	(bfalse)
	=>
	(f(a): A)


  RULE InSetXY.33
	band((binhyp(max(A)<=b)), 
	(binhyp(b+1<=c))) &
	(bfalse)
	=>
	(c: A)


  RULE InSetXY.34
	band((binhyp(b<=min(A))), 
	(binhyp(c+1<=b))) &
	(bfalse)
	=>
	(c: A)


  RULE InSetXY.35
	(binhyp(dom(f)/\A = {})) &
	(bfalse)
	=>
	(f~(a): A)


  RULE InSetXY.36
	(binhyp(A/\dom(f) = {})) &
	(bfalse)
	=>
	(f~(a): A)


  RULE InSetXY.37
	(bfalse)
	=>
	(a: {})


  RULE InSetXY.38
	(bfalse)
	=>
	(a: A-A)



THEORY InSetLeavesXY IS



  RULE InSetLeavesXY.1
	(binhyp(s~: E +-> NATURAL))
	=>
	(front(s)~: E +-> NATURAL)


  RULE InSetLeavesXY.2
	(binhyp(s~: E +-> NATURAL))
	=>
	(tail(s)~: E +-> NATURAL)


  RULE InSetLeavesXY.3
	(bsearch({a},A\/B,r))
	=>
	(a: A\/B)


  RULE InSetLeavesXY.4
	(btest(2<1))
	=>
	(__blankrule)


  RULE InSetLeavesXY.5
	(binhyp(A = b\/{c})) &
	(bsearch({a},b\/{c},R))
	=>
	(a: A)


  RULE InSetLeavesXY.6
	(binhyp(c = a))
	=>
	(a: b\/{c})


  RULE InSetLeavesXY.7
	(binhyp(a = c))
	=>
	(a: b\/{c})


  RULE InSetLeavesXY.8
	band((binhyp(a: b\/c)), 
	(binhyp(not(a: c))))
	=>
	(a: b)


  RULE InSetLeavesXY.9
	band((binhyp(a: b\/c)), 
	(binhyp(not(a: b))))
	=>
	(a: c)


  RULE InSetLeavesXY.10
	band((binhyp(a: b)), 
	(binhyp(b: POW(c))))
	=>
	(a: c)


  RULE InSetLeavesXY.11
	band((binhyp(a: b)), 
	(binhyp(b = c)))
	=>
	(a: c)


  RULE InSetLeavesXY.12
	band((binhyp(a: b)), 
	(binhyp(c = b)))
	=>
	(a: c)


  RULE InSetLeavesXY.13
	band((binhyp(b = c)), 
	(binhyp(a: b)))
	=>
	(a: c)


  RULE InSetLeavesXY.14
	band((binhyp(c = b)), 
	(binhyp(a: b)))
	=>
	(a: c)


  RULE InSetLeavesXY.15
	(binhyp(ran(f): POW(T)))
	=>
	(f(a): T)


  RULE InSetLeavesXY.16
	(binhyp(f: seq(T)))
	=>
	(f(a): T)


  RULE InSetLeavesXY.17
	(binhyp(f: S +-> T))
	=>
	(f(a): T)


  RULE InSetLeavesXY.18
	f(a): ran(f)


  RULE InSetLeavesXY.19
	band((binhyp(a: f~[{c}])), 
	(binhyp(dom(f) = A)))
	=>
	(a: A)


  RULE InSetLeavesXY.20
	max(s): s


  RULE InSetLeavesXY.21
	max(s-t): s


  RULE InSetLeavesXY.22
	min(s): s


  RULE InSetLeavesXY.23
	min(s-t): s


  RULE InSetLeavesXY.24
	(binhyp(k|>a: POW(l)))
	=>
	(k|>a-{n}: POW(l))


  RULE InSetLeavesXY.25
	(binhyp(a<|k: POW(l)))
	=>
	(a-{n}<|k: POW(l))


  RULE InSetLeavesXY.26
	(binhyp(d(l) = c))
	=>
	(c: d[{l}])


  RULE InSetLeavesXY.27
	first(s): ran(s)


  RULE InSetLeavesXY.28
	last(s): ran(s)


  RULE InSetLeavesXY.29
	(binhyp(f(x) = y))
	=>
	(x|->y: f)


  RULE InSetLeavesXY.30
	x|->f(x): f


  RULE InSetLeavesXY.31
	(binhyp(f(x) = a))
	=>
	(x: dom(f|>{a}))


  RULE InSetLeavesXY.32
	(binhyp(ran(f): POW(P))) &
	(binhyp(ran(g): POW(P)))
	=>
	((f\/g)(x): P)


  RULE InSetLeavesXY.33
	band((binhyp(x: a\/b)), 
	(binhyp(b: POW(a))))
	=>
	(x: a)


  RULE InSetLeavesXY.34
	f~(a): dom(f)


  RULE InSetLeavesXY.35
	(binhyp(dom(f): POW(A)))
	=>
	(f~(a): A)


  RULE InSetLeavesXY.36
	f(a): f[{a}]


  RULE InSetLeavesXY.37
	(binhyp(x: A*B))
	=>
	(prj1(A,B)(x): A)


  RULE InSetLeavesXY.38
	(binhyp(x: A*B))
	=>
	(prj2(A,B)(x): B)


  RULE InSetLeavesXY.39
	(bstring(s))
	=>
	(s: STRING)


  RULE InSetLeavesXY.40
	a: b\/{a}


  RULE InSetLeavesXY.41
	a: {a}


  RULE InSetLeavesXY.42
	TRUE: BOOL


  RULE InSetLeavesXY.43
	FALSE: BOOL


  RULE InSetLeavesXY.44
	bool(C): BOOL



THEORY InStructXY IS



  RULE InStructXY.1
	(bnot(bpattern(b,g>>h))) &
	(b: f) &
	(rec(a): struct(d))
	=>
	(rec(a,b): struct(d,e>>f))


  RULE InStructXY.2
	(c: e) &
	(rec(a): struct(d))
	=>
	(rec(a,b>>c): struct(d,b>>e))


  RULE InStructXY.3
	(bnot(bpattern(b,g>>h))) &
	(b: f)
	=>
	(rec(b): struct(e>>f))


  RULE InStructXY.4
	(c: e)
	=>
	(rec(b>>c): struct(b>>e))



THEORY NegationXY IS



  RULE NegationXY.1
	(#x.not(P))
	=>
	(not(!x.P))


  RULE NegationXY.2
	(!x.not(P))
	=>
	(not(#x.P))


  RULE NegationXY.3
	(a) &
	(not(b))
	=>
	(not(a => b))


  RULE NegationXY.4
	(not(p) or not(q))
	=>
	(not(p & q))


  RULE NegationXY.5
	(not(p)) &
	(not(q))
	=>
	(not(p or q))


  RULE NegationXY.6
	(p)
	=>
	(not(not(p)))


  RULE NegationXY.7
	(y+1<=x)
	=>
	(not(x<=y))


  RULE NegationXY.8
	(bfalse)
	=>
	(not(btrue))


  RULE NegationXY.9
	(a: INTEGER) &
	(a+1<=0)
	=>
	(not(a: INTEGER & 0<=a))


  RULE NegationXY.10
	(binhyp(y+1<=x))
	=>
	(not(x = y))


  RULE NegationXY.11
	(binhyp(x+1<=y))
	=>
	(not(x = y))


  RULE NegationXY.12
	not(bfalse)



THEORY NotInSetTryXY IS



  RULE NotInSetTryXY.1
	band((binhyp(f: a +-> b)), 
	(binhyp(x: dom(f)))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(ran(f)/\s = {} | Curr)))
	=>
	(not(f(x): s))



THEORY NotInSetXY IS



  RULE NotInSetXY.1
	(not(a: b)) &
	(not(a: c))
	=>
	(not(a: b\/c))


  RULE NotInSetXY.2
	(not(A = {})) &
	(not(A = {a}))
	=>
	(not(A: POW({a})))


  RULE NotInSetXY.3
	band((binhyp(not(a: r[v]))), 
	(binhyp(v: POW(u)))) &
	(not(a: r[u-v]))
	=>
	(not(a: r[u]))


  RULE NotInSetXY.4
	band((binhyp(a: A\/B)), 
	(binhyp(A/\B = {}))) &
	(a: B)
	=>
	(not(a: A))


  RULE NotInSetXY.5
	band((binhyp(a: A\/B)), 
	(binhyp(A/\B = {}))) &
	(a: A)
	=>
	(not(a: B))


  RULE NotInSetXY.6
	band((binhyp(f: s +-> t)), 
	(binhyp(c = f(a)))) &
	(binhyp(a: dom(f))) &
	(not(b = c))
	=>
	(not(a: f~[{b}]))


  RULE NotInSetXY.7
	band((binhyp(f: s +-> t)), 
	(binhyp(f(a) = c))) &
	(binhyp(a: dom(f))) &
	(not(b = c))
	=>
	(not(a: f~[{b}]))


  RULE NotInSetXY.8
	(binhyp(not(a: ran(f))))
	=>
	(not(a: ran(b<<|f)))


  RULE NotInSetXY.9
	(binhyp(not(a: ran(f))))
	=>
	(not(a: f[b]))


  RULE NotInSetXY.10
	(binhyp(not(a: dom(f))))
	=>
	(not(a: dom(f|>>b)))


  RULE NotInSetXY.11
	(binhyp(not(a: dom(f))))
	=>
	(not(a: f~[b]))


  RULE NotInSetXY.12
	(binhyp(s: a +-> NATURAL-{0}))
	=>
	(not(0: ran(s)))


  RULE NotInSetXY.13
	(binhyp(s: seq(a)))
	=>
	(not(0: ran(s~)))


  RULE NotInSetXY.14
	not(0: 1..size(s))


  RULE NotInSetXY.15
	band((binhyp(c: b)), 
	(binhyp(a/\b = {})))
	=>
	(not(c: a))


  RULE NotInSetXY.16
	band((binhyp(not(a: b))), 
	(binhyp(c: POW(b))))
	=>
	(not(a: c))


  RULE NotInSetXY.17
	band((binhyp(not(a: r[v]))), 
	(binhyp(u: POW(v))))
	=>
	(not(a: r[u]))


  RULE NotInSetXY.18
	band((binhyp(A: POW(a..b))), 
	(binhyp(b+1<=c)))
	=>
	(not(c: A))


  RULE NotInSetXY.19
	band((binhyp(A: POW(a..b))), 
	(binhyp(c+1<=a)))
	=>
	(not(c: A))


  RULE NotInSetXY.20
	band((binhyp(f: s +-> t)), 
	(binhyp(not(b = f(a)))))
	=>
	(not(a: f~[{b}]))


  RULE NotInSetXY.21
	band((binhyp(f: s +-> t)), 
	(binhyp(not(f(a) = b))))
	=>
	(not(a: f~[{b}]))


  RULE NotInSetXY.22
	(binhyp(not(a: ran(f))))
	=>
	(not(a: ran(b<<|f)))


  RULE NotInSetXY.23
	(binhyp(not(a: ran(f))))
	=>
	(not(a: ran(b<|f)))


  RULE NotInSetXY.24
	(binhyp(not(a: ran(f))))
	=>
	(not(a: ran(f|>>b)))


  RULE NotInSetXY.25
	(binhyp(not(a: ran(f))))
	=>
	(not(a: ran(f|>b)))


  RULE NotInSetXY.26
	(binhyp(not(a: dom(f))))
	=>
	(not(a: dom(f|>>b)))


  RULE NotInSetXY.27
	(binhyp(not(a: dom(f))))
	=>
	(not(a: dom(f|>b)))


  RULE NotInSetXY.28
	(binhyp(not(a: dom(f))))
	=>
	(not(a: dom(b<<|f)))


  RULE NotInSetXY.29
	(binhyp(not(a: dom(f))))
	=>
	(not(a: dom(b<|f)))



THEORY OrderTryXY IS



  RULE OrderTryXY.1
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(b: POW(c) | Curr)))
	=>
	(card(a\/b)<=card(a\/c))


  RULE OrderTryXY.2
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(a: POW(c) | Curr)))
	=>
	(card(a\/b)<=card(c\/b))


  RULE OrderTryXY.3
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(a: POW(d) | Curr))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(c: POW(e) | Curr)))
	=>
	(card(a\/b\/c)<=card(d\/b\/e))


  RULE OrderTryXY.4
	band((binhyp(p<=b)), 
	(bguard(Fast_Prove_Order: a<=p))) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(c: INTEGER & 0<=c | Curr)))
	=>
	(a<=b+c)


  RULE OrderTryXY.5
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(x: s | Curr)))
	=>
	(x<=max(s))


  RULE OrderTryXY.6
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(x: s | Curr)))
	=>
	(min(s)<=x)


  RULE OrderTryXY.7
	band((binhyp(n<=p)), 
	band((bnot(bpattern(p,n))), 
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(p<=q | Curr)))))
	=>
	(n<=q)


  RULE OrderTryXY.8
	band((binhyp(p<=q)), 
	band((bnot(bpattern(p,q))), 
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(n<=p | Curr)))))
	=>
	(n<=q)



THEORY OrderXY IS



  RULE OrderXY.1
	(binhyp(a: INTEGER)) &
	(binhyp(0<=a)) &
	(binhyp(b: INTEGER)) &
	(binhyp(0<=b)) &
	(1<=a) &
	(1<=b)
	=>
	(1<=a*b)


  RULE OrderXY.2
	(bguard(Fast_Prove_Positif: x)) &
	(x = 0)
	=>
	(x<=0)


  RULE OrderXY.3
	(not(a = {}))
	=>
	(1<=card(a))


  RULE OrderXY.4
	(not(X<=0 & Y<=0) => 0<=X & 0<=Y)
	=>
	(0<=X*Y)


  RULE OrderXY.5
	(btest(2<1))
	=>
	(__blankrule)


  RULE OrderXY.6
	(btest(2<1))
	=>
	(__blankrule)


  RULE OrderXY.7
	(x\n) &
	(!x.(p => x<=n))
	=>
	(max(SET(x).p)<=n)


  RULE OrderXY.8
	(x\n) &
	(!x.(p => n<=x))
	=>
	(n<=min(SET(x).p))


  RULE OrderXY.9
	(binhyp(a<=m)) &
	(btest(m
	(n<=a)


  RULE OrderXY.10
	(binhyp(m<=a)) &
	(btest(n
	(a<=n)


  RULE OrderXY.11
	(binhyp(b<=a)) &
	(bfalse)
	=>
	(a+1<=b)


  RULE OrderXY.12
	(bguard(Fast_Prove_Order: m+1<=n)) &
	(bfalse)
	=>
	(n<=m)


  RULE OrderXY.13
	(btest(1<=N)) &
	(bsearch({e},A/\B,R))
	=>
	(card(A/\B)<=N)


  RULE OrderXY.14
	band((binhyp(a: POW(b))), 
	(binhyp(card(b)<=n)))
	=>
	(card(a)<=n)


  RULE OrderXY.15
	(binhyp(card(a)+1<=n))
	=>
	(card(a\/{b})<=n)


  RULE OrderXY.16
	(binhyp(n: dom(s)))
	=>
	(n<=size(s))


  RULE OrderXY.17
	(btest(2<1))
	=>
	(__blankrule)


  RULE OrderXY.18
	band((binhyp(m+n<=p)), 
	(bguard(Fast_Prove_Positif: m)))
	=>
	(n<=p)


  RULE OrderXY.19
	band((binhyp(n+m<=p)), 
	(bguard(Fast_Prove_Positif: m)))
	=>
	(n<=p)


  RULE OrderXY.20
	(binhyp(n<=min(a))) &
	(binhyp(not(n: a)))
	=>
	(n+1<=min(a))


  RULE OrderXY.21
	n<=min(n..p/\a)


  RULE OrderXY.22
	n<=min((n..p)-a)


  RULE OrderXY.23
	(binhyp(n<=min(a))) &
	(binhyp(p: INTEGER)) &
	(binhyp(0<=p))
	=>
	(n<=min(a)+p)


  RULE OrderXY.24
	n<=max(n..p/\a)


  RULE OrderXY.25
	n<=max((n..p)-a)


  RULE OrderXY.26
	f(x)<=max(ran(f))


  RULE OrderXY.27
	(binhyp(x: a))
	=>
	(f(x)<=max(f[a]))


  RULE OrderXY.28
	(binhyp(ran(r): POW(A)))
	=>
	(r(x)<=max(A))


  RULE OrderXY.29
	(binhyp(n: s))
	=>
	(n<=max(s))


  RULE OrderXY.30
	(binhyp(f: s +-> t))
	=>
	(min(ran(f))<=f(x))


  RULE OrderXY.31
	band((binhyp(f: s +-> t)), 
	(binhyp(x: a)))
	=>
	(min(f[a])<=f(x))


  RULE OrderXY.32
	min(n..p/\a)<=p


  RULE OrderXY.33
	min((n..p)-a)<=p


  RULE OrderXY.34
	max(n..p/\a)<=p


  RULE OrderXY.35
	max((n..p)-a)<=p


  RULE OrderXY.36
	(binhyp(a: POW(b)))
	=>
	(min(b)<=min(a))


  RULE OrderXY.37
	(binhyp(n: s))
	=>
	(min(s)<=n)


  RULE OrderXY.38
	(binhyp(a: POW(b)))
	=>
	(max(a)<=max(b))


  RULE OrderXY.39
	max(b)<=max(a\/b)


  RULE OrderXY.40
	max(a)<=max(a\/b)


  RULE OrderXY.41
	max(a-b)<=max(a)


  RULE OrderXY.42
	max(a/\b)<=max(b)


  RULE OrderXY.43
	max(a/\b)<=max(a)


  RULE OrderXY.44
	min(a)<=min(a/\b)


  RULE OrderXY.45
	min(b)<=min(a/\b)


  RULE OrderXY.46
	min(a)<=min(a-b)


  RULE OrderXY.47
	min(a\/b)<=min(a)


  RULE OrderXY.48
	min(a\/b)<=min(b)


  RULE OrderXY.49
	(binhyp(max(a)<=p)) &
	(binhyp(not(p: a)))
	=>
	(max(a)+1<=p)


  RULE OrderXY.50
	(binhyp(card(S)<=n)) &
	(x\S)
	=>
	(card(SET(x).(x: S & P))<=n)


  RULE OrderXY.51
	(binhyp(a: POW(b)))
	=>
	(card(a)<=card(b))


  RULE OrderXY.52
	(binhyp(card(a)<=n))
	=>
	(card(a-b)<=n)


  RULE OrderXY.53
	card(a/\b)<=card(b)


  RULE OrderXY.54
	card(a-b)<=card(a)


  RULE OrderXY.55
	band((binhyp(n<=q)), 
	band((binhyp(m<=p)), 
	(btest(q<=m))))
	=>
	(n<=p)


  RULE OrderXY.56
	band((binhyp(n<=q)), 
	(binhyp(q<=p)))
	=>
	(n<=p)


  RULE OrderXY.57
	band((binhyp(n<=q)), 
	band((binhyp(q<=r)), 
	(binhyp(r<=p))))
	=>
	(n<=p)


  RULE OrderXY.58
	band((binhyp(r<=p)), 
	(bguard(Fast_Prove_Order: n<=r))) &
	(bguard(Fast_Prove_Positif: q))
	=>
	(n<=p+q)


  RULE OrderXY.59
	(binhyp(n<=p)) &
	(bguard(Fast_Prove_Positif: q))
	=>
	(n<=p+q)


  RULE OrderXY.60
	band((binhyp(r<=q)), 
	(bguard(Fast_Prove_Order: n<=r))) &
	(bguard(Fast_Prove_Positif: p))
	=>
	(n<=p+q)


  RULE OrderXY.61
	(binhyp(n<=q)) &
	(bguard(Fast_Prove_Positif: p))
	=>
	(n<=p+q)


  RULE OrderXY.62
	band((binhyp(n+m<=q)), 
	(bguard(Fast_Prove_Order: p<=m)))
	=>
	(n+p<=q)


  RULE OrderXY.63
	(binhyp(n<=m)) &
	(binhyp(p<=q))
	=>
	(n+p<=m+q)


  RULE OrderXY.64
	(binhyp(n<=q)) &
	(binhyp(p<=m))
	=>
	(n+p<=m+q)


  RULE OrderXY.65
	(binhyp(a<=b)) &
	(binhyp(not(a = b)))
	=>
	(a+1<=b)


  RULE OrderXY.66
	(bguard(Fast_Prove_Positif: n)) &
	(binhyp(not(n = 0)))
	=>
	(1<=n)


  RULE OrderXY.67
	(bguard(Fast_Prove_Positif: m))
	=>
	(n<=n+m)


  RULE OrderXY.68
	band((binhyp(a<=m)), 
	(bguard(Fast_Prove_All_Order: m<=n)))
	=>
	(a<=n)


  RULE OrderXY.69
	band((binhyp(p<=q)), 
	(bguard(Fast_Prove_All_Order: n<=p)))
	=>
	(n<=q)


  RULE OrderXY.70
	(btest(2<1))
	=>
	(__blankrule)


  RULE OrderXY.71
	(btest(a<=b))
	=>
	(a<=b)


  RULE OrderXY.72
	x<=x


  RULE OrderXY.73
	(binhyp(a+b<=c))
	=>
	(0<=c-a-b)


  RULE OrderXY.74
	(binhyp(0<=b)) &
	(binhyp(a<=c))
	=>
	(0<= -a+b+c)


  RULE OrderXY.75
	(binhyp(0<=c)) &
	(binhyp(a<=b))
	=>
	(0<= -a+b+c)


  RULE OrderXY.76
	(binhyp(0<=b)) &
	(binhyp(c<=a))
	=>
	(0<=a+b-c)


  RULE OrderXY.77
	(binhyp(0<=a)) &
	(binhyp(c<=b))
	=>
	(0<=a+b-c)


  RULE OrderXY.78
	(binhyp(0<=a)) &
	(binhyp(b<=c))
	=>
	(0<=a-b+c)


  RULE OrderXY.79
	(binhyp(b<=a))
	=>
	(0<=a-b)


  RULE OrderXY.80
	(binhyp(0<=b-a))
	=>
	(a<=b)


  RULE OrderXY.81
	(-1<=n)
	=>
	(0<=succ(n))


  RULE OrderXY.82
	(1<=n)
	=>
	(0<=pred(n))


  RULE OrderXY.83
	(not(0<=n & (0<= -p => n+1<= -p)) => n<=0 & (0<=p => 1-n<=p))
	=>
	(0<=n/p)


  RULE OrderXY.84
	(!x.(P => not(E = 0)) => card(SET(x).(P & E<= -1)) mod 2 = 0)
	=>
	(0<=PI(x).(P | E))


  RULE OrderXY.85
	(binhyp(S: FIN(T))) &
	(x\S) &
	(not(0: ran(%x.(x: S | E))) => card(SET(x).(x: S & E<= -1)) mod 2 = 0)
	=>
	(0<=PI(x).(x: S | E))


  RULE OrderXY.86
	(!x.(x: p..q => not(E = 0)) => card(SET(x).(x: p..q & E<= -1)) mod 2 = 0)
	=>
	(0<=PI(x).(x: p..q | E))


  RULE OrderXY.87
	(bsearch((x: p..q),P,r)) &
	(SIGMA(x).(P & 0<= -E | -E)<=SIGMA(x).(P & 0<=E | E))
	=>
	(0<=SIGMA(x).(P | E))


  RULE OrderXY.88
	(bpattern(P,(u & v))) &
	band((bsearch(x<=q,P,r)), 
	(bsearch(p<=x,P,s))) &
	(SIGMA(x).(P & 0<= -E | -E)<=SIGMA(x).(P & 0<=E | E))
	=>
	(0<=SIGMA(x).(P | E))


  RULE OrderXY.89
	(SIGMA(x).(x: p..q & 0<= -E | -E)<=SIGMA(x).(x: p..q & 0<=E | E))
	=>
	(0<=SIGMA(x).(x: p..q | E))


  RULE OrderXY.90
	(not(S/\NATURAL = {}))
	=>
	(0<=max(S))


  RULE OrderXY.91
	(S: POW(NATURAL))
	=>
	(0<=min(S))


  RULE OrderXY.92
	(bguard(Fast_Prove_Positif: n))
	=>
	(0<=n**p)


  RULE OrderXY.93
	(btest(2<1))
	=>
	(__blankrule)


  RULE OrderXY.94
	band((binhyp(n: INTEGER)), 
	band((binhyp(0<=n)), 
	(bnum(p))))
	=>
	(0<=n+p)


  RULE OrderXY.95
	0<=card(S)


  RULE OrderXY.96
	0<=size(s)


  RULE OrderXY.97
	0<=card(n..p)


  RULE OrderXY.98
	band((binhyp(a<=n)), 
	(btest(a>=0)))
	=>
	(0<=n)


  RULE OrderXY.99
	band((binhyp(a<=n)), 
	(binhyp(0<=a)))
	=>
	(0<=n)


  RULE OrderXY.100
	(btest(n>=0))
	=>
	(0<=n)


  RULE OrderXY.101
	band((binhyp(s: seq(T))), 
	(binhyp(T: POW(NATURAL))))
	=>
	(0<=s(a))


  RULE OrderXY.102
	band((binhyp(s: S +-> T)), 
	(binhyp(T: POW(NATURAL))))
	=>
	(0<=s(a))


  RULE OrderXY.103
	0<=a*a


  RULE OrderXY.104
	(btest(a rle b))
	=>
	(a rle b)


  RULE OrderXY.105
	(btest(a rge b))
	=>
	(a rge b)


  RULE OrderXY.106
	(btest(a rlt b))
	=>
	(a rlt b)


  RULE OrderXY.107
	(btest(a rgt b))
	=>
	(a rgt b)



THEORY DisjonctionTryXY IS



  RULE DisjonctionTryXY.1
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(not(b) => a | Curr)))
	=>
	(a or b)


  RULE DisjonctionTryXY.2
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(not(a) => b | Curr)))
	=>
	(a or b)


  RULE DisjonctionTryXY.3
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(a => b | Curr)))
	=>
	(not(a) or b)


  RULE DisjonctionTryXY.4
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(b => a | Curr)))
	=>
	(a or not(b))



THEORY DisjonctionXY IS



  RULE DisjonctionXY.1
	(binhyp(a))
	=>
	(a or b)


  RULE DisjonctionXY.2
	(binhyp(b))
	=>
	(a or b)


  RULE DisjonctionXY.3
	(binhyp(not(a) => b))
	=>
	(a or b)


  RULE DisjonctionXY.4
	(binhyp(not(b) => a))
	=>
	(a or b)


  RULE DisjonctionXY.5
	(binhyp(a => b))
	=>
	(not(a) or b)


  RULE DisjonctionXY.6
	(binhyp(b => a))
	=>
	(a or not(b))



THEORY SplitOr IS



  RULE SplitOr.1
	(not(b) => a)
	=>
	(a or b)


  RULE SplitOr.2
	(not(a) => b)
	=>
	(a or b)



THEORY TryRulesXY IS



  RULE TryRulesXY.1
	band((binhyp(a = b)), 
	(bsubfrm(b,toto,B,(R,?)))) &
	(bguard(SubFrmX: SubFrmG(b,a,B),C)) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(C | Curr)))
	=>
	(B)


  RULE TryRulesXY.2
	band((binhyp(a = b)), 
	(bsubfrm(a,toto,B,(R,?)))) &
	(bguard(SubFrmX: SubFrmG(b,a,B),C)) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(C | Curr)))
	=>
	(B)


  RULE TryRulesXY.3
	band((binhyp(!x.(P => Q))), 
	band((bmatch(x,Q,B,e)), 
	band((bguard((SUB;RES): bresult([x:=e]P),C)), 
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e([x:=e]P | Curr)))))) &
	(WD(expr(e),Z))
	=>
	(B)




FORWARD RULES


THEORY GenDirectContradictionX IS



  RULE GenDirectContradictionX.1
	(1<=size({}))
	=>
	(bfalse)


  RULE GenDirectContradictionX.2
	(2<=card(ran(first(s)->s/|\2))) &
	(not(s = {}))
	=>
	(bfalse)


  RULE GenDirectContradictionX.3
	(!x.(x: y => x<=n)) &
	(a: y) &
	(n+1<=a) &
	(x\(y,n))
	=>
	(bfalse)


  RULE GenDirectContradictionX.4
	(a/\b = {}) &
	(c: a) &
	(c: b)
	=>
	(bfalse)


  RULE GenDirectContradictionX.5
	(c: a) &
	(a/\b = {}) &
	(c: b)
	=>
	(bfalse)


  RULE GenDirectContradictionX.6
	(c: b) &
	(a/\b = {}) &
	(c: a)
	=>
	(bfalse)


  RULE GenDirectContradictionX.7
	(a => not(b)) &
	(a => b) &
	(a)
	=>
	(bfalse)


  RULE GenDirectContradictionX.8
	(a => b) &
	(a => not(b)) &
	(a)
	=>
	(bfalse)


  RULE GenDirectContradictionX.9
	(a) &
	(a => not(b)) &
	(a => b)
	=>
	(bfalse)


  RULE GenDirectContradictionX.10
	(not(a)) &
	(a)
	=>
	(bfalse)


  RULE GenDirectContradictionX.11
	(a) &
	(not(a))
	=>
	(bfalse)


  RULE GenDirectContradictionX.12
	(b+1<=a) &
	(a = b)
	=>
	(bfalse)


  RULE GenDirectContradictionX.13
	(a = b) &
	(b+1<=a)
	=>
	(bfalse)


  RULE GenDirectContradictionX.14
	(a+1<=b) &
	(b+1<=a)
	=>
	(bfalse)


  RULE GenDirectContradictionX.15
	(b+1<=a) &
	(a+1<=b)
	=>
	(bfalse)


  RULE GenDirectContradictionX.16
	(a+1<=b) &
	(b<=a)
	=>
	(bfalse)


  RULE GenDirectContradictionX.17
	(b<=a) &
	(a+1<=b)
	=>
	(bfalse)


  RULE GenDirectContradictionX.18
	(not(b = a)) &
	(a = b)
	=>
	(bfalse)


  RULE GenDirectContradictionX.19
	(a = b) &
	(not(b = a))
	=>
	(bfalse)


  RULE GenDirectContradictionX.20
	(a+n = n) &
	(1<=a)
	=>
	(bfalse)


  RULE GenDirectContradictionX.21
	(1<=a) &
	(a+n = n)
	=>
	(bfalse)


  RULE GenDirectContradictionX.22
	(a+n = a) &
	(1<=n)
	=>
	(bfalse)


  RULE GenDirectContradictionX.23
	(1<=n) &
	(a+n = a)
	=>
	(bfalse)


  RULE GenDirectContradictionX.24
	(a+1<=a)
	=>
	(bfalse)


  RULE GenDirectContradictionX.25
	(a<=a-1)
	=>
	(bfalse)


  RULE GenDirectContradictionX.26
	(m = n+p) &
	(m+1<=p) &
	(n: INTEGER) &
	(0<=n)
	=>
	(bfalse)


  RULE GenDirectContradictionX.27
	(m+1<=p) &
	(m = n+p) &
	(n: INTEGER) &
	(0<=n)
	=>
	(bfalse)


  RULE GenDirectContradictionX.28
	(n: INTEGER) &
	(0<=n) &
	(m+1<=p) &
	(m = n+p)
	=>
	(bfalse)


  RULE GenDirectContradictionX.29
	(m = n+p) &
	(m+1<=p) &
	(n: a..b) &
	(0<=a)
	=>
	(bfalse)


  RULE GenDirectContradictionX.30
	(m = n+p) &
	(m+1<=p) &
	(n: a..b) &
	(a: INTEGER) &
	(0<=a)
	=>
	(bfalse)


  RULE GenDirectContradictionX.31
	(m+1<=p) &
	(m = n+p) &
	(n: a..b) &
	(0<=a)
	=>
	(bfalse)


  RULE GenDirectContradictionX.32
	(m+1<=p) &
	(m = n+p) &
	(n: a..b) &
	(a: INTEGER) &
	(0<=a)
	=>
	(bfalse)


  RULE GenDirectContradictionX.33
	(n: a..b) &
	(m = n+p) &
	(m+1<=p) &
	(0<=a)
	=>
	(bfalse)


  RULE GenDirectContradictionX.34
	(not(a = a))
	=>
	(bfalse)


  RULE GenDirectContradictionX.35
	(TRUE = FALSE)
	=>
	(bfalse)


  RULE GenDirectContradictionX.36
	(FALSE = TRUE)
	=>
	(bfalse)


  RULE GenDirectContradictionX.37
	(a = FALSE) &
	(a = TRUE)
	=>
	(bfalse)


  RULE GenDirectContradictionX.38
	(a = TRUE) &
	(a = FALSE)
	=>
	(bfalse)


  RULE GenDirectContradictionX.39
	(not(a: {a}))
	=>
	(bfalse)


  RULE GenDirectContradictionX.40
	(a: ran({}))
	=>
	(bfalse)


  RULE GenDirectContradictionX.41
	(a: dom({}))
	=>
	(bfalse)


  RULE GenDirectContradictionX.42
	(a: {})
	=>
	(bfalse)


  RULE GenDirectContradictionX.43
	({a} = {})
	=>
	(bfalse)


  RULE GenDirectContradictionX.44
	(a\/{b} = {})
	=>
	(bfalse)


  RULE GenDirectContradictionX.45
	({b}\/a = {})
	=>
	(bfalse)


  RULE GenDirectContradictionX.46
	(not(e|->r(e): r)) &
	(e: dom(r)) &
	(r: s +-> t)
	=>
	(bfalse)


  RULE GenDirectContradictionX.47
	(a = b) &
	(b: s) &
	(not(a: s))
	=>
	(bfalse)


  RULE GenDirectContradictionX.48
	(a = b) &
	(not(b: s)) &
	(a: s)
	=>
	(bfalse)


  RULE GenDirectContradictionX.49
	(a<=b) &
	(btest(b
	(bfalse)


  RULE GenDirectContradictionX.50
	(a = b) &
	(c<=a) &
	(btest(b
	(bfalse)


  RULE GenDirectContradictionX.51
	(c<=a) &
	(a = b) &
	(btest(b
	(bfalse)


  RULE GenDirectContradictionX.52
	(k: f) &
	(f: POW(l)) &
	(not(k: l))
	=>
	(bfalse)


  RULE GenDirectContradictionX.53
	(not(r(e)|->e: r~)) &
	(e: dom(r)) &
	(r: s +-> t)
	=>
	(bfalse)


  RULE GenDirectContradictionX.54
	(not(a: INTEGER))
	=>
	(bfalse)



THEORY GenTryContradictionX IS



  RULE GenTryContradictionX.1
	(not(c: d[{l}])) &
	(d(l) = c) &
	(d: s +-> t)
	=>
	(bfalse)


  RULE GenTryContradictionX.2
	(n: a) &
	(not(n: b)) &
	(bguard(attempt_to_prove: a_t_t_e_m_p_t__t_o__p_r_o_v_e(a: POW(b) | Curr)))
	=>
	(bfalse)



THEORY GenEqualityX IS



  RULE GenEqualityX.1
	(a<=b) &
	(b<=a)
	=>
	(a = b)


  RULE GenEqualityX.2
	(a-n = b) &
	(n<=a)
	=>
	(a = b+n)


  RULE GenEqualityX.3
	(n<=a) &
	(a-n = b)
	=>
	(a = b+n)


  RULE GenEqualityX.4
	(x: dom({a|->b}))
	=>
	(x = a)


  RULE GenEqualityX.5
	(a: POW(b)) &
	(b: POW(a))
	=>
	(a = b)


  RULE GenEqualityX.6
	(b/\c = {}) &
	(a: POW(b))
	=>
	(a/\c = {})


  RULE GenEqualityX.7
	(a: POW(b)) &
	(b/\c = {})
	=>
	(a/\c = {})


  RULE GenEqualityX.8
	(b/\c = {}) &
	(a: POW(c))
	=>
	(a/\b = {})


  RULE GenEqualityX.9
	(a: POW(c)) &
	(b/\c = {})
	=>
	(a/\b = {})


  RULE GenEqualityX.10
	(a/\b = {}) &
	(a: POW(b))
	=>
	(a = {})


  RULE GenEqualityX.11
	(a: POW(b)) &
	(a/\b = {})
	=>
	(a = {})


  RULE GenEqualityX.12
	(a/\b = c)
	=>
	(b/\a = c)


  RULE GenEqualityX.13
	(a\/b = c)
	=>
	(b\/a = c)


  RULE GenEqualityX.14
	(dom(f) = {})
	=>
	(f = {})


  RULE GenEqualityX.15
	(ran(f) = {})
	=>
	(f = {})


  RULE GenEqualityX.16
	(not(a: {b|->c}[{b}]))
	=>
	(not(a = c)) &
	(not(c = a))


  RULE GenEqualityX.17
	(not(a = TRUE))
	=>
	(a = FALSE)


  RULE GenEqualityX.18
	(not(a = FALSE))
	=>
	(a = TRUE)


  RULE GenEqualityX.19
	(a|->b = c|->d)
	=>
	(a = c) &
	(b = d)



THEORY GenFromRelationX IS



  RULE GenFromRelationX.1
	(f: s +-> t)
	=>
	(f: s <-> t)


  RULE GenFromRelationX.2
	(r: s <-> t)
	=>
	(dom(r): POW(s)) &
	(ran(r): POW(t))


  RULE GenFromRelationX.3
	(r~: s <-> t)
	=>
	(r: t <-> s)


  RULE GenFromRelationX.4
	(s: seq(a))
	=>
	(s: 1..size(s) +-> a) &
	(dom(s) = 1..size(s)) &
	(size(s): INTEGER) &
	(0<=size(s))



THEORY GenAllInPOWX IS



  RULE GenAllInPOWX.1
	(a: POW(c)) &
	(a = b) &
	(bnot(bpattern(b,c)))
	=>
	(b: POW(c))


  RULE GenAllInPOWX.2
	(a = b) &
	(a: POW(c)) &
	(bnot(bpattern(b,c)))
	=>
	(b: POW(c))


  RULE GenAllInPOWX.3
	(a: POW(c)) &
	(b = a) &
	(bnot(bpattern(b,c)))
	=>
	(b: POW(c))


  RULE GenAllInPOWX.4
	(b = a) &
	(a: POW(c)) &
	(bnot(bpattern(b,c)))
	=>
	(b: POW(c))



THEORY GenInPOWX IS



  RULE GenInPOWX.1
	(a: POW(b)) &
	(b: POW(c))
	=>
	(a: POW(c))


  RULE GenInPOWX.2
	(b: POW(c)) &
	(a: POW(b))
	=>
	(a: POW(c))


  RULE GenInPOWX.3
	(a\/b: POW(c))
	=>
	(a: POW(c)) &
	(b: POW(c))


  RULE GenInPOWX.4
	(c/\a = {}) &
	(a: POW(b\/c))
	=>
	(a: POW(b))


  RULE GenInPOWX.5
	(a: POW(b\/c)) &
	(c/\a = {})
	=>
	(a: POW(b))


  RULE GenInPOWX.6
	(b/\a = {}) &
	(a: POW(b\/c))
	=>
	(a: POW(c))


  RULE GenInPOWX.7
	(a: POW(b\/c)) &
	(b/\a = {})
	=>
	(a: POW(c))


  RULE GenInPOWX.8
	(a/\c = {}) &
	(a: POW(b\/c))
	=>
	(a: POW(b))


  RULE GenInPOWX.9
	(a: POW(b\/c)) &
	(a/\c = {})
	=>
	(a: POW(b))


  RULE GenInPOWX.10
	(a/\b = {}) &
	(a: POW(b\/c))
	=>
	(a: POW(c))


  RULE GenInPOWX.11
	(a: POW(a/\b))
	=>
	(a: POW(b))


  RULE GenInPOWX.12
	(a: POW(b/\a))
	=>
	(a: POW(b))


  RULE GenInPOWX.13
	(r: a <-> b) &
	(r: POW(s))
	=>
	(dom(r): POW(dom(s)))


  RULE GenInPOWX.14
	(r: POW(s)) &
	(r: a <-> b)
	=>
	(dom(r): POW(dom(s)))


  RULE GenInPOWX.15
	(r: a <-> b) &
	(r: POW(s))
	=>
	(ran(r): POW(ran(s)))


  RULE GenInPOWX.16
	(r: POW(s)) &
	(r: a <-> b)
	=>
	(ran(r): POW(ran(s)))


  RULE GenInPOWX.17
	(a: POW(dom(r~)))
	=>
	(a: POW(ran(r)))


  RULE GenInPOWX.18
	(a: POW(ran(r~)))
	=>
	(a: POW(dom(r)))


  RULE GenInPOWX.19
	(a: POW(f[u]))
	=>
	(a: POW(ran(f)))


  RULE GenInPOWX.20
	(a: POW(f~[u]))
	=>
	(a: POW(dom(f)))


  RULE GenInPOWX.21
	(a: POW(SET(x).(x: b))) &
	(x\b)
	=>
	(a: POW(b))


  RULE GenInPOWX.22
	(p: POW(SET(x).(x: f~[b]))) &
	(x\(f,b))
	=>
	(p: POW(dom(f)))


  RULE GenInPOWX.23
	(r[u\/v]: POW(w))
	=>
	(r[u]: POW(w)) &
	(r[v]: POW(w))


  RULE GenInPOWX.24
	(u\/v = w)
	=>
	(u: POW(w)) &
	(v: POW(w))


  RULE GenInPOWX.25
	(a: POW(b/\c))
	=>
	(a: POW(b)) &
	(a: POW(c))


  RULE GenInPOWX.26
	(a: POW(dom(b))) &
	(bnot(bsubfrm(b,btrue,a,Q)))
	=>
	(dom(a<|b) = a)



THEORY GenAllInSetX IS



  RULE GenAllInSetX.1
	(a: dom(f)) &
	(f: A +-> B) &
	(bnot(binhyp(dom(f) = B))) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(f(a): B)),O))
	=>
	(O)


  RULE GenAllInSetX.2
	(f: A +-> B) &
	(a: dom(f)) &
	(bnot(binhyp(dom(f) = B))) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(f(a): B)),O))
	=>
	(O)


  RULE GenAllInSetX.3
	(a: b) &
	(bnot(bpattern(b,(1..j)*{E}))) &
	(b: POW(c)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: c)),O))
	=>
	(O)


  RULE GenAllInSetX.4
	(b: POW(c)) &
	(a: b) &
	(bnot(bpattern(b,(1..j)*{E}))) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: c)),O))
	=>
	(O)


  RULE GenAllInSetX.5
	(f: s +-> t) &
	(s: FIN(a)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(f: FIN(s*t))),O))
	=>
	(O)


  RULE GenAllInSetX.6
	(s: FIN(a)) &
	(f: s +-> t) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(f: FIN(s*t))),O))
	=>
	(O)


  RULE GenAllInSetX.7
	(f: s <-> t) &
	(s: FIN(a)) &
	(t: FIN(b)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(f: FIN(s*t))),O))
	=>
	(O)


  RULE GenAllInSetX.8
	(s: FIN(a)) &
	(f: s <-> t) &
	(t: FIN(b)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(f: FIN(s*t))),O))
	=>
	(O)


  RULE GenAllInSetX.9
	(t: FIN(b)) &
	(s: FIN(a)) &
	(f: s <-> t) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(f: FIN(s*t))),O))
	=>
	(O)



THEORY GenInSetX IS



  RULE GenInSetX.1
	(s: seq(a)-{{}})
	=>
	(s: seq(a)) &
	(not(s = {}))


  RULE GenInSetX.2
	(s: iseq(a)-{{}})
	=>
	(s: seq(a)) &
	(s~: a +-> NATURAL-{0}) &
	(not(s = {}))


  RULE GenInSetX.3
	(s: iseq(a)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(s: seq(a) & s~: a +-> NATURAL-{0})),O))
	=>
	(O)


  RULE GenInSetX.4
	(a: FIN(b)-{{}}) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: FIN(b) & not(a = {}) & card(a): INTEGER & 0<=card(a) & 1<=card(a))),O))
	=>
	(O)


  RULE GenInSetX.5
	(a: POW(b)-{{}}) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: POW(b) & not(a = {}))),O))
	=>
	(O)


  RULE GenInSetX.6
	(btest(2<1))
	=>
	(__blankrule)


  RULE GenInSetX.7
	(not(f(x) = a)) &
	(f: s +-> {a}\/{b}) &
	(f~[{b}] = t) &
	(x: dom(f)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(x: t)),O))
	=>
	(O)


  RULE GenInSetX.8
	(f: s +-> {a}\/{b}) &
	(not(f(x) = a)) &
	(f~[{b}] = t) &
	(x: dom(f)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(x: t)),O))
	=>
	(O)


  RULE GenInSetX.9
	(f~[{b}] = t) &
	(f: s +-> {a}\/{b}) &
	(not(f(x) = a)) &
	(x: dom(f)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(x: t)),O))
	=>
	(O)


  RULE GenInSetX.10
	(not(f(x) = b)) &
	(f: s +-> a\/{b}) &
	(f~[a] = t) &
	(x: dom(f)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(x: t)),O))
	=>
	(O)


  RULE GenInSetX.11
	(f: s +-> a\/{b}) &
	(not(f(x) = b)) &
	(f~[a] = t) &
	(x: dom(f)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(x: t)),O))
	=>
	(O)


  RULE GenInSetX.12
	(f~[a] = t) &
	(f: s +-> a\/{b}) &
	(not(f(x) = b)) &
	(x: dom(f)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(x: t)),O))
	=>
	(O)


  RULE GenInSetX.13
	(x<=b) &
	(a<=x) &
	(dom(f) = a..b)
	=>
	(x: dom(f))


  RULE GenInSetX.14
	(a<=x) &
	(x<=b) &
	(dom(f) = a..b)
	=>
	(x: dom(f))


  RULE GenInSetX.15
	(dom(f) = a..b) &
	(a<=x) &
	(x<=b)
	=>
	(x: dom(f))


  RULE GenInSetX.16
	(1<=size(s)) &
	(s: seq(a)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(first(s): a & last(s): a)),O))
	=>
	(O)


  RULE GenInSetX.17
	(s: seq(a)) &
	(1<=size(s)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(first(s): a & last(s): a)),O))
	=>
	(O)


  RULE GenInSetX.18
	(n: dom(s)) &
	(s: seq(a)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(n: INTEGER & 0<=n & s(n): a & 1<=n & n<=size(s))),O))
	=>
	(O)


  RULE GenInSetX.19
	(s: seq(a)) &
	(n: dom(s)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(n: INTEGER & 0<=n & s(n): a & 1<=n & n<=size(s))),O))
	=>
	(O)


  RULE GenInSetX.20
	(a: dom(r)) &
	(r: s <-> t) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: s)),O))
	=>
	(O)


  RULE GenInSetX.21
	(r: s <-> t) &
	(a: dom(r)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: s)),O))
	=>
	(O)


  RULE GenInSetX.22
	(a: ran(r)) &
	(r: s <-> t) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: t)),O))
	=>
	(O)


  RULE GenInSetX.23
	(r: s <-> t) &
	(a: ran(r)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: t)),O))
	=>
	(O)


  RULE GenInSetX.24
	(a: dom(r)) &
	(r: s +-> t) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: s)),O))
	=>
	(O)


  RULE GenInSetX.25
	(r: s +-> t) &
	(a: dom(r)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: s)),O))
	=>
	(O)


  RULE GenInSetX.26
	(a: ran(r)) &
	(r~: t +-> s) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: t)),O))
	=>
	(O)


  RULE GenInSetX.27
	(r~: t +-> s) &
	(a: ran(r)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: t)),O))
	=>
	(O)


  RULE GenInSetX.28
	(a: f[b]) &
	(f: s <-> t) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: t & a: ran(f))),O))
	=>
	(O)


  RULE GenInSetX.29
	(f: s <-> t) &
	(a: f[b]) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: t & a: ran(f))),O))
	=>
	(O)


  RULE GenInSetX.30
	(a: f~[b]) &
	(f: s <-> t) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: s & a: dom(f))),O))
	=>
	(O)


  RULE GenInSetX.31
	(f: s <-> t) &
	(a: f~[b]) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: s & a: dom(f))),O))
	=>
	(O)


  RULE GenInSetX.32
	(not(a = c)) &
	(a: b\/{c}) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: b)),O))
	=>
	(O)


  RULE GenInSetX.33
	(a: b\/{c}) &
	(not(a = c)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: b)),O))
	=>
	(O)


  RULE GenInSetX.34
	(a: b\/c) &
	(not(a: c)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: b)),O))
	=>
	(O)


  RULE GenInSetX.35
	(not(a: c)) &
	(a: b\/c) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: b)),O))
	=>
	(O)


  RULE GenInSetX.36
	(a: b\/c) &
	(not(a: b)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: c)),O))
	=>
	(O)


  RULE GenInSetX.37
	(not(a: b)) &
	(a: b\/c) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: c)),O))
	=>
	(O)


  RULE GenInSetX.38
	(a: b) &
	(b: POW(c)) &
	(bnot(bpattern(c,INTEGER))) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: c)),O))
	=>
	(O)


  RULE GenInSetX.39
	(b: POW(c)) &
	(a: b) &
	(bnot(bpattern(c,INTEGER))) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: c)),O))
	=>
	(O)


  RULE GenInSetX.40
	(a: b) &
	(c = b) &
	(bnot(bpattern(b,(1..j)*{E}))) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: c)),O))
	=>
	(O)


  RULE GenInSetX.41
	(c = b) &
	(a: b) &
	(bnot(bpattern(b,(1..j)*{E}))) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: c)),O))
	=>
	(O)


  RULE GenInSetX.42
	(a: b) &
	(b = c) &
	(bnot(bpattern(b,(1..j)*{E}))) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: c)),O))
	=>
	(O)


  RULE GenInSetX.43
	(b = c) &
	(a: b) &
	(bnot(bpattern(b,(1..j)*{E}))) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: c)),O))
	=>
	(O)


  RULE GenInSetX.44
	(n: r..s) &
	(r+1<=s) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(n: INTEGER & r<=n & n<=s)),O))
	=>
	(O)


  RULE GenInSetX.45
	(r+1<=s) &
	(n: r..s) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(n: INTEGER & r<=n & n<=s)),O))
	=>
	(O)


  RULE GenInSetX.46
	(a: dom(b<<|f)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: dom(f) & not(a: b))),O))
	=>
	(O)


  RULE GenInSetX.47
	(a: dom(b<|f)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: dom(f) & a: b)),O))
	=>
	(O)


  RULE GenInSetX.48
	(a: ran(f|>>b)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: ran(f) & not(a: b))),O))
	=>
	(O)


  RULE GenInSetX.49
	(a: ran(f|>b)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: ran(f) & a: b)),O))
	=>
	(O)


  RULE GenInSetX.50
	(a: FIN(b))
	=>
	(a: POW(b))


  RULE GenInSetX.51
	(a<=b) &
	(c: a..b) &
	(a: INTEGER) &
	(0<=a) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(c: INTEGER & 0<=c)),O))
	=>
	(O)


  RULE GenInSetX.52
	(c: a..b) &
	(a<=b) &
	(a: INTEGER) &
	(0<=a) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(c: INTEGER & 0<=c)),O))
	=>
	(O)


  RULE GenInSetX.53
	(a: INTEGER) &
	(0<=a) &
	(c: a..b) &
	(a<=b) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(c: INTEGER & 0<=c)),O))
	=>
	(O)


  RULE GenInSetX.54
	(a<=b) &
	(c: a..b) &
	(bnum(a)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(c: INTEGER & 0<=c)),O))
	=>
	(O)


  RULE GenInSetX.55
	(c: a..b) &
	(a<=b) &
	(bnum(a)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(c: INTEGER & 0<=c)),O))
	=>
	(O)


  RULE GenInSetX.56
	(a<=b) &
	(c: a..b) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(c: INTEGER)),O))
	=>
	(O)


  RULE GenInSetX.57
	(c: a..b) &
	(a<=b) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(c: INTEGER)),O))
	=>
	(O)


  RULE GenInSetX.58
	(i|->E: b\/{j|->E}) &
	(btest(i/=j)) &
	(bnum(i)) &
	(bnum(j)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(i|->E: b)),O))
	=>
	(O)


  RULE GenInSetX.59
	(a: b-c) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(a: b & not(a: c))),O))
	=>
	(O)



THEORY GenAllNotEqualX IS



  RULE GenAllNotEqualX.1
	(not(a = b))
	=>
	(not(b = a))



THEORY GenNotEqualX IS



  RULE GenNotEqualX.1
	(not(a = b)) &
	(a = c)
	=>
	(not(b = c))


  RULE GenNotEqualX.2
	(a = c) &
	(not(a = b))
	=>
	(not(b = c))


  RULE GenNotEqualX.3
	(1<=size(s)) &
	(s: seq(e))
	=>
	(not(s = {}))


  RULE GenNotEqualX.4
	(s: seq(e)) &
	(1<=size(s))
	=>
	(not(s = {}))


  RULE GenNotEqualX.5
	(a: b) &
	(not(c: b))
	=>
	(not(a = c))


  RULE GenNotEqualX.6
	(not(c: b)) &
	(a: b)
	=>
	(not(a = c))


  RULE GenNotEqualX.7
	(not(card(a) = 0)) &
	(a: FIN(b))
	=>
	(not(a = {}))


  RULE GenNotEqualX.8
	(a: FIN(b)) &
	(not(card(a) = 0))
	=>
	(not(a = {}))


  RULE GenNotEqualX.9
	(not(1<=card(a))) &
	(a: FIN(b))
	=>
	(a = {})


  RULE GenNotEqualX.10
	(a: FIN(b)) &
	(not(1<=card(a)))
	=>
	(a = {})


  RULE GenNotEqualX.11
	(not(b: a)) &
	(not(b..c/\a = {}))
	=>
	(not(b+1..c/\a = {}))


  RULE GenNotEqualX.12
	(not(b..c/\a = {})) &
	(not(b: a))
	=>
	(not(b+1..c/\a = {}))


  RULE GenNotEqualX.13
	(not(c: a)) &
	(not(b..c/\a = {}))
	=>
	(not(b..c-1/\a = {}))


  RULE GenNotEqualX.14
	(not(b..c/\a = {})) &
	(not(c: a))
	=>
	(not(b..c-1/\a = {}))


  RULE GenNotEqualX.15
	(not(a/\b = {}))
	=>
	(not(a = {})) &
	(not(b = {}))


  RULE GenNotEqualX.16
	(3<=size(a->s))
	=>
	(not(s = {}))


  RULE GenNotEqualX.17
	(2<=size(a->s))
	=>
	(not(s = {}))


  RULE GenNotEqualX.18
	(not(first(a->s) = b))
	=>
	(not(a = b))


  RULE GenNotEqualX.19
	(a+1<=b)
	=>
	(not(a = b))


  RULE GenNotEqualX.20
	(not(a-b = {}))
	=>
	(not(a = {})) &
	(not(a = b))



THEORY GenNotInSetX IS



  RULE GenNotInSetX.1
	(not(a = c)) &
	(not(a: b-{c}))
	=>
	(not(a: b))


  RULE GenNotInSetX.2
	(not(a: b-{c})) &
	(not(a = c))
	=>
	(not(a: b))


  RULE GenNotInSetX.3
	(not(a: b)) &
	(b = c)
	=>
	(not(a: c))


  RULE GenNotInSetX.4
	(b = c) &
	(not(a: b))
	=>
	(not(a: c))


  RULE GenNotInSetX.5
	(not(a: b)) &
	(c = b)
	=>
	(not(a: c))


  RULE GenNotInSetX.6
	(c = b) &
	(not(a: b))
	=>
	(not(a: c))


  RULE GenNotInSetX.7
	(c: b) &
	(a/\b = {})
	=>
	(not(c: a))


  RULE GenNotInSetX.8
	(a/\b = {}) &
	(c: b)
	=>
	(not(c: a))


  RULE GenNotInSetX.9
	(c: a) &
	(a/\b = {})
	=>
	(not(c: b))


  RULE GenNotInSetX.10
	(a/\b = {}) &
	(c: a)
	=>
	(not(c: b))


  RULE GenNotInSetX.11
	(b: POW(c)) &
	(not(a: c))
	=>
	(not(a: b))


  RULE GenNotInSetX.12
	(not(a: c)) &
	(b: POW(c))
	=>
	(not(a: b))


  RULE GenNotInSetX.13
	(a<=b) &
	(a..b/\c = {})
	=>
	(not(b: c))


  RULE GenNotInSetX.14
	(a..b/\c = {}) &
	(a<=b)
	=>
	(not(b: c))


  RULE GenNotInSetX.15
	(a<=b) &
	(a..b/\c = {})
	=>
	(not(a: c))


  RULE GenNotInSetX.16
	(a..b/\c = {}) &
	(a<=b)
	=>
	(not(a: c))


  RULE GenNotInSetX.17
	(not(a: b\/c))
	=>
	(not(a: b)) &
	(not(a: c))


  RULE GenNotInSetX.18
	(not(f(a) = b))
	=>
	(not(a: f~[{b}]))



THEORY GenAllOrderX IS



  RULE GenAllOrderX.1
	(a: FIN(b))
	=>
	(0<=card(a))


  RULE GenAllOrderX.2
	(a: FIN(b)) &
	(not(a = {}))
	=>
	(1<=card(a))


  RULE GenAllOrderX.3
	(not(a = {})) &
	(a: FIN(b))
	=>
	(1<=card(a))



THEORY GenOrderX IS



  RULE GenOrderX.1
	(s: seq(a)) &
	(n: dom(s))
	=>
	(1<=n) &
	(n<=size(s))


  RULE GenOrderX.2
	(n: dom(s)) &
	(s: seq(a))
	=>
	(1<=n) &
	(n<=size(s))


  RULE GenOrderX.3
	(s: seq(a)) &
	(not(s = {}))
	=>
	(1<=size(s))


  RULE GenOrderX.4
	(not(s = {})) &
	(s: seq(a))
	=>
	(1<=size(s))


  RULE GenOrderX.5
	(s: seq(a)) &
	(1<=b) &
	(b<=size(s))
	=>
	(s(b): a)


  RULE GenOrderX.6
	(b<=size(s)) &
	(1<=b) &
	(s: seq(a))
	=>
	(s(b): a)


  RULE GenOrderX.7
	(1<=b) &
	(b<=size(s)) &
	(s: seq(a))
	=>
	(s(b): a)


  RULE GenOrderX.8
	(2<=size(tail(s)))
	=>
	(3<=size(s))


  RULE GenOrderX.9
	(a<=b) &
	(b<=c) &
	(bnot(band(bnum(a),bnum(c))))
	=>
	(a<=c)


  RULE GenOrderX.10
	(b<=c) &
	(a<=b) &
	(bnot(band(bnum(a),bnum(c))))
	=>
	(a<=c)


  RULE GenOrderX.11
	(a<=b) &
	(b+1<=c) &
	(btest(b/=c))
	=>
	(a+1<=c)


  RULE GenOrderX.12
	(b+1<=c) &
	(btest(b/=c)) &
	(a<=b)
	=>
	(a+1<=c)


  RULE GenOrderX.13
	(a<=b) &
	(c+1<=a)
	=>
	(c+1<=b)


  RULE GenOrderX.14
	(c+1<=a) &
	(a<=b)
	=>
	(c+1<=b)


  RULE GenOrderX.15
	(a+1<=b) &
	(b+1<=c)
	=>
	(a+1<=c)


  RULE GenOrderX.16
	(b+1<=c) &
	(a+1<=b)
	=>
	(a+1<=c)


  RULE GenOrderX.17
	(not(n = 0)) &
	(n: INTEGER) &
	(0<=n)
	=>
	(1<=n)


  RULE GenOrderX.18
	(n: INTEGER) &
	(0<=n) &
	(not(n = 0))
	=>
	(1<=n)


  RULE GenOrderX.19
	(not(a = {})) &
	(a: POW(x..y))
	=>
	(x<=min(a))


  RULE GenOrderX.20
	(a: POW(x..y)) &
	(not(a = {}))
	=>
	(x<=min(a))


  RULE GenOrderX.21
	(not(a = {})) &
	(a: POW(x..y))
	=>
	(max(a)<=y)


  RULE GenOrderX.22
	(a: POW(x..y)) &
	(not(a = {}))
	=>
	(max(a)<=y)


  RULE GenOrderX.23
	(a<=min(b)) &
	(b: FIN(s)) &
	(not(b = {}))
	=>
	(a<=max(b))


  RULE GenOrderX.24
	(a+1<=b)
	=>
	(a<=b)


  RULE GenOrderX.25
	(btest(2<1))
	=>
	(__blankrule)


  RULE GenOrderX.26
	(a: INTEGER) &
	(0<=a) &
	(not(a = 0))
	=>
	(1<=a)


  RULE GenOrderX.27
	(not(a..b = {}))
	=>
	(a<=b)


  RULE GenOrderX.28
	(n+p+1<=m+p)
	=>
	(n+1<=m)


  RULE GenOrderX.29
	(a-b+1<=c) &
	(b<=a)
	=>
	(a+1<=c+b)


  RULE GenOrderX.30
	(a+1<=b-c) &
	(c<=b)
	=>
	(a+c+1<=b)


  RULE GenOrderX.31
	(a+b<=c) &
	(a: INTEGER) &
	(0<=a) &
	(b: INTEGER) &
	(0<=b)
	=>
	(a<=c) &
	(b<=c)


  RULE GenOrderX.32
	(a: INTEGER) &
	(0<=a) &
	(a+b<=c) &
	(b: INTEGER) &
	(0<=b)
	=>
	(a<=c) &
	(b<=c)


  RULE GenOrderX.33
	(b: INTEGER) &
	(0<=b) &
	(a+b<=c) &
	(a: INTEGER) &
	(0<=a)
	=>
	(a<=c) &
	(b<=c)



THEORY GenObvPredicateX IS



  RULE GenObvPredicateX.1
	(a) &
	(a => b) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(b)),O))
	=>
	(O)


  RULE GenObvPredicateX.2
	(a => b) &
	(a) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(b)),O))
	=>
	(O)


  RULE GenObvPredicateX.3
	(a = a => b) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(b)),O))
	=>
	(O)


  RULE GenObvPredicateX.4
	(a = b) &
	(b = a => p) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(p)),O))
	=>
	(O)


  RULE GenObvPredicateX.5
	(b = a => p) &
	(a = b) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(p)),O))
	=>
	(O)


  RULE GenObvPredicateX.6
	(not(a = b)) &
	(not(b = a) => p) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(p)),O))
	=>
	(O)


  RULE GenObvPredicateX.7
	(not(b = a) => p) &
	(not(a = b)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(p)),O))
	=>
	(O)


  RULE GenObvPredicateX.8
	(not(b)) &
	(a => b) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(not(a))),O))
	=>
	(O)


  RULE GenObvPredicateX.9
	(a => b) &
	(not(b)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(not(a))),O))
	=>
	(O)


  RULE GenObvPredicateX.10
	(not(b)) &
	(a => X & x) &
	(bsearch(b,(X & x),r)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(not(a))),O))
	=>
	(O)


  RULE GenObvPredicateX.11
	(a => X & x) &
	(not(b)) &
	(bsearch(b,(X & x),r)) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(not(a))),O))
	=>
	(O)


  RULE GenObvPredicateX.12
	(!x.(a => b)) &
	(c) &
	(bmatch(x,a,c,e)) &
	(bguard((SUB;RES): bresult([x:=e]b),B)) &
	(bnot(band(bsubfrm(P,btrue,B,Q),bmatch(x,a,P,E)))) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(B)),O))
	=>
	(O)


  RULE GenObvPredicateX.13
	(c) &
	(!x.(a => b)) &
	(bmatch(x,a,c,e)) &
	(bguard((SUB;RES): bresult([x:=e]b),B)) &
	(bnot(band(bsubfrm(P,btrue,B,Q),bmatch(x,a,P,E)))) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(B)),O))
	=>
	(O)


  RULE GenObvPredicateX.14
	(!x.(a => b)) &
	(not(c)) &
	(bmatch(x,b,c,e)) &
	(bguard((SUB;RES): bresult([x:=e]not(a)),not(A))) &
	(bnot(band(bsubfrm(P,btrue,A,Q),bmatch(x,b,P,E)))) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(not(A))),O))
	=>
	(O)


  RULE GenObvPredicateX.15
	(not(c)) &
	(!x.(a => b)) &
	(bmatch(x,b,c,e)) &
	(bguard((SUB;RES): bresult([x:=e]not(a)),not(A))) &
	(bnot(band(bsubfrm(P,btrue,A,Q),bmatch(x,b,P,E)))) &
	(bguard((SimplifyX~;FLAT;RES): bresult(bflat(not(A))),O))
	=>
	(O)


  RULE GenObvPredicateX.16
	(not(a+1<=b))
	=>
	(b<=a)


  RULE GenObvPredicateX.17
	(not(a<=b))
	=>
	(b+1<=a)


  RULE GenObvPredicateX.18
	(not(a: {x}))
	=>
	(not(a = x))


  RULE GenObvPredicateX.19
	(not(a: SET(x).P)) &
	(bguard((SUB;RES): bresult([x:=a]not(P)),R)) &
	(bnot(bpattern(R,[y:=z]S)))
	=>
	(R)


  RULE GenObvPredicateX.20
	(not(a: x\/{y}))
	=>
	(not(a: x)) &
	(not(a: {y}))


  RULE GenObvPredicateX.21
	(c: a..b) &
	(bnot(band(bnum(c),bnum(b)))) &
	(SOLVEPRED(c<=b,C<=B,H,0))
	=>
	(__spe(H)) &
	(C<=B) &
	(c<=b)


  RULE GenObvPredicateX.22
	(c: a..b) &
	(bnot(band(bnum(c),bnum(a)))) &
	(SOLVEPRED(a<=c,A<=C,H,0))
	=>
	(__spe(H)) &
	(A<=C) &
	(a<=c)


  RULE GenObvPredicateX.23
	(0+a<=b)
	=>
	(a<=b)


  RULE GenObvPredicateX.24
	(a+0<=b)
	=>
	(a<=b)


  RULE GenObvPredicateX.25
	(0+a = b)
	=>
	(a = b)


  RULE GenObvPredicateX.26
	(a+0 = b)
	=>
	(a = b)


  RULE GenObvPredicateX.27
	(not(b = a)) &
	(a<=b) &
	(bguard(RaiseOrderX: RaiseOrderG(a,b),H))
	=>
	(H)


  RULE GenObvPredicateX.28
	(a<=b) &
	(not(b = a)) &
	(bguard(RaiseOrderX: RaiseOrderG(a,b),H))
	=>
	(H)


  RULE GenObvPredicateX.29
	(not(a = b)) &
	(a<=b) &
	(bguard(RaiseOrderX: RaiseOrderG(a,b),H))
	=>
	(H)


  RULE GenObvPredicateX.30
	(a<=b) &
	(not(a = b)) &
	(bguard(RaiseOrderX: RaiseOrderG(a,b),H))
	=>
	(H)


  RULE GenObvPredicateX.31
	(1<=n) &
	(not(n = 1))
	=>
	(2<=n)


  RULE GenObvPredicateX.32
	(not(n = 1)) &
	(1<=n)
	=>
	(2<=n)


  RULE GenObvPredicateX.33
	(a: {x})
	=>
	(a = x)


  RULE GenObvPredicateX.34
	(a: SET(x).P) &
	(x\a)
	=>
	([x:=a]P)


  RULE GenObvPredicateX.35
	(btrue => b)
	=>
	(b)


  RULE GenObvPredicateX.36
	(a = bool(b)) &
	(a = FALSE)
	=>
	(not(b))


  RULE GenObvPredicateX.37
	(a = FALSE) &
	(a = bool(b))
	=>
	(not(b))


  RULE GenObvPredicateX.38
	(a = bool(b)) &
	(a = TRUE)
	=>
	(b)


  RULE GenObvPredicateX.39
	(a = TRUE) &
	(a = bool(b))
	=>
	(b)


  RULE GenObvPredicateX.40
	(TRUE = bool(b))
	=>
	(b)


  RULE GenObvPredicateX.41
	(bool(b) = TRUE)
	=>
	(b)


  RULE GenObvPredicateX.42
	(FALSE = bool(b))
	=>
	(not(b))


  RULE GenObvPredicateX.43
	(bool(b) = FALSE)
	=>
	(not(b))


  RULE GenObvPredicateX.44
	(btest(2<1))
	=>
	(__blankrule)


  RULE GenObvPredicateX.45
	(not(a: INTEGER & 0<=a))
	=>
	(a: INTEGER) &
	(a+1<=0)


  RULE GenObvPredicateX.46
	(not(-(-a): INTEGER & 0<= -(-a)))
	=>
	(a: INTEGER) &
	(a+1<=0)


  RULE GenObvPredicateX.47
	(not(a: {x}) => c)
	=>
	(not(a = x) => c)


  RULE GenObvPredicateX.48
	(a<=b) &
	(b<=a)
	=>
	(a = b)


  RULE GenObvPredicateX.49
	(s: iseq(a))
	=>
	(s: seq(a)) &
	(s~: a +-> NATURAL-{0})


  RULE GenObvPredicateX.50
	(f: a >->> b)
	=>
	(f: a >+> b) &
	(dom(f) = a) &
	(ran(f) = b)


  RULE GenObvPredicateX.51
	(f: a>+>>b)
	=>
	(f: a >+> b) &
	(ran(f) = b)


  RULE GenObvPredicateX.52
	(f: a >-> b)
	=>
	(f: a >+> b) &
	(dom(f) = a)


  RULE GenObvPredicateX.53
	(f: a -->> b)
	=>
	(f: a +-> b) &
	(dom(f) = a) &
	(ran(f) = b)


  RULE GenObvPredicateX.54
	(f: a +->> b)
	=>
	(f: a +-> b) &
	(ran(f) = b)


  RULE GenObvPredicateX.55
	(f: a --> b)
	=>
	(f: a +-> b) &
	(dom(f) = a)


  RULE GenObvPredicateX.56
	(f: a >+> b)
	=>
	(f: a +-> b) &
	(f~: b +-> a)


  RULE GenObvPredicateX.57
	(a: b/\c)
	=>
	(a: b) &
	(a: c)


  RULE GenObvPredicateX.58
	(not(a: b\/c))
	=>
	(not(a: b)) &
	(not(a: c))


  RULE GenObvPredicateX.59
	(a: b-c)
	=>
	(a: b) &
	(not(a: c))


  RULE GenObvPredicateX.60
	(a: POW({x}))
	=>
	(not(a = {}) => a = {x})


  RULE GenObvPredicateX.61
	(a: INT)
	=>
	(a: INTEGER) &
	(a<=maxint) &
	(minint<=a)


  RULE GenObvPredicateX.62
	(a: NAT)
	=>
	(a: INTEGER) &
	(0<=a) &
	(a<=maxint)


  RULE GenObvPredicateX.63
	(not(not(a)))
	=>
	(a)



THEORY GenPredicateX IS



  RULE GenPredicateX.1
	(not(a & b))
	=>
	(a => not(b)) &
	(b => not(a))


  RULE GenPredicateX.2
	(not(a & x: {b}))
	=>
	(a => not(x = b)) &
	(x = b => not(a))


  RULE GenPredicateX.3
	(not(a & x: {b}\/{c}))
	=>
	(a => not(x: {b}\/{c})) &
	(x: {b}\/{c} => not(a))


  RULE GenPredicateX.4
	(not(a & x: SET(y).P))
	=>
	(a => not(x: SET(y).P)) &
	(x: SET(y).P => not(a))


  RULE GenPredicateX.5
	(not(x: n..p))
	=>
	(n<=x => p+1<=x)


  RULE GenPredicateX.6
	(not(x: a\/b))
	=>
	(not(x: a)) &
	(not(x: b))


  RULE GenPredicateX.7
	(not(a: POW({x}))) &
	(bgetallhyp(H)) &
	(bfresh(zz,H,z))
	=>
	(#z.(z: a & not(z = x)))


  RULE GenPredicateX.8
	(not(a: POW(x)\/{y})) &
	(bgetallhyp(H)) &
	(bfresh(zz,H,z))
	=>
	(#z.(z: a & not(z: x) & not(z = y)))


  RULE GenPredicateX.9
	(not(a: POW(SET(x).P))) &
	(bfresh(x,not(a: POW(SET(x).P)),y))
	=>
	(#y.(y: a & [x:=y]not(P)))


  RULE GenPredicateX.10
	(s: seq(a)) &
	(not(s = {}))
	=>
	(1<=size(s))


  RULE GenPredicateX.11
	(not(s = {})) &
	(s: seq(a))
	=>
	(1<=size(s))


  RULE GenPredicateX.12
	(a: x\/{y})
	=>
	(not(a: x) => a = y) &
	(not(a = y) => a: x)


  RULE GenPredicateX.13
	(not(a: x\/{y}) => c)
	=>
	(not(a: x) => (not(a = y) => c))


  RULE GenPredicateX.14
	(!x.(a => b & c))
	=>
	(!x.(a => b)) &
	(!x.(a => c))


  RULE GenPredicateX.15
	(a => b & c)
	=>
	(a => b) &
	(a => c)


  RULE GenPredicateX.16
	(a => (not(b) => c))
	=>
	(a => (not(b) => c)) &
	(not(b) => (a => c)) &
	(a => (not(c) => b)) &
	(not(c) => (a => b)) &
	(not(b) => (not(c) => not(a))) &
	(not(c) => (not(b) => not(a)))


  RULE GenPredicateX.17
	(a => (b => c) & (c => b))
	=>
	(a => (b => c)) &
	(b => (a => c)) &
	(a => (c => b)) &
	(c => (a => c))


  RULE GenPredicateX.18
	(not(a) => b => c)
	=>
	(a => c) &
	(b => c)


  RULE GenPredicateX.19
	(a => b => c)
	=>
	(not(a) => c) &
	(b => c)


  RULE GenPredicateX.20
	((a => b) & (b => a) => c)
	=>
	(not(a) => (b => a => c)) &
	(not(b) => (not(a) => c)) &
	(b => (b => a => c)) &
	(a => (b => c))


  RULE GenPredicateX.21
	(not(not(a) => b) => c)
	=>
	(not(a) => (not(b) => c)) &
	(not(b) => (not(a) => c))


  RULE GenPredicateX.22
	(not(a & b) => c)
	=>
	(not(a) => c) &
	(not(b) => c)


  RULE GenPredicateX.23
	(not(a => b) => c)
	=>
	(a => (not(b) => c)) &
	(not(b) => (a => c))


  RULE GenPredicateX.24
	((not(a) => b) & (b => not(a)) => c)
	=>
	(a => (not(b) => c)) &
	(not(a) => (b => c)) &
	(b => (not(a) => c)) &
	(not(b) => (a => c))


  RULE GenPredicateX.25
	(not(a = b))
	=>
	(not(b = a))


  RULE GenPredicateX.26
	(not(x: s)) &
	(f: s <-> t)
	=>
	(not(x: dom(f)))


  RULE GenPredicateX.27
	(f: s +-> t)
	=>
	(f: s <-> t)


  RULE GenPredicateX.28
	(r: s <-> t)
	=>
	(dom(r): POW(s)) &
	(ran(r): POW(t))


  RULE GenPredicateX.29
	(r~: s <-> t)
	=>
	(r: t <-> s)


  RULE GenPredicateX.30
	(s: seq(a))
	=>
	(s: 1..size(s) --> a) &
	(size(s): NATURAL)


  RULE GenPredicateX.31
	(s: 1..n +-> a) &
	(dom(s) = 1..n) &
	(0<=n)
	=>
	(s: seq(a)) &
	(size(s) = n)


  RULE GenPredicateX.32
	(f<|m: POW(l)) &
	(x: m)
	=>
	(f<|{x}: POW(l))


  RULE GenPredicateX.33
	(x: m) &
	(f<|m: POW(l))
	=>
	(f<|{x}: POW(l))


  RULE GenPredicateX.34
	(x: m) &
	(m|>f: POW(l))
	=>
	({x}|>f: POW(l))


  RULE GenPredicateX.35
	(m|>f: POW(l)) &
	(x: m)
	=>
	({x}|>f: POW(l))


  RULE GenPredicateX.36
	(x: s~[{p}]) &
	(s: a +-> b)
	=>
	(s(x) = p)



THEORY OptimGenAnyX IS



  RULE OptimGenAnyX.1
	(bguard((CalculTailleX;ARI;RES): CalculTailleG(GenAnyX),T)) &
	(bguard((SUB~;RES): bresult([S]Q),R)) &
	(bguard((FLAT~;RULE): bcrelr(GenAnyX,(bflat(H & !X.(U & V => Q) & A) => R & bcall1(ForwardRule(GenAny.T))))))
	=>
	(OptimGenAnyGSimple(A,X,U,V,u,v,Q,S,H))


  RULE OptimGenAnyX.2
	(bguard((CalculTailleX;ARI;RES): CalculTailleG(GenAnyX),T)) &
	(bguard((FLAT~;RULE): bcrelr(GenAnyX,(bflat(H & !X.(U & V => Q) & A & bguard((SUB~;RES): bresult([S](u & v)),Y) & bguard(_Empty: Y) & bguard((SUB~;RES): bresult([S]Q),R)) => R & bcall1(ForwardRule(GenAny.T))))))
	=>
	(OptimGenAnyG(A,X,U,V,u,v,Q,S,H))



THEORY _Empty IS



  RULE _Empty.1
	(binhyp(p))
	=>
	(p)