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

FORWARD THEORIES

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)