﻿-------------------------------------------------------------------
*
* 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.
*
-------------------------------------------------------------------


-------------------------------------------------------------------
THEORY SimplifyX IS

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

  RULE SimplifyX.2
	rewrite  (a => bfalse)  in  (not(a))
		not if (a) is a litteral string

  RULE SimplifyX.3
	always rewrite (bfalse => a) in (btrue)

  RULE SimplifyX.4
	always rewrite (a => btrue) in (btrue)

  RULE SimplifyX.5
	always rewrite (btrue => a) in (a)

  RULE SimplifyX.6
	rewrite  (#x.a)  in  (a)
		prove (bvrb(x))
		if (x) is a variable list whith no free occurences in (a)

  RULE SimplifyX.7
	rewrite  (#x.(a & b))  in  (#x.a & b)
		prove (bvrb(x))
		if (x) is a variable list whith no free occurences in (b)

  RULE SimplifyX.8
	rewrite  (#x.(a & b))  in  (a & #x.b)
		prove (bvrb(x))
		if (x) is a variable list whith no free occurences in (a)

  RULE SimplifyX.9
	rewrite  (!(L,l).(P & p => S))  in  (!M.(Q => T))
		if list (P & p) contains (y = x)
		if list (L,l) contains (x)
		if (x) is a variable list whith no free occurences in (y)
		not if (y) matches on (A,a)
		if tactic (SUB~;RES) proves (bresult([x:=y](P & p => S))) and gives result (Q => T)

  RULE SimplifyX.10
	rewrite  (!(L,l).(P & p => S))  in  (!M.(Q => T))
		if list (P & p) contains (x = y)
		if list (L,l) contains (x)
		if (x) is a variable list whith no free occurences in (y)
		not if (y) matches on (A,a)
		if tactic (SUB~;RES) proves (bresult([x:=y](P & p => S))) and gives result (Q => T)

  RULE SimplifyX.11
	rewrite  (!L.(P & p => S))  in  (Q => T)
		if list (P & p) contains (y = L)
		if (L) is a variable list whith no free occurences in (y)
		if tactic (SUB;RES) proves (bresult([L:=y]!OK.OK)) and gives result (!OK.OK)
		if tactic (SUB~;RES) proves (bresult([L:=y](P & p => S))) and gives result (Q => T)

  RULE SimplifyX.12
	rewrite  (!L.(P & p => S))  in  (Q => T)
		if list (P & p) contains (L = y) and gives (u) without this element
		if (L) is a variable list whith no free occurences in (y)
		if tactic (SUB;RES) proves (bresult([L:=y]!OK.OK)) and gives result (!OK.OK)
		if tactic (SUB~;RES) proves (bresult([L:=y](u => S))) and gives result (Q => T)

  RULE SimplifyX.13
	rewrite  (!x.(p => !y.(q => r)))  in  (!Z.(p & Q => R))
		if (Y) is a fresh variable in (x,p,q,r)
		if tactic (FLAT~;RES) proves (bresult(bflat(x,Y))) and gives result (Z)
		if tactic (SUB~;RES) proves (bresult([y:=Y](q => r))) and gives result (Q => R)

  RULE SimplifyX.14
	rewrite  (!x.(p => q))  in  (c => !x.(r => q))
		prove (bvrb(x))
		if (p) matches on (u & v)
		if list (p) contains (c) and gives (r) without this element
		if (x) is a variable list whith no free occurences in (c)

  RULE SimplifyX.15
	rewrite  (!x.a)  in  (a)
		prove (bvrb(x))
		if (x) is a variable list whith no free occurences in (a)

  RULE SimplifyX.16
	rewrite  (!x.(a or b))  in  (!x.a or b)
		if (x) is a variable list whith no free occurences in (b)

  RULE SimplifyX.17
	rewrite  (!x.(a or b))  in  (a or !x.b)
		if (x) is a variable list whith no free occurences in (a)

  RULE SimplifyX.18
	rewrite  (!x.(not(a) => b))  in  (not(!x.a) => b)
		prove (bvrb(x))
		if (x) is a variable list whith no free occurences in (b)

  RULE SimplifyX.19
	rewrite  (!x.(not(a) => b))  in  (not(!x.b) => a)
		prove (bvrb(x))
		if (x) is a variable list whith no free occurences in (a)

  RULE SimplifyX.20
	always rewrite (!x.(a & b)) in (!x.a & !x.b)

  RULE SimplifyX.21
	rewrite  (m+p<=n+p)  in  (m<=n)
		if (p) is a numerical constant

  RULE SimplifyX.22
	rewrite  (m+p<=n+p)  in  (m<=n)
		if (p: INTEGER) is in hypothesis
		if (p) does not contain non-free variables in replacement

  RULE SimplifyX.23
	rewrite  (m-p<=n-p)  in  (m<=n)
		if (p) is a numerical constant

  RULE SimplifyX.24
	rewrite  (m-p<=n-p)  in  (m<=n)
		if (p: INTEGER) is in hypothesis
		if (p) does not contain non-free variables in replacement

  RULE SimplifyX.25
	rewrite  (m*p<=n*p)  in  (m<=n)
		if (p>0) is litteraly true

  RULE SimplifyX.26
	rewrite  (m+p = n+p)  in  (m = n)
		if (p) is a numerical constant

  RULE SimplifyX.27
	rewrite  (m+p = n+p)  in  (m = n)
		if (p: INTEGER) is in hypothesis
		if (p) does not contain non-free variables in replacement

  RULE SimplifyX.28
	rewrite  (m-p = n-p)  in  (m = n)
		if (p) is a numerical constant

  RULE SimplifyX.29
	rewrite  (m-p = n-p)  in  (m = n)
		if (p: INTEGER) is in hypothesis
		if (p) does not contain non-free variables in replacement

  RULE SimplifyX.30
	rewrite  (m*p = n*p)  in  (m = n)
		if (p>0) is litteraly true

  RULE SimplifyX.31
	always rewrite (bool(P) = FALSE) in (not(P))

  RULE SimplifyX.32
	always rewrite (bool(P) = TRUE) in (P)

  RULE SimplifyX.33
	always rewrite (FALSE = x) in (x = FALSE)

  RULE SimplifyX.34
	always rewrite (TRUE = x) in (x = TRUE)

  RULE SimplifyX.35
	always rewrite (FALSE = TRUE) in (bfalse)

  RULE SimplifyX.36
	always rewrite (TRUE = FALSE) in (bfalse)

  RULE SimplifyX.37
	always rewrite (TRUE: BOOL) in (btrue)

  RULE SimplifyX.38
	always rewrite (FALSE: BOOL) in (btrue)

  RULE SimplifyX.39
	rewrite  (rec(L)'l)  in  (v)
		if tactic (FindLabX) proves (__fl(rec(L) | l)) and gives result (v)

  RULE SimplifyX.40
	rewrite  (r: struct(T))  in  (L)
		if tactic (LabelRecX;FLAT) proves (__labrec(r | struct(T))) and gives result (L)

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

  RULE SimplifyX.42
	always rewrite (x,y: A*B) in (x: A & y: B)

  RULE SimplifyX.43
	rewrite  ([a]: seq(E))  in  (a: E)
		not if (a) matches on (u,v)

  RULE SimplifyX.44
	always rewrite ([a,b]: seq(E)) in (b: E & [a]: seq(E))

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

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

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

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

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

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

  RULE SimplifyX.51
	always rewrite (f: a >+> b) in (f: a +-> b & f~: b +-> a)

  RULE SimplifyX.52
	always rewrite (a: b/\c) in (a: b & a: c)

  RULE SimplifyX.53
	always rewrite (not(a: b\/c)) in (not(a: b) & not(a: c))

  RULE SimplifyX.54
	always rewrite (a: b-c) in (a: b & not(a: c))

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

  RULE SimplifyX.56
	rewrite  (a: POW(SET(x).P))  in  (!y.(y: a => [x:=y]P))
		prove (bvrb(x))
		if (y) is a fresh variable in (a: POW(SET(x).P))

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

  RULE SimplifyX.58
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

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

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

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

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

  RULE SimplifyX.63
	rewrite  (a: {x})  in  (a = x)
		not if (x) matches on (y,z)

  RULE SimplifyX.64
	rewrite  (a: SET(x).P)  in  (R)
		if tactic (SUB;RES) proves (bresult([x:=a]P)) and gives result (R)
		not if (R) matches on ([y:=z]S)

  RULE SimplifyX.65
	always rewrite ({x}: POW(a)) in (x: a)

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

  RULE SimplifyX.67
	rewrite  (SET(x).P: POW(a))  in  (!y.([x:=y]P => y: a))
		prove (bvrb(x))
		if (y) is a fresh variable in (SET(x).P: POW(a))

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

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

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

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

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

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

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

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

  RULE SimplifyX.76
	rewrite  (a/\SET(x).P = {})  in  (!y.(y: a => not([x:=y]P)))
		prove (bvrb(x))
		if (y) is a fresh variable in (a/\SET(x).P = {})

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

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

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

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

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

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

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

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

  RULE SimplifyX.85
	rewrite  (SET(x).(P & Q) = {})  in  (!x.(x: a => not(R)))
		prove (bvrb(x))
		if list (P & Q) contains (x: a) and gives (R) without this element

  RULE SimplifyX.86
	rewrite  (SET(x).(P & Q) = {})  in  (!x.(x = a => not(R)))
		prove (bvrb(x))
		if list (P & Q) contains (x = a) and gives (R) without this element

  RULE SimplifyX.87
	always rewrite ({} = a) in (a = {})

  RULE SimplifyX.88
	rewrite  (rec(L) = rec(M))  in  (R)
		if tactic (RecEqualityX~;RES) proves (rec(L) = rec(M)) and gives result (R)

  RULE SimplifyX.89
	always rewrite (not(not(a))) in (a)

  RULE SimplifyX.90
	rewrite  (a<=b)  in  (btrue)
		if (a<=b) is litteraly true

  RULE SimplifyX.91
	rewrite  (a<=b)  in  (bfalse)
		if (b<a) is litteraly true

  RULE SimplifyX.92
	rewrite  (a = b)  in  (bfalse)
		if (a) is a numerical constant
		if (b) is a numerical constant
		if (b/=a) is litteraly true

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

  RULE SimplifyX.94
	always rewrite (not(a or b)) in (not(a) & not(b))

  RULE SimplifyX.95
	always rewrite (not(btrue)) in (bfalse)

  RULE SimplifyX.96
	always rewrite (not(bfalse)) in (btrue)

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

  RULE SimplifyX.98
	always rewrite (a or btrue) in (btrue)

  RULE SimplifyX.99
	always rewrite (btrue or a) in (btrue)

  RULE SimplifyX.100
	always rewrite (a or bfalse) in (a)

  RULE SimplifyX.101
	always rewrite (bfalse or a) in (a)

  RULE SimplifyX.102
	always rewrite (a or a) in (a)

  RULE SimplifyX.103
	always rewrite (a & bfalse) in (bfalse)

  RULE SimplifyX.104
	always rewrite (bfalse & a) in (bfalse)

  RULE SimplifyX.105
	always rewrite (a & btrue) in (a)

  RULE SimplifyX.106
	always rewrite (btrue & a) in (a)

  RULE SimplifyX.107
	always rewrite (a & bfalse & bfalse) in (bfalse)

  RULE SimplifyX.108
	always rewrite (bfalse & a & bfalse) in (bfalse)

  RULE SimplifyX.109
	always rewrite (bfalse & bfalse & a) in (bfalse)

  RULE SimplifyX.110
	always rewrite (a & btrue & btrue) in (a)

  RULE SimplifyX.111
	always rewrite (btrue & a & btrue) in (a)

  RULE SimplifyX.112
	always rewrite (btrue & btrue & a) in (a)

  RULE SimplifyX.113
	always rewrite (x = x) in (btrue)

  RULE SimplifyX.114
	always rewrite (a & x = x) in (a)

  RULE SimplifyX.115
	always rewrite (x = x & a) in (a)

  RULE SimplifyX.116
	always rewrite (a & x = x & y = y) in (a)

  RULE SimplifyX.117
	always rewrite (x = x & a & y = y) in (a)

  RULE SimplifyX.118
	always rewrite (x = x & y = y & a) in (a)

  RULE SimplifyX.119
	rewrite  (i|->E = j|->E)  in  (bfalse)
		if (i) is a numerical constant
		if (j) is a numerical constant
		if (i/=j) is litteraly true

  RULE SimplifyX.120
	rewrite  (not(i|->E = j|->E))  in  (btrue)
		if (i) is a numerical constant
		if (j) is a numerical constant
		if (i/=j) is litteraly true

  RULE SimplifyX.121
	rewrite  (a & i|->E = j|->E)  in  (bfalse)
		if (i) is a numerical constant
		if (j) is a numerical constant
		if (i/=j) is litteraly true

  RULE SimplifyX.122
	rewrite  (i|->E = j|->E & a)  in  (bfalse)
		if (i) is a numerical constant
		if (j) is a numerical constant
		if (i/=j) is litteraly true

  RULE SimplifyX.123
	rewrite  (a & not(i|->E = j|->E))  in  (a)
		if (i) is a numerical constant
		if (j) is a numerical constant
		if (i/=j) is litteraly true

  RULE SimplifyX.124
	rewrite  (not(i|->E = j|->E) & a)  in  (a)
		if (i) is a numerical constant
		if (j) is a numerical constant
		if (i/=j) is litteraly true

  RULE SimplifyX.125
	always rewrite (a: {}) in (bfalse)

  RULE SimplifyX.126
	always rewrite ({b} = {}) in (bfalse)


-------------------------------------------------------------------
THEORY RecEqualityX IS

  RULE RecEqualityX.1
	if goal is (Goal(l>>x | l>>y | R))
		prove (bresult(R & x = y))
		then initial goal is proved

  RULE RecEqualityX.2
	if goal is (Goal(L,l>>x | M,l>>y | R))
		prove (Goal(L | M | R & x = y))
		then initial goal is proved

  RULE RecEqualityX.3
	if goal is (rec(l>>x) = rec(l>>y))
		prove (bresult(x = y))
		then initial goal is proved

  RULE RecEqualityX.4
	if goal is (rec(L,l>>x) = rec(M,l>>y))
		prove (Goal(L | M | x = y))
		then initial goal is proved


-------------------------------------------------------------------
THEORY FindLabX IS

  RULE FindLabX.1
	goal (__fl(rec(x>>v) | l)) is always TRUE

  RULE FindLabX.2
	if goal is (__fl(rec(l>>v) | l))
		proves (bresult(v)) with tactic (RES)
		then initial goal is proved

  RULE FindLabX.3
	if goal is (__fl(rec(L,x>>v) | l))
		prove (__fl(rec(L) | l))
		then initial goal is proved

  RULE FindLabX.4
	if goal is (__fl(rec(L,l>>v) | l))
		proves (bresult(v)) with tactic (RES)
		then initial goal is proved


-------------------------------------------------------------------
THEORY LabelRecX IS

  RULE LabelRecX.1
	if goal is (__labrec1(r | struct(x>>E) | P))
		proves (bresult(bflat(P & r'x: E))) with tactic (FLAT;RES)
		then initial goal is proved

  RULE LabelRecX.2
	if goal is (__labrec1(r | struct(T,x>>E) | P))
		prove (__labrec1(r | struct(T) | bflat(P & r'x: E)))
		then initial goal is proved

  RULE LabelRecX.3
	if goal is (__labrec(r | struct(x>>E)))
		proves (bresult(r'x: E)) with tactic (RES)
		then initial goal is proved

  RULE LabelRecX.4
	if goal is (__labrec(r | struct(T,x>>E)))
		prove (__labrec1(r | struct(T) | r'x: E))
		then initial goal is proved


-------------------------------------------------------------------
THEORY AssociativityXY IS

  RULE AssociativityXY.1
	rewrite  ((u\/{e})-v)  in  (u-v\/{e})
		if (not(e: v)) is in hypothesis
		if (not(e: v)) does not contain non-free variables in replacement

  RULE AssociativityXY.2
	rewrite  ((u\/v-{a})-w)  in  ((u\/v)-w-{a})
		if (not(a: u)) is in hypothesis
		if (not(a: u)) does not contain non-free variables in replacement

  RULE AssociativityXY.3
	always rewrite (a-{e}-b) in (a-b-{e})

  RULE AssociativityXY.4
	always rewrite (a\/{x}\/b) in (a\/b\/{x})

  RULE AssociativityXY.5
	always rewrite (s;(r;t)) in (s;r;t)

  RULE AssociativityXY.6
	always rewrite (a+(b+c)) in (a+b+c)

  RULE AssociativityXY.7
	always rewrite (a+b+c) in (a+(b+c))

  RULE AssociativityXY.8
	always rewrite (a\/(b\/c)) in (a\/b\/c)

  RULE AssociativityXY.9
	always rewrite (a/\(b/\c)) in (a/\b/\c)

  RULE AssociativityXY.10
	always rewrite (r<+(s<+t)) in (r<+s<+t)


-------------------------------------------------------------------
THEORY CommutativityXY IS

  RULE CommutativityXY.1
	rewrite  (n*p)  in  (p*n)
		if we make a successfull attempt to prove (n: INTEGER) with current prover force
		if (n) does not contain non-free variables in replacement

  RULE CommutativityXY.2
	rewrite  (n*p)  in  (p*n)
		if we make a successfull attempt to prove (p: INTEGER) with current prover force
		if (p) does not contain non-free variables in replacement

  RULE CommutativityXY.3
	always rewrite (not(n = p)) in (not(p = n))

  RULE CommutativityXY.4
	always rewrite (a\/b) in (b\/a)

  RULE CommutativityXY.5
	always rewrite (a/\b) in (b/\a)

  RULE CommutativityXY.6
	always rewrite (n+(m-p)) in (n+m-p)

  RULE CommutativityXY.7
	always rewrite (n-q+p) in (n+p-q)

  RULE CommutativityXY.8
	rewrite  (n*(p*q))  in  (n*p*q)
		if we make a successfull attempt to prove (n: INTEGER) with current prover force
		if (n) does not contain non-free variables in replacement

  RULE CommutativityXY.9
	rewrite  (n*(p*q))  in  (n*p*q)
		if we make a successfull attempt to prove (p: INTEGER) with current prover force
		if (p) does not contain non-free variables in replacement

  RULE CommutativityXY.10
	rewrite  (n*(p*q))  in  (n*p*q)
		if we make a successfull attempt to prove (q: INTEGER) with current prover force
		if (q) does not contain non-free variables in replacement

  RULE CommutativityXY.11
	always rewrite (a-c/\b) in ((a/\b)-c)

  RULE CommutativityXY.12
	always rewrite (a\/b\/c) in (a\/c\/b)

  RULE CommutativityXY.13
	always rewrite (a/\b/\c) in (a/\c/\b)

  RULE CommutativityXY.14
	always rewrite (u<|(r|>v)) in (u<|r|>v)

  RULE CommutativityXY.15
	always rewrite (u<|(r|>>v)) in (u<|r|>>v)

  RULE CommutativityXY.16
	always rewrite (u<|r|>v) in (u<|(r|>v))

  RULE CommutativityXY.17
	always rewrite (u<<|r|>v) in (u<<|(r|>v))

  RULE CommutativityXY.18
	always rewrite (u<<|(r|>v)) in (u<<|r|>v)

  RULE CommutativityXY.19
	always rewrite (u<<|(r|>>v)) in (u<<|r|>>v)

  RULE CommutativityXY.20
	always rewrite (u<|r|>>v) in (u<|(r|>>v))

  RULE CommutativityXY.21
	always rewrite (u<<|r|>>v) in (u<<|(r|>>v))

  RULE CommutativityXY.22
	always rewrite (a\/b) in (b\/a)

  RULE CommutativityXY.23
	always rewrite (a/\b) in (b/\a)

  RULE CommutativityXY.24
	always rewrite (a\/b/\c) in (a/\c\/(b/\c))

  RULE CommutativityXY.25
	always rewrite (a\/b) in (b\/a)

  RULE CommutativityXY.26
	always rewrite (a\/(b\/c)) in (a\/b\/c)

  RULE CommutativityXY.27
	always rewrite (a/\(b/\c)) in (a/\b/\c)

  RULE CommutativityXY.28
	always rewrite (r<+s<+t) in (r<+(s<+t))


-------------------------------------------------------------------
THEORY SimplifySeqEnuXY IS

  RULE SimplifySeqEnuXY.1
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

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


-------------------------------------------------------------------
THEORY SimplifyBoolXY IS

  RULE SimplifyBoolXY.1
	always rewrite (bool(bfalse)) in (FALSE)

  RULE SimplifyBoolXY.2
	always rewrite (bool(btrue)) in (TRUE)


-------------------------------------------------------------------
THEORY SimplifyExistXY IS

  RULE SimplifyExistXY.1
	rewrite  (#(w,x).(P & R))  in  (#z.[y:=E]U)
		if list (P & R) contains (E = y)
		prove (IWD(expr(E),Z))
		if list (U) contains ((E = y),(P & R)) and gives (Z) without this element
		if (y) is a variable list whith no free occurences in (E)
		if list (w,x) contains (y)
		if tactic (SUB;RES) proves (bresult([y:=E]U)) and gives result (S)
		not if (S) matches on ([a:=b]T)

  RULE SimplifyExistXY.2
	rewrite  (#(w,x).(P & R))  in  (#z.[y:=E]Q)
		if list (P & R) contains (E = y) and gives (Q) without this element
		prove (bgetallhyp(H))
		if pattern (E) found in (H), replaced by toto becomes I, non free vars ?
		if (y) is a variable list whith no free occurences in (E)
		if list (w,x) contains (y) and gives (z) without this element
		if (z) is a variable list whith no free occurences in (E)
		if tactic (SUB;RES) proves (bresult([y:=E]Q)) and gives result (S)
		not if (S) matches on ([a:=b]T)

  RULE SimplifyExistXY.3
	rewrite  (#(w,x).(P & R))  in  (#z.[y:=E]Q)
		if list (P & R) contains (E = y) and gives (Q) without this element
		prove (WD(expr(E),Z))
		if (y) is a variable list whith no free occurences in (E)
		if list (w,x) contains (y) and gives (z) without this element
		if (z) is a variable list whith no free occurences in (E)
		if tactic (SUB;RES) proves (bresult([y:=E]Q)) and gives result (S)
		not if (S) matches on ([a:=b]T)

  RULE SimplifyExistXY.4
	rewrite  (#(w,x).(P & R))  in  (#z.[y:=E]U)
		if list (P & R) contains (y = E)
		prove (IWD(expr(E),Z))
		if list (U) contains ((y = E),(P & R)) and gives (Z) without this element
		if (y) is a variable list whith no free occurences in (E)
		if list (w,x) contains (y)
		if tactic (SUB;RES) proves (bresult([y:=E]U)) and gives result (S)
		not if (S) matches on ([a:=b]T)

  RULE SimplifyExistXY.5
	rewrite  (#(w,x).(P & R))  in  (#z.[y:=E]Q)
		if list (P & R) contains (y = E) and gives (Q) without this element
		prove (bgetallhyp(H))
		if pattern (E) found in (H), replaced by toto becomes I, non free vars ?
		if (y) is a variable list whith no free occurences in (E)
		if list (w,x) contains (y) and gives (z) without this element
		if (z) is a variable list whith no free occurences in (E)
		if tactic (SUB;RES) proves (bresult([y:=E]Q)) and gives result (S)
		not if (S) matches on ([a:=b]T)

  RULE SimplifyExistXY.6
	rewrite  (#(w,x).(P & R))  in  (#z.[y:=E]Q)
		if list (P & R) contains (y = E) and gives (Q) without this element
		prove (WD(expr(E),Z))
		if (y) is a variable list whith no free occurences in (E)
		if list (w,x) contains (y) and gives (z) without this element
		if (z) is a variable list whith no free occurences in (E)
		if tactic (SUB;RES) proves (bresult([y:=E]Q)) and gives result (S)
		not if (S) matches on ([a:=b]T)

  RULE SimplifyExistXY.7
	rewrite  (#x.(P & R))  in  ([x:=E]U)
		if list (P & R) contains (E = x)
		prove (IWD(expr(E),Z))
		if list (U) contains ((x = E),(P & R)) and gives (Z) without this element
		if (x) is a variable list whith no free occurences in (E)
		if tactic (SUB;RES) proves (bresult([x:=E]U)) and gives result (S)
		not if (S) matches on ([a:=b]T)

  RULE SimplifyExistXY.8
	rewrite  (#x.(P & R))  in  ([x:=E]Q)
		if list (P & R) contains (E = x) and gives (Q) without this element
		prove (bgetallhyp(H))
		if pattern (E) found in (H), replaced by toto becomes I, non free vars ?
		if (x) is a variable list whith no free occurences in (E)
		if tactic (SUB;RES) proves (bresult([x:=E]Q)) and gives result (S)
		not if (S) matches on ([a:=b]T)

  RULE SimplifyExistXY.9
	rewrite  (#x.(P & R))  in  ([x:=E]Q)
		if list (P & R) contains (E = x) and gives (Q) without this element
		prove (WD(expr(E),Z))
		if (x) is a variable list whith no free occurences in (E)
		if tactic (SUB;RES) proves (bresult([x:=E]Q)) and gives result (S)
		not if (S) matches on ([a:=b]T)

  RULE SimplifyExistXY.10
	rewrite  (#x.(P & R))  in  ([x:=E]U)
		if list (P & R) contains (x = E)
		prove (IWD(expr(E),Z))
		if list (U) contains ((x = E),(P & R)) and gives (Z) without this element
		if (x) is a variable list whith no free occurences in (E)
		if tactic (SUB;RES) proves (bresult([x:=E]U)) and gives result (S)
		not if (S) matches on ([a:=b]T)

  RULE SimplifyExistXY.11
	rewrite  (#x.(P & R))  in  ([x:=E]Q)
		if list (P & R) contains (x = E) and gives (Q) without this element
		prove (bgetallhyp(H))
		if pattern (E) found in (H), replaced by toto becomes I, non free vars ?
		if (x) is a variable list whith no free occurences in (E)
		if tactic (SUB;RES) proves (bresult([x:=E]Q)) and gives result (S)
		not if (S) matches on ([a:=b]T)

  RULE SimplifyExistXY.12
	rewrite  (#x.(P & R))  in  ([x:=E]Q)
		if list (P & R) contains (x = E) and gives (Q) without this element
		prove (WD(expr(E),Z))
		if (x) is a variable list whith no free occurences in (E)
		if tactic (SUB;RES) proves (bresult([x:=E]Q)) and gives result (S)
		not if (S) matches on ([a:=b]T)

  RULE SimplifyExistXY.13
	rewrite  (#x.(x = E))  in  (btrue)
		if (x) is a variable list whith no free occurences in (E)


-------------------------------------------------------------------
THEORY SimplifyFunctionXY IS

  RULE SimplifyFunctionXY.1
	rewrite  ((L\/{a|->b})(x))  in  (y)
		if (L\/{a|->b}: s +-> t) is in hypothesis
		if (a,b,L) does not contain non-free variables in replacement
		if list (L\/{a|->b}) contains ({x|->y})

  RULE SimplifyFunctionXY.2
	always rewrite (%x.(bfalse | e)) in ({})

  RULE SimplifyFunctionXY.3
	always rewrite (f><{}) in ({})

  RULE SimplifyFunctionXY.4
	always rewrite ({}><g) in ({})


-------------------------------------------------------------------
THEORY SimplifyIntMaxXY IS

  RULE SimplifyIntMaxXY.1
	rewrite  (max({p}\/{q}))  in  (p)
		if (q<=p) is litteraly true

  RULE SimplifyIntMaxXY.2
	rewrite  (max({p}\/{q}))  in  (p)
		if (q<=p) is in hypothesis
		if (q<=p) does not contain non-free variables in replacement

  RULE SimplifyIntMaxXY.3
	rewrite  (max({p}\/{q}))  in  (q)
		if (p<=q) is litteraly true

  RULE SimplifyIntMaxXY.4
	rewrite  (max({p}\/{q}))  in  (q)
		if (p<=q) is in hypothesis
		if (p<=q) does not contain non-free variables in replacement

  RULE SimplifyIntMaxXY.5
	rewrite  (max(L\/e))  in  (max(R\/{B}))
		if list (L\/e) contains ({a}) and gives (Q\/f) without this element
		if list (Q\/f) contains ({b}) and gives (R) without this element
		if (a,b) does not contain non-free variables in replacement
		if tactic (PutInOrderX) proves (PutInOrderG(a | b)) and gives result (PutInOrderR(A | B))

  RULE SimplifyIntMaxXY.6
	always rewrite (max(a..b)) in (b)

  RULE SimplifyIntMaxXY.7
	always rewrite (max({max(s)}\/t)) in (max(s\/t))

  RULE SimplifyIntMaxXY.8
	always rewrite (max({p})) in (p)


-------------------------------------------------------------------
THEORY SimplifyIntMinXY IS

  RULE SimplifyIntMinXY.1
	rewrite  (min(a-b))  in  (min(a))
		if (min(a)+1<=min(b)) is in hypothesis
		if (min(a)+1<=min(b)) does not contain non-free variables in replacement

  RULE SimplifyIntMinXY.2
	rewrite  (min({a}\/{b}))  in  (b)
		if (b<=a) is litteraly true

  RULE SimplifyIntMinXY.3
	rewrite  (min({a}\/{b}))  in  (b)
		if (b<=a) is in hypothesis
		if (b<=a) does not contain non-free variables in replacement

  RULE SimplifyIntMinXY.4
	rewrite  (min({a}\/{b}))  in  (a)
		if (a<=b) is litteraly true

  RULE SimplifyIntMinXY.5
	rewrite  (min({a}\/{b}))  in  (a)
		if (a<=b) is in hypothesis
		if (a<=b) does not contain non-free variables in replacement

  RULE SimplifyIntMinXY.6
	rewrite  (min(L\/e))  in  (min(R\/{A}))
		if list (L\/e) contains ({a}) and gives (Q\/f) without this element
		if list (Q\/f) contains ({b}) and gives (R) without this element
		if (a,b) does not contain non-free variables in replacement
		if tactic (PutInOrderX) proves (PutInOrderG(a | b)) and gives result (PutInOrderR(A | B))

  RULE SimplifyIntMinXY.7
	always rewrite (min(p..q)) in (p)

  RULE SimplifyIntMinXY.8
	always rewrite (min({min(s)}\/t)) in (min(s\/t))

  RULE SimplifyIntMinXY.9
	always rewrite (min(NATURAL)) in (0)

  RULE SimplifyIntMinXY.10
	always rewrite (min(NATURAL-{0})) in (1)

  RULE SimplifyIntMinXY.11
	always rewrite (min({a})) in (a)


-------------------------------------------------------------------
THEORY SimplifyIntPIXY IS

  RULE SimplifyIntPIXY.1
	rewrite  (PI(x).(x: S | size((f\/{s|->y})(x))))  in  (PI(x).(x: S | size(f(x))))
		if (f: S +-> T) is in hypothesis
		if (not(s: S)) is in hypothesis
		if we make a successfull attempt to prove (dom(f) = S) with current prover force
		if Q is the list of active non-free variables in replacement
		if (Q) is a variable list whith no free occurences in (f: S +-> T)
		if (Q) is a variable list whith no free occurences in (not(s: S))
		if (x) is a variable list whith no free occurences in (S,f,s)

  RULE SimplifyIntPIXY.2
	rewrite  (PI(x).(x: S | size((f\/{s|->y})(x))))  in  (PI(x).(x: S | size(f(x))))
		if (f: S +-> T) is in hypothesis
		if (not(s: dom(f))) is in hypothesis
		if we make a successfull attempt to prove (dom(f) = S) with current prover force
		if Q is the list of active non-free variables in replacement
		if (Q) is a variable list whith no free occurences in (f: S +-> T)
		if (Q) is a variable list whith no free occurences in (not(s: dom(f)))
		if (x) is a variable list whith no free occurences in (S,f,s)

  RULE SimplifyIntPIXY.3
	rewrite  (PI(x).(x: S | (f\/{s|->y})(x)))  in  (PI(x).(x: S | f(x)))
		if (f: S +-> NATURAL) is in hypothesis
		if (not(s: S)) is in hypothesis
		if we make a successfull attempt to prove (dom(f) = S) with current prover force
		if Q is the list of active non-free variables in replacement
		if (Q) is a variable list whith no free occurences in (f: S +-> NATURAL)
		if (Q) is a variable list whith no free occurences in (not(s: S))
		if (x) is a variable list whith no free occurences in (S,f,s)

  RULE SimplifyIntPIXY.4
	rewrite  (PI(x).(x: S | (f\/{s|->y})(x)))  in  (PI(x).(x: S | f(x)))
		if (f: S +-> NATURAL) is in hypothesis
		if (not(s: dom(f))) is in hypothesis
		if we make a successfull attempt to prove (dom(f) = S) with current prover force
		if Q is the list of active non-free variables in replacement
		if (Q) is a variable list whith no free occurences in (f: S +-> NATURAL)
		if (Q) is a variable list whith no free occurences in (not(s: dom(f)))
		if (x) is a variable list whith no free occurences in (S,f,s)

  RULE SimplifyIntPIXY.5
	rewrite  (PI(x).(x: a\/{b} | e))  in  (PI(x).(x: a | e)*[x:=b]e)
		if (not(b: a)) is in hypothesis
		if (not(b: a)) does not contain non-free variables in replacement
		if (x) is a variable list whith no free occurences in (a,b)

  RULE SimplifyIntPIXY.6
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

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

  RULE SimplifyIntPIXY.8
	rewrite  (PI(x).(x: {a} | e))  in  ([x:=a]e)
		if (x) is a variable list whith no free occurences in (a)


-------------------------------------------------------------------
THEORY SimplifyIntParXY IS

  RULE SimplifyIntParXY.1
	rewrite  (p)  in  (q+1)
		if (p: r..q+1) is in hypothesis
		if (q<p) is litteraly true
		if (p: r..q+1) does not contain non-free variables in replacement

  RULE SimplifyIntParXY.2
	rewrite  (p)  in  (q+1)
		if (q+1<=p) is in hypothesis
		if (p: r..q+1) is in hypothesis
		if (p: r..q+1) does not contain non-free variables in replacement


-------------------------------------------------------------------
THEORY SimplifyIntSIGXY IS

  RULE SimplifyIntSIGXY.1
	rewrite  (SIGMA(x).(x: S | size((f\/{s|->y})(x))))  in  (SIGMA(x).(x: S | size(f(x))))
		if (f: S +-> T) is in hypothesis
		if (not(s: S)) is in hypothesis
		if we make a successfull attempt to prove (dom(f) = S) with current prover force
		if Q is the list of active non-free variables in replacement
		if (Q) is a variable list whith no free occurences in (f: S +-> T)
		if (Q) is a variable list whith no free occurences in (not(s: S))
		if (x) is a variable list whith no free occurences in (f,s,S)

  RULE SimplifyIntSIGXY.2
	rewrite  (SIGMA(x).(x: S | size((f\/{s|->y})(x))))  in  (SIGMA(x).(x: S | size(f(x))))
		if (f: S +-> T) is in hypothesis
		if (not(s: dom(f))) is in hypothesis
		if we make a successfull attempt to prove (dom(f) = S) with current prover force
		if Q is the list of active non-free variables in replacement
		if (Q) is a variable list whith no free occurences in (f: S +-> T)
		if (Q) is a variable list whith no free occurences in (not(s: dom(f)))
		if (x) is a variable list whith no free occurences in (f,s,S)

  RULE SimplifyIntSIGXY.3
	rewrite  (SIGMA(x).(x: S | (f\/{s|->y})(x)))  in  (SIGMA(x).(x: S | f(x)))
		if (f: S +-> NATURAL) is in hypothesis
		if (not(s: S)) is in hypothesis
		if we make a successfull attempt to prove (dom(f) = S) with current prover force
		if Q is the list of active non-free variables in replacement
		if (Q) is a variable list whith no free occurences in (f: S +-> NATURAL)
		if (Q) is a variable list whith no free occurences in (not(s: S))
		if (x) is a variable list whith no free occurences in (f,s,S)

  RULE SimplifyIntSIGXY.4
	rewrite  (SIGMA(x).(x: S | (f\/{s|->y})(x)))  in  (SIGMA(x).(x: S | f(x)))
		if (f: S +-> NATURAL) is in hypothesis
		if (not(s: dom(f))) is in hypothesis
		if we make a successfull attempt to prove (dom(f) = S) with current prover force
		if Q is the list of active non-free variables in replacement
		if (Q) is a variable list whith no free occurences in (f: S +-> NATURAL)
		if (Q) is a variable list whith no free occurences in (not(s: dom(f)))
		if (x) is a variable list whith no free occurences in (f,s,S)

  RULE SimplifyIntSIGXY.5
	rewrite  (SIGMA(x).(x: a\/{b} | e))  in  (SIGMA(x).(x: a | e)+[x:=b]e)
		not if (x) matches on (y,z)
		if (not(b: a)) is in hypothesis
		if (not(b: a)) does not contain non-free variables in replacement
		if (x) is a variable list whith no free occurences in (a,b)

  RULE SimplifyIntSIGXY.6
	rewrite  (SIGMA(x).(x: a..b | e))  in  (T)
		if (a,b) does not contain non-free variables in replacement
		not if theory (DangerousExp) has a rule number (m) that matches with (SIGMA(x).(x: a..b | e))
		if tactic (ARI~;Fast_Prove_All_Order) proves (a<=b)
		if tactic (ARI~;Fast_Prove_All_Order) proves (b<=a+20)
		if tactic (TryEvalSigma) proves (SIGMA(x).(x: a..b | e)) and gives result (T)

  RULE SimplifyIntSIGXY.7
	rewrite  (SIGMA(x).(P | e))  in  (SIGMA(x).(Q | e))
		if (x: INTEGER & 0<=x & a<=x & x<=b) found in (P) and give (Q) when replaced by (x: a..b/\NATURAL)

  RULE SimplifyIntSIGXY.8
	rewrite  (SIGMA(x).(P | e))  in  (SIGMA(x).(Q | e))
		if (x: INTEGER & 0<=x & x<=b & a<=x) found in (P) and give (Q) when replaced by (x: a..b/\NATURAL)

  RULE SimplifyIntSIGXY.9
	rewrite  (SIGMA(x).(P | 0))  in  (0)
		if list (P) contains (x: p..q)

  RULE SimplifyIntSIGXY.10
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE SimplifyIntSIGXY.11
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE SimplifyIntSIGXY.12
	rewrite  (SIGMA(x).(x: {a} | e))  in  ([x:=a]e)
		not if (x) matches on (y,z)
		if (x) is a variable list whith no free occurences in (a)

  RULE SimplifyIntSIGXY.13
	rewrite  (SIGMA(x).(P | 0))  in  (0)
		if (P) matches on (u & v)
		if list (P) contains (x<=q)
		if list (P) contains (p<=x)

  RULE SimplifyIntSIGXY.14
	always rewrite (SIGMA(x).(x: p..q | 0)) in (0)


-------------------------------------------------------------------
THEORY SimplifyRelComXY IS

  RULE SimplifyRelComXY.1
	rewrite  (r;{a}<<|s)  in  (r;s)
		if (not(a: ran(r))) is in hypothesis
		if (not(a: ran(r))) does not contain non-free variables in replacement

  RULE SimplifyRelComXY.2
	rewrite  (r;{a|->b})  in  ({})
		if (not(a: ran(r))) is in hypothesis
		if (not(a: ran(r))) does not contain non-free variables in replacement

  RULE SimplifyRelComXY.3
	rewrite  (r<+s;t)  in  ((r;t)<+(s;t))
		if (ran(s): POW(dom(t))) is in hypothesis
		if (ran(s): POW(dom(t))) does not contain non-free variables in replacement

  RULE SimplifyRelComXY.4
	rewrite  (r;s<+t)  in  ((r;s)<+(r;t))
		if (r: u +-> v) is in hypothesis
		if (r: u +-> v) does not contain non-free variables in replacement

  RULE SimplifyRelComXY.5
	rewrite  (r;s/\t)  in  ((r;s)/\(r;t))
		if (r: u +-> v) is in hypothesis
		if (r: u +-> v) does not contain non-free variables in replacement

  RULE SimplifyRelComXY.6
	rewrite  (r;s-t)  in  ((r;s)-(r;t))
		if (r: u +-> v) is in hypothesis
		if (r: u +-> v) does not contain non-free variables in replacement

  RULE SimplifyRelComXY.7
	rewrite  (r;s><t)  in  ((r;s)><(r;t))
		if (r: u +-> v) is in hypothesis
		if (r: u +-> v) does not contain non-free variables in replacement

  RULE SimplifyRelComXY.8
	rewrite  (r/\s;t)  in  ((r;t)/\(s;t))
		if (t~: u +-> v) is in hypothesis
		if (t~: u +-> v) does not contain non-free variables in replacement

  RULE SimplifyRelComXY.9
	rewrite  (r-s;t)  in  ((r;t)-(s;t))
		if (t~: u +-> v) is in hypothesis
		if (t~: u +-> v) does not contain non-free variables in replacement

  RULE SimplifyRelComXY.10
	rewrite  (r~;r)  in  (id(ran(r)))
		if (r: u +-> v) is in hypothesis
		if (r: u +-> v) does not contain non-free variables in replacement

  RULE SimplifyRelComXY.11
	rewrite  (r;r~)  in  (id(dom(r)))
		if (r~: u +-> v) is in hypothesis
		if (r~: u +-> v) does not contain non-free variables in replacement

  RULE SimplifyRelComXY.12
	always rewrite (r;u*v) in (r~[u]*v)

  RULE SimplifyRelComXY.13
	always rewrite (r;(s;t)) in (r;s;t)

  RULE SimplifyRelComXY.14
	always rewrite (r;id(u)) in (r|>u)

  RULE SimplifyRelComXY.15
	always rewrite (r;u<|s) in (r|>u;s)

  RULE SimplifyRelComXY.16
	always rewrite (r;s|>u) in ((r;s)|>u)

  RULE SimplifyRelComXY.17
	always rewrite (r;u<<|s) in (r|>>u;s)

  RULE SimplifyRelComXY.18
	always rewrite (r;s|>>u) in ((r;s)|>>u)

  RULE SimplifyRelComXY.19
	always rewrite (r;s\/t) in ((r;s)\/(r;t))

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

  RULE SimplifyRelComXY.21
	always rewrite (u*v;r) in (u*r[v])

  RULE SimplifyRelComXY.22
	always rewrite (id(u);r) in (u<|r)

  RULE SimplifyRelComXY.23
	always rewrite (u<|r;s) in (u<|(r;s))

  RULE SimplifyRelComXY.24
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE SimplifyRelComXY.25
	always rewrite (u<<|r;s) in (u<<|(r;s))

  RULE SimplifyRelComXY.26
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE SimplifyRelComXY.27
	always rewrite (r\/s;t) in ((r;t)\/(s;t))

  RULE SimplifyRelComXY.28
	always rewrite (id(u);id(v)) in (id(u/\v))

  RULE SimplifyRelComXY.29
	always rewrite (p || q;(r || s)) in (p;r || (q;s))

  RULE SimplifyRelComXY.30
	always rewrite (p><q;(r || s)) in ((p;r)><(q;s))

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

  RULE SimplifyRelComXY.32
	always rewrite (r;{}) in ({})

  RULE SimplifyRelComXY.33
	always rewrite ({};r) in ({})


-------------------------------------------------------------------
THEORY SimplifyRelDoaLongXY IS

  RULE SimplifyRelDoaLongXY.1
	always rewrite (u<<|(r<+s)) in (u<<|r<+(u<<|s))

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

  RULE SimplifyRelDoaLongXY.3
	always rewrite (u<<|(r\/s)) in (u<<|r\/(u<<|s))

  RULE SimplifyRelDoaLongXY.4
	always rewrite (u<<|(r/\s)) in (u<<|r/\(u<<|s))

  RULE SimplifyRelDoaLongXY.5
	always rewrite (u\/v<<|r) in (u<<|r/\(v<<|r))

  RULE SimplifyRelDoaLongXY.6
	always rewrite (u/\v<<|r) in (u<<|r\/(v<<|r))

  RULE SimplifyRelDoaLongXY.7
	always rewrite (u-v<<|r) in (u<<|r\/(v<|r))


-------------------------------------------------------------------
THEORY SimplifyRelDoaXY IS

  RULE SimplifyRelDoaXY.1
	always rewrite (INTEGER<<|r) in ({})

  RULE SimplifyRelDoaXY.2
	rewrite  (f~[w]<<|f)  in  (f|>>w)
		if (f: u +-> v) is in hypothesis
		if (f: u +-> v) does not contain non-free variables in replacement

  RULE SimplifyRelDoaXY.3
	rewrite  ({a}<<|{b|->c})  in  ({b|->c})
		if tactic (Fast_Prove_Difference) proves (not(a = b))
		if (not(a = b)) does not contain non-free variables in replacement

  RULE SimplifyRelDoaXY.4
	rewrite  ({a}<<|r)  in  (r)
		if (not(a: dom(r))) is in hypothesis
		if (not(a: dom(r))) does not contain non-free variables in replacement

  RULE SimplifyRelDoaXY.5
	rewrite  (u<<|{a|->b})  in  ({a|->b})
		if (not(a: u)) is in hypothesis
		if (not(a: u)) does not contain non-free variables in replacement

  RULE SimplifyRelDoaXY.6
	rewrite  (u<<|{a|->b})  in  ({})
		if (a: u) is in hypothesis
		if (a: u) does not contain non-free variables in replacement

  RULE SimplifyRelDoaXY.7
	rewrite  (u<<|r)  in  ({})
		if (dom(r): POW(u)) is in hypothesis
		if (dom(r): POW(u)) does not contain non-free variables in replacement

  RULE SimplifyRelDoaXY.8
	rewrite  (u<<|r)  in  (r)
		if (dom(r)/\u = {}) is in hypothesis
		if (dom(r)/\u = {}) does not contain non-free variables in replacement

  RULE SimplifyRelDoaXY.9
	rewrite  (u<<|r)  in  (r)
		if (u/\dom(r) = {}) is in hypothesis
		if (u/\dom(r) = {}) does not contain non-free variables in replacement

  RULE SimplifyRelDoaXY.10
	rewrite  (u<<|SET(x,y).(x: S & y: T & P))  in  (SET(x,y).(x: S-u & y: T & P))
		if (x,y) is a variable list whith no free occurences in (u)

  RULE SimplifyRelDoaXY.11
	rewrite  (u<<|%x.(x: S | E))  in  (%x.(x: S-u | E))
		if (x) is a variable list whith no free occurences in (u)

  RULE SimplifyRelDoaXY.12
	rewrite  (u<<|%x.(x: S & P | E))  in  (%x.(x: S-u & P | E))
		if (x) is a variable list whith no free occurences in (u)

  RULE SimplifyRelDoaXY.13
	always rewrite (u<<|(r;s)) in (u<<|r;s)

  RULE SimplifyRelDoaXY.14
	always rewrite (u<<|id(v)) in (id(v-u))

  RULE SimplifyRelDoaXY.15
	always rewrite (u<<|(v<|r)) in (v-u<|r)

  RULE SimplifyRelDoaXY.16
	always rewrite (u<<|(v<<|r)) in (u\/v<<|r)

  RULE SimplifyRelDoaXY.17
	always rewrite (u<<|v*t) in ((v-u)*t)

  RULE SimplifyRelDoaXY.18
	always rewrite (u<<|u*v) in ({})

  RULE SimplifyRelDoaXY.19
	always rewrite (u<<|r-s) in ((u<<|r)-s)

  RULE SimplifyRelDoaXY.20
	always rewrite (dom(r)<<|r) in ({})

  RULE SimplifyRelDoaXY.21
	always rewrite (u<<|{}) in ({})

  RULE SimplifyRelDoaXY.22
	always rewrite ({}<<|r) in (r)

  RULE SimplifyRelDoaXY.23
	always rewrite ({a}<<|{a|->b}) in ({})


-------------------------------------------------------------------
THEORY SimplifyRelDomXY IS

  RULE SimplifyRelDomXY.1
	rewrite  (dom(r;s))  in  (dom(r))
		if (ran(r): POW(dom(s))) is in hypothesis
		if (ran(r): POW(dom(s))) does not contain non-free variables in replacement

  RULE SimplifyRelDomXY.2
	rewrite  (dom(u*v))  in  (u)
		if (not(v = {})) is in hypothesis
		if (v) does not contain non-free variables in replacement

  RULE SimplifyRelDomXY.3
	rewrite  (dom(f-g))  in  (dom(f)-dom(g))
		if (f: A +-> B) is in hypothesis
		if (g: POW(f)) is in hypothesis
		if (f: A +-> B & g: POW(f)) does not contain non-free variables in replacement

  RULE SimplifyRelDomXY.4
	rewrite  (dom(r|>>u))  in  (dom(r)-r~[u])
		if (r: s +-> t) is in hypothesis
		if (r: s +-> t) does not contain non-free variables in replacement

  RULE SimplifyRelDomXY.5
	always rewrite (dom(%x.(P | e))) in (SET(x).P)

  RULE SimplifyRelDomXY.6
	always rewrite (dom(r;s)) in (r~[dom(s)])

  RULE SimplifyRelDomXY.7
	always rewrite (dom(u*{a})) in (u)

  RULE SimplifyRelDomXY.8
	always rewrite (dom(id(s))) in (s)

  RULE SimplifyRelDomXY.9
	always rewrite (dom(succ)) in (INTEGER)

  RULE SimplifyRelDomXY.10
	always rewrite (dom(pred)) in (INTEGER)

  RULE SimplifyRelDomXY.11
	always rewrite (dom(u<|r)) in (u/\dom(r))

  RULE SimplifyRelDomXY.12
	always rewrite (dom(r|>u)) in (r~[u])

  RULE SimplifyRelDomXY.13
	always rewrite (dom(u<<|r)) in (dom(r)-u)

  RULE SimplifyRelDomXY.14
	always rewrite (dom(r~)) in (ran(r))

  RULE SimplifyRelDomXY.15
	always rewrite (dom(r<+s)) in (dom(r)\/dom(s))

  RULE SimplifyRelDomXY.16
	always rewrite (dom(r><s)) in (dom(r)/\dom(s))

  RULE SimplifyRelDomXY.17
	always rewrite (dom(prj1(u,v))) in (u*v)

  RULE SimplifyRelDomXY.18
	always rewrite (dom(prj2(u,v))) in (u*v)

  RULE SimplifyRelDomXY.19
	always rewrite (dom(r\/s)) in (dom(r)\/dom(s))

  RULE SimplifyRelDomXY.20
	always rewrite (dom(r || s)) in (dom(r)*dom(s))

  RULE SimplifyRelDomXY.21
	rewrite  (dom({a|->b}))  in  ({a})
		not if (a) matches on (c,d)

  RULE SimplifyRelDomXY.22
	always rewrite (dom({})) in ({})

  RULE SimplifyRelDomXY.23
	rewrite  (dom({(c,d)|->b}))  in  (dom({c|->b})*{d})
		not if (d) matches on (e,f)


-------------------------------------------------------------------
THEORY SimplifyRelDorLongXY IS

  RULE SimplifyRelDorLongXY.1
	always rewrite (u<|(r<+s)) in (u<|r<+(u<|s))

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

  RULE SimplifyRelDorLongXY.3
	always rewrite (a<|(r\/s)) in (a<|r\/(a<|s))

  RULE SimplifyRelDorLongXY.4
	always rewrite (u<|(r/\s)) in (u<|r/\(u<|s))

  RULE SimplifyRelDorLongXY.5
	always rewrite (u/\v<|r) in (u<|r/\(v<|r))

  RULE SimplifyRelDorLongXY.6
	always rewrite (a\/b<|r) in (a<|r\/(b<|r))

  RULE SimplifyRelDorLongXY.7
	always rewrite (u-v<|r) in ((u<|r)-(v<|r))


-------------------------------------------------------------------
THEORY SimplifyRelDorXY IS

  RULE SimplifyRelDorXY.1
	rewrite  ({a}<|(f\/{a|->b}))  in  ({a|->b})
		if (not(a: dom(f))) is in hypothesis
		if (a: dom(f)) does not contain non-free variables in replacement

  RULE SimplifyRelDorXY.2
	rewrite  ({a}<|f)  in  ({a|->f(a)})
		if (f: u +-> v) is in hypothesis
		if (a: dom(f)) is in hypothesis
		if Q is the list of active non-free variables in replacement
		if (Q) is a variable list whith no free occurences in (f: u +-> v)
		if (Q) is a variable list whith no free occurences in (a: dom(f))

  RULE SimplifyRelDorXY.3
	rewrite  ({a}<|r)  in  ({})
		if (not(a: dom(r))) is in hypothesis
		if (not(a: dom(r))) does not contain non-free variables in replacement

  RULE SimplifyRelDorXY.4
	rewrite  ({b}<|r~)  in  ({})
		if (not(b: ran(r))) is in hypothesis
		if (not(b: ran(r))) does not contain non-free variables in replacement

  RULE SimplifyRelDorXY.5
	rewrite  (f~[w]<|f)  in  (f|>w)
		if (f: u +-> v) is in hypothesis
		if (f: u +-> v) does not contain non-free variables in replacement

  RULE SimplifyRelDorXY.6
	rewrite  (u<|(r;s))  in  ({})
		if (u/\dom(r) = {}) is in hypothesis
		if (u/\dom(r) = {}) does not contain non-free variables in replacement

  RULE SimplifyRelDorXY.7
	rewrite  (u<|{a|->b})  in  ({a|->b})
		if (a: u) is in hypothesis
		if (a: u) does not contain non-free variables in replacement

  RULE SimplifyRelDorXY.8
	rewrite  (u<|{a|->b})  in  ({})
		if (not(a: u)) is in hypothesis
		if (a: u) does not contain non-free variables in replacement

  RULE SimplifyRelDorXY.9
	rewrite  (u<|r)  in  (r)
		if (dom(r): POW(u)) is in hypothesis
		if (dom(r): POW(u)) does not contain non-free variables in replacement

  RULE SimplifyRelDorXY.10
	rewrite  (u<|r)  in  ({})
		if (u/\dom(r) = {}) is in hypothesis
		if (u/\dom(r) = {}) does not contain non-free variables in replacement

  RULE SimplifyRelDorXY.11
	rewrite  (u<|r)  in  ({})
		if (dom(r)/\u = {}) is in hypothesis
		if (dom(r)/\u = {}) does not contain non-free variables in replacement

  RULE SimplifyRelDorXY.12
	rewrite  ({a}<|{b|->c})  in  ({})
		if tactic (Fast_Prove_Difference) proves (not(a = b))
		if (not(a = b)) does not contain non-free variables in replacement

  RULE SimplifyRelDorXY.13
	rewrite  (u<|%x.(x: S | E))  in  (%x.(x: u/\S | E))
		if (x) is a variable list whith no free occurences in (u)

  RULE SimplifyRelDorXY.14
	rewrite  (u<|%x.(x: S & P | E))  in  (%x.(x: u/\S & P | E))
		if (x) is a variable list whith no free occurences in (u)

  RULE SimplifyRelDorXY.15
	rewrite  (u<|SET(x,y).(x: S & y: T & P))  in  (SET(x,y).(x: u/\S & y: T & P))
		if (x,y) is a variable list whith no free occurences in (u)

  RULE SimplifyRelDorXY.16
	always rewrite (u<|id(v)) in (id(u/\v))

  RULE SimplifyRelDorXY.17
	always rewrite (u<|v*w) in ((u/\v)*w)

  RULE SimplifyRelDorXY.18
	always rewrite (u<|u*v) in (u*v)

  RULE SimplifyRelDorXY.19
	always rewrite (u<|(v<|r)) in (u/\v<|r)

  RULE SimplifyRelDorXY.20
	always rewrite (u<|(v<<|r)) in (u-v<|r)

  RULE SimplifyRelDorXY.21
	always rewrite (u*v<|(r || s)) in (u<|r || v<|s)

  RULE SimplifyRelDorXY.22
	always rewrite (u<|r-s) in ((u<|r)-s)

  RULE SimplifyRelDorXY.23
	always rewrite ({a}<|{a|->b}) in ({a|->b})

  RULE SimplifyRelDorXY.24
	always rewrite (dom(r)<|r) in (r)

  RULE SimplifyRelDorXY.25
	always rewrite (ran(r)<|r~) in (r~)

  RULE SimplifyRelDorXY.26
	always rewrite (u<|{}) in ({})

  RULE SimplifyRelDorXY.27
	always rewrite ({}<|r) in ({})


-------------------------------------------------------------------
THEORY SimplifyRelFonXY IS

  RULE SimplifyRelFonXY.1
	rewrite  (prj2(A,B)(c))  in  (a)
		if (c: C*{a}) is in hypothesis
		if (c: C*{a}) does not contain non-free variables in replacement

  RULE SimplifyRelFonXY.2
	always rewrite (id(u)(a)) in (a)

  RULE SimplifyRelFonXY.3
	rewrite  ((u<|r)(a))  in  (r(a))
		if (r: s +-> t) is in hypothesis
		if (r: s +-> t) does not contain non-free variables in replacement

  RULE SimplifyRelFonXY.4
	rewrite  ((u<<|r)(a))  in  (r(a))
		if (r: s +-> t) is in hypothesis
		if (r: s +-> t) does not contain non-free variables in replacement

  RULE SimplifyRelFonXY.5
	rewrite  ((r|>u)(a))  in  (r(a))
		if (r: s +-> t) is in hypothesis
		if (r: s +-> t) does not contain non-free variables in replacement

  RULE SimplifyRelFonXY.6
	rewrite  ((r|>>u)(a))  in  (r(a))
		if (r: s +-> t) is in hypothesis
		if (r: s +-> t) does not contain non-free variables in replacement

  RULE SimplifyRelFonXY.7
	rewrite  ((r<+s)(a))  in  (r(a))
		if (r: u +-> v) is in hypothesis
		if (not(a: dom(s))) is in hypothesis
		if (not(a: dom(s)) & r: u +-> v) does not contain non-free variables in replacement

  RULE SimplifyRelFonXY.8
	rewrite  ((r<+s)(a))  in  (s(a))
		if (a: dom(s)) is in hypothesis
		if (a: dom(s)) does not contain non-free variables in replacement

  RULE SimplifyRelFonXY.9
	rewrite  ((r<+{a|->b})(c))  in  (r(c))
		if (r: u +-> v) is in hypothesis
		if (c: dom(r)) is in hypothesis
		if tactic (Fast_Prove_Difference) proves (not(a = c))
		if (not(a = c) & c: dom(r) & r: u +-> v) does not contain non-free variables in replacement

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

  RULE SimplifyRelFonXY.11
	rewrite  ((r><s)(a))  in  (r(a)|->s(a))
		if (r: u +-> t) is in hypothesis
		if (s: v +-> w) is in hypothesis
		if (r,s) does not contain non-free variables in replacement

  RULE SimplifyRelFonXY.12
	rewrite  ((f/\g)(a))  in  (f(a))
		if (f: s +-> t) is in hypothesis
		if (f: s +-> t) does not contain non-free variables in replacement

  RULE SimplifyRelFonXY.13
	rewrite  ((f/\g)(a))  in  (g(a))
		if (g: s +-> t) is in hypothesis
		if (g: s +-> t) does not contain non-free variables in replacement

  RULE SimplifyRelFonXY.14
	rewrite  ((r\/s)(a))  in  (r(a))
		if (a: dom(r)) is in hypothesis
		if (a: dom(r) & s) does not contain non-free variables in replacement

  RULE SimplifyRelFonXY.15
	rewrite  ((r\/s)(a))  in  (s(a))
		if (a: dom(s)) is in hypothesis
		if (a: dom(s) & r) does not contain non-free variables in replacement

  RULE SimplifyRelFonXY.16
	rewrite  ((r\/{a|->b})(c))  in  (r(c))
		if tactic (Fast_Prove_Difference) proves (not(a = c))
		if (c: dom(r<+{a|->b})) does not contain non-free variables in replacement

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

  RULE SimplifyRelFonXY.18
	rewrite  ((r-s)(a))  in  (r(a))
		if (r: u +-> v) is in hypothesis
		if (r: u +-> v) does not contain non-free variables in replacement

  RULE SimplifyRelFonXY.19
	rewrite  ((f;g)(x))  in  (g(f(x)))
		if (f: A +-> B) is in hypothesis
		if (g: C +-> D) is in hypothesis
		if (x & f: A +-> B & g: C +-> D) does not contain non-free variables in replacement

  RULE SimplifyRelFonXY.20
	always rewrite (r~(r(a))) in (a)

  RULE SimplifyRelFonXY.21
	always rewrite (r(r~(a))) in (a)

  RULE SimplifyRelFonXY.22
	rewrite  ((%x.(P | E))(a))  in  (R)
		if tactic (SUB;RES) proves (bresult([x:=a]E)) and gives result (R)
		not if (R) matches on ([y:=z]S)

  RULE SimplifyRelFonXY.23
	rewrite  (prj1(A,B)(c))  in  (a)
		if (c: {a}*C) is in hypothesis
		if (c: {a}*C) does not contain non-free variables in replacement

  RULE SimplifyRelFonXY.24
	always rewrite (prj1(u,v)(a|->b)) in (a)

  RULE SimplifyRelFonXY.25
	always rewrite (prj2(u,v)(a|->b)) in (b)

  RULE SimplifyRelFonXY.26
	always rewrite ((A*{y})(x)) in (y)

  RULE SimplifyRelFonXY.27
	rewrite  (succ(x))  in  (x+1)
		if tactic (Fast_Prove_Num) proves (x)

  RULE SimplifyRelFonXY.28
	rewrite  (pred(x))  in  (x-1)
		if tactic (Fast_Prove_Num) proves (x)

  RULE SimplifyRelFonXY.29
	always rewrite ({a|->b}(a)) in (b)

  RULE SimplifyRelFonXY.30
	always rewrite (([a,b])(size([a,b])-1)) in (([a])(size([a])))

  RULE SimplifyRelFonXY.31
	rewrite  (([a])(size([a])))  in  (a)
		not if (a) matches on (u,v)

  RULE SimplifyRelFonXY.32
	always rewrite (([a,b])(size([a,b]))) in (b)

  RULE SimplifyRelFonXY.33
	rewrite  (([a])(1))  in  (a)
		not if (a) matches on (u,v)

  RULE SimplifyRelFonXY.34
	always rewrite (([a,b])(1)) in (([a])(1))

  RULE SimplifyRelFonXY.35
	rewrite {a} spe b
		in {a}(b)

  RULE SimplifyRelFonXY.36
	always rewrite ((a\/{b})c) in ((a\/{b})(c))


-------------------------------------------------------------------
THEORY SimplifyRelId IS

  RULE SimplifyRelId.1
	always rewrite (id(u\/v)) in (id(u)\/id(v))

  RULE SimplifyRelId.2
	always rewrite (id(u/\v)) in (id(u)/\id(v))

  RULE SimplifyRelId.3
	always rewrite (id(u-v)) in (id(u)-id(v))

  RULE SimplifyRelId.4
	always rewrite (id({a})) in ({a|->a})

  RULE SimplifyRelId.5
	always rewrite (id({})) in ({})


-------------------------------------------------------------------
THEORY SimplifyRelImaLongXY IS

  RULE SimplifyRelImaLongXY.1
	rewrite  ((r/\s)[u])  in  (r[u]/\s[u])
		if (r|>ran(s) = s|>ran(r)) is in hypothesis
		if (r/\s) does not contain non-free variables in replacement

  RULE SimplifyRelImaLongXY.2
	rewrite  ((r-s)[u])  in  (r[u]-s[u])
		if (r|>ran(s) = s|>ran(r)) is in hypothesis
		if (r-s) does not contain non-free variables in replacement

  RULE SimplifyRelImaLongXY.3
	rewrite  (r[u/\v])  in  (r[u]/\r[v])
		if (r~: t +-> s) is in hypothesis
		if (r~: t +-> s) does not contain non-free variables in replacement

  RULE SimplifyRelImaLongXY.4
	rewrite  (r[u-v])  in  (r[u]-r[v])
		if (r~: t +-> s) is in hypothesis
		if (r~: t +-> s) does not contain non-free variables in replacement

  RULE SimplifyRelImaLongXY.5
	always rewrite ((r\/s)[u]) in (r[u]\/s[u])

  RULE SimplifyRelImaLongXY.6
	always rewrite (r[u\/v]) in (r[u]\/r[v])


-------------------------------------------------------------------
THEORY SimplifyRelImaXY IS

  RULE SimplifyRelImaXY.1
	rewrite  (r[A])  in  (ran(r))
		if (dom(r): POW(A)) is in hypothesis
		if (dom(r): POW(A)) does not contain non-free variables in replacement

  RULE SimplifyRelImaXY.2
	rewrite  (r[{r~(a)}])  in  ({a})
		if (r: A +-> B) is in hypothesis
		if (a: ran(r)) is in hypothesis
		if (r: A +-> B & a: ran(r)) does not contain non-free variables in replacement

  RULE SimplifyRelImaXY.3
	rewrite  (prj1(A,B)[A*B])  in  (A)
		if (not(B = {})) is in hypothesis
		if (B) does not contain non-free variables in replacement

  RULE SimplifyRelImaXY.4
	rewrite  (prj2(A,B)[A*B])  in  (B)
		if (not(A = {})) is in hypothesis
		if (A) does not contain non-free variables in replacement

  RULE SimplifyRelImaXY.5
	rewrite  (r[dom(s)])  in  (ran(r))
		if (r: POW(s)) is in hypothesis
		if (r: POW(s)) does not contain non-free variables in replacement

  RULE SimplifyRelImaXY.6
	rewrite  (r[ran(s)])  in  (ran(r))
		if (r: POW(s~)) is in hypothesis
		if (r: POW(s~)) does not contain non-free variables in replacement

  RULE SimplifyRelImaXY.7
	rewrite  (({a}*v)[{b}])  in  ({})
		if tactic (Fast_Prove_Difference) proves (not(a = b))
		if (not(a = b)) does not contain non-free variables in replacement

  RULE SimplifyRelImaXY.8
	rewrite  ((u*v)[u])  in  (v)
		if (not(u = {})) is in hypothesis
		if (u) does not contain non-free variables in replacement

  RULE SimplifyRelImaXY.9
	rewrite  ((u*v)[w])  in  (v)
		if (not(u/\w = {})) is in hypothesis
		if (not(u/\w = {})) does not contain non-free variables in replacement

  RULE SimplifyRelImaXY.10
	rewrite  ((u*v)[w])  in  ({})
		if (u/\w = {}) is in hypothesis
		if (u/\w = {}) does not contain non-free variables in replacement

  RULE SimplifyRelImaXY.11
	rewrite  (r[u])  in  ({})
		if (dom(r)/\u = {}) is in hypothesis
		if (dom(r)/\u = {}) does not contain non-free variables in replacement

  RULE SimplifyRelImaXY.12
	rewrite  (r[u])  in  ({})
		if (u/\dom(r) = {}) is in hypothesis
		if (u/\dom(r) = {}) does not contain non-free variables in replacement

  RULE SimplifyRelImaXY.13
	rewrite  (f[{a}])  in  ({b})
		if (f(a) = b) is in hypothesis
		if (a: dom(f)) is in hypothesis
		if (f(a) = b) does not contain non-free variables in replacement

  RULE SimplifyRelImaXY.14
	rewrite  (r~[{a}])  in  ({})
		if (not(a: ran(r))) is in hypothesis
		if (a: ran(r)) does not contain non-free variables in replacement

  RULE SimplifyRelImaXY.15
	rewrite  (r[{a}])  in  ({})
		if (not(a: dom(r))) is in hypothesis
		if (a: dom(r)) does not contain non-free variables in replacement

  RULE SimplifyRelImaXY.16
	rewrite  (r[{a}])  in  ({r(a)})
		if (r: u +-> v) is in hypothesis
		if (a: dom(r)) is in hypothesis
		if Q is the list of active non-free variables in replacement
		if (Q) is a variable list whith no free occurences in (r: u +-> v)
		if (Q) is a variable list whith no free occurences in (a: dom(r))

  RULE SimplifyRelImaXY.17
	rewrite  ({a|->b}[u])  in  ({})
		if (not(a: u)) is in hypothesis
		if (not(a: u)) does not contain non-free variables in replacement

  RULE SimplifyRelImaXY.18
	rewrite  ({a|->b}[u])  in  ({b})
		if (a: u) is in hypothesis
		if (a: u) does not contain non-free variables in replacement

  RULE SimplifyRelImaXY.19
	rewrite  ({a|->b}[{c}])  in  ({})
		if tactic (Fast_Prove_Difference) proves (not(a = c))
		if (not(a = c)) does not contain non-free variables in replacement

  RULE SimplifyRelImaXY.20
	always rewrite (succ[a..b]) in (succ(a)..succ(b))

  RULE SimplifyRelImaXY.21
	always rewrite (pred[a..b]) in (pred(a)..pred(b))

  RULE SimplifyRelImaXY.22
	always rewrite (id(u)[v]) in (u/\v)

  RULE SimplifyRelImaXY.23
	always rewrite ((r;s)[v]) in (s[r[v]])

  RULE SimplifyRelImaXY.24
	always rewrite ((u<|r)[v]) in (r[u/\v])

  RULE SimplifyRelImaXY.25
	always rewrite ((u<<|r)[v]) in (r[v-u])

  RULE SimplifyRelImaXY.26
	always rewrite ((u<<|r)[u]) in ({})

  RULE SimplifyRelImaXY.27
	always rewrite ((r|>u)[v]) in (r[v]/\u)

  RULE SimplifyRelImaXY.28
	always rewrite ((r|>>u)[v]) in (r[v]-u)

  RULE SimplifyRelImaXY.29
	always rewrite ((u<<|r)~[v]) in (r~[v]-u)

  RULE SimplifyRelImaXY.30
	always rewrite ((r|>u)~[u]) in (r~[u])

  RULE SimplifyRelImaXY.31
	always rewrite ((r|>>u)~[u]) in ({})

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

  RULE SimplifyRelImaXY.33
	always rewrite ((r><s)[u]) in (r~;u<|s)

  RULE SimplifyRelImaXY.34
	always rewrite ((r || s)[u*v]) in (r[u]*s[v])

  RULE SimplifyRelImaXY.35
	always rewrite (({a}*p)[{a}]) in (p)

  RULE SimplifyRelImaXY.36
	always rewrite ({FALSE|->a}[{TRUE}]) in ({})

  RULE SimplifyRelImaXY.37
	always rewrite ({TRUE|->a}[{FALSE}]) in ({})

  RULE SimplifyRelImaXY.38
	always rewrite (r[{}]) in ({})

  RULE SimplifyRelImaXY.39
	always rewrite ({}[a]) in ({})

  RULE SimplifyRelImaXY.40
	always rewrite (r[dom(r)]) in (ran(r))

  RULE SimplifyRelImaXY.41
	always rewrite (r~[ran(r)]) in (dom(r))

  RULE SimplifyRelImaXY.42
	always rewrite ({a|->b}[{a}]) in ({b})


-------------------------------------------------------------------
THEORY SimplifyRelInvXY IS

  RULE SimplifyRelInvXY.1
	rewrite  ((SET(x,y).P)~)  in  (SET(y,x).P)
		not if (x) matches on (u,v)

  RULE SimplifyRelInvXY.2
	always rewrite ({a|->b}~) in ({b|->a})

  RULE SimplifyRelInvXY.3
	always rewrite (id(u)~) in (id(u))

  RULE SimplifyRelInvXY.4
	always rewrite ((r;s)~) in (s~;r~)

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

  RULE SimplifyRelInvXY.6
	always rewrite ((u<|r)~) in (r~|>u)

  RULE SimplifyRelInvXY.7
	always rewrite ((u<<|r)~) in (r~|>>u)

  RULE SimplifyRelInvXY.8
	always rewrite ((r|>u)~) in (u<|r~)

  RULE SimplifyRelInvXY.9
	always rewrite ((r|>>u)~) in (u<<|r~)

  RULE SimplifyRelInvXY.10
	always rewrite ((u*v)~) in (v*u)

  RULE SimplifyRelInvXY.11
	always rewrite ((r || s)~) in (r~ || s~)

  RULE SimplifyRelInvXY.12
	always rewrite ((r/\s)~) in (r~/\s~)

  RULE SimplifyRelInvXY.13
	always rewrite ((r\/s)~) in (r~\/s~)

  RULE SimplifyRelInvXY.14
	always rewrite ((r-s)~) in (r~-s~)

  RULE SimplifyRelInvXY.15
	always rewrite (r~~) in (r)

  RULE SimplifyRelInvXY.16
	always rewrite ({}~) in ({})

  RULE SimplifyRelInvXY.17
	always rewrite (pred~) in (succ)

  RULE SimplifyRelInvXY.18
	always rewrite (succ~) in (pred)


-------------------------------------------------------------------
THEORY SimplifyRelOveXY IS

  RULE SimplifyRelOveXY.1
	rewrite  (r<+s)  in  (r\/s)
		if (dom(s)<|r = dom(r)<|s) is in hypothesis
		if (dom(s)<|r = dom(r)<|s) does not contain non-free variables in replacement

  RULE SimplifyRelOveXY.2
	rewrite  ({a|->b}<+{c|->d})  in  ({a|->b}\/{c|->d})
		if tactic (Fast_Prove_Difference) proves (not(a = c))
		if (a = c) does not contain non-free variables in replacement

  RULE SimplifyRelOveXY.3
	rewrite  (r~<+{a|->b})  in  (r~\/{a|->b})
		if (not(a: ran(r))) is in hypothesis
		if (a: ran(r)) does not contain non-free variables in replacement

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

  RULE SimplifyRelOveXY.5
	always rewrite (f<+{x|->f(x)}) in (f)

  RULE SimplifyRelOveXY.6
	rewrite  (f<+g)  in  (f)
		if (g: POW(f)) is in hypothesis
		if (f: s +-> t) is in hypothesis
		if (g: POW(f)) does not contain non-free variables in replacement

  RULE SimplifyRelOveXY.7
	rewrite  (f<+g<+{x|->y})  in  (f<+{x|->y}<+g)
		if (not(x: dom(g))) is in hypothesis
		if (x: dom(g)) does not contain non-free variables in replacement

  RULE SimplifyRelOveXY.8
	rewrite  (r<+(s<+t))  in  (r<+s<+t)
		not prove (bpattern(s,{a}) & bpattern(t,{b}))

  RULE SimplifyRelOveXY.9
	always rewrite (r<+{a}<+{b}) in (r<+({a}<+{b}))

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

  RULE SimplifyRelOveXY.11
	always rewrite ({a}*v<+{a|->b}) in ({a|->b})

  RULE SimplifyRelOveXY.12
	always rewrite ({}<+r) in (r)

  RULE SimplifyRelOveXY.13
	always rewrite (r<+{}) in (r)

  RULE SimplifyRelOveXY.14
	always rewrite ({a|->b}<+{a|->c}) in ({a|->c})


-------------------------------------------------------------------
THEORY SimplifyRelRaaLongXY IS

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

  RULE SimplifyRelRaaLongXY.2
	always rewrite (r|>>(u\/v)) in (r|>>u/\(r|>>v))

  RULE SimplifyRelRaaLongXY.3
	always rewrite (r|>>(u/\v)) in (r|>>u\/(r|>>v))

  RULE SimplifyRelRaaLongXY.4
	always rewrite (r|>>u-v) in (r|>>u\/(r|>v))

  RULE SimplifyRelRaaLongXY.5
	always rewrite (r/\s|>>u) in (r|>>u/\(s|>>u))

  RULE SimplifyRelRaaLongXY.6
	always rewrite (r\/s|>>u) in (r|>>u\/(s|>>u))


-------------------------------------------------------------------
THEORY SimplifyRelRaaXY IS

  RULE SimplifyRelRaaXY.1
	rewrite  ({a|->b}|>>{c})  in  ({a|->b})
		if tactic (Fast_Prove_Difference) proves (not(b = c))
		if (not(b = c)) does not contain non-free variables in replacement

  RULE SimplifyRelRaaXY.2
	rewrite  (r|>>{a})  in  (r)
		if (not(a: ran(r))) is in hypothesis
		if (not(a: ran(r))) does not contain non-free variables in replacement

  RULE SimplifyRelRaaXY.3
	rewrite  ({a|->b}|>>u)  in  ({a|->b})
		if (not(b: u)) is in hypothesis
		if (not(b: u)) does not contain non-free variables in replacement

  RULE SimplifyRelRaaXY.4
	rewrite  ({a|->b}|>>u)  in  ({})
		if (b: u) is in hypothesis
		if (b: u) does not contain non-free variables in replacement

  RULE SimplifyRelRaaXY.5
	rewrite  (r|>>u)  in  ({})
		if (ran(r): POW(u)) is in hypothesis
		if (ran(r): POW(u)) does not contain non-free variables in replacement

  RULE SimplifyRelRaaXY.6
	rewrite  (r|>>u)  in  (r)
		if (ran(r)/\u = {}) is in hypothesis
		if (ran(r)/\u = {}) does not contain non-free variables in replacement

  RULE SimplifyRelRaaXY.7
	rewrite  (r|>>u)  in  (r)
		if (u/\ran(r) = {}) is in hypothesis
		if (u/\ran(r) = {}) does not contain non-free variables in replacement

  RULE SimplifyRelRaaXY.8
	rewrite  (f|>>f[w])  in  (w<<|f)
		if (f~: u +-> v) is in hypothesis
		if (f~: u +-> v) does not contain non-free variables in replacement

  RULE SimplifyRelRaaXY.9
	rewrite  (r~|>>{a})  in  (r~)
		if (not(a: dom(r))) is in hypothesis
		if (a: dom(r)) does not contain non-free variables in replacement

  RULE SimplifyRelRaaXY.10
	rewrite  (SET(x,y).(x: S & y: T & P)|>>u)  in  (SET(x,y).(x: S & y: T-u & P))
		if (x,y) is a variable list whith no free occurences in (u)

  RULE SimplifyRelRaaXY.11
	always rewrite ((r;s)|>>u) in (r;s|>>u)

  RULE SimplifyRelRaaXY.12
	always rewrite (id(u)|>>v) in (id(u-v))

  RULE SimplifyRelRaaXY.13
	always rewrite (r|>u|>>v) in (r|>u-v)

  RULE SimplifyRelRaaXY.14
	always rewrite (r|>>u|>>v) in (r|>>(u\/v))

  RULE SimplifyRelRaaXY.15
	always rewrite (u*v|>>t) in (u*(v-t))

  RULE SimplifyRelRaaXY.16
	always rewrite (u*v|>>v) in ({})

  RULE SimplifyRelRaaXY.17
	always rewrite (r-s|>>u) in ((r|>>u)-s)

  RULE SimplifyRelRaaXY.18
	always rewrite (r|>>ran(r)) in ({})

  RULE SimplifyRelRaaXY.19
	always rewrite ({}|>>u) in ({})

  RULE SimplifyRelRaaXY.20
	always rewrite (r|>>{}) in (r)

  RULE SimplifyRelRaaXY.21
	always rewrite ({a|->b}|>>{b}) in ({})


-------------------------------------------------------------------
THEORY SimplifyRelRanXY IS

  RULE SimplifyRelRanXY.1
	rewrite  (ran(u<<|r))  in  (ran(r)-r[u])
		if (r~: s +-> t) is in hypothesis
		if (r~: s +-> t) does not contain non-free variables in replacement

  RULE SimplifyRelRanXY.2
	rewrite  (ran(u*v))  in  (v)
		if (not(u = {})) is in hypothesis
		if (u) does not contain non-free variables in replacement

  RULE SimplifyRelRanXY.3
	rewrite  (ran(f-g))  in  (ran(f)-ran(g))
		if (g: POW(f)) is in hypothesis
		if (f~: b +-> a) is in hypothesis
		if (f~: b +-> a & g: POW(f)) does not contain non-free variables in replacement

  RULE SimplifyRelRanXY.4
	rewrite  (ran(prj1(A,B)))  in  (A)
		if (not(B = {})) is in hypothesis
		if (B) does not contain non-free variables in replacement

  RULE SimplifyRelRanXY.5
	rewrite  (ran(prj2(A,B)))  in  (B)
		if (not(A = {})) is in hypothesis
		if (A) does not contain non-free variables in replacement

  RULE SimplifyRelRanXY.6
	always rewrite (ran(succ)) in (INTEGER)

  RULE SimplifyRelRanXY.7
	always rewrite (ran(pred)) in (INTEGER)

  RULE SimplifyRelRanXY.8
	always rewrite (ran(r;s)) in (s[ran(r)])

  RULE SimplifyRelRanXY.9
	always rewrite (ran(id(u))) in (u)

  RULE SimplifyRelRanXY.10
	always rewrite (ran(r|>u)) in (ran(r)/\u)

  RULE SimplifyRelRanXY.11
	always rewrite (ran(r|>>u)) in (ran(r)-u)

  RULE SimplifyRelRanXY.12
	always rewrite (ran(r~)) in (dom(r))

  RULE SimplifyRelRanXY.13
	always rewrite (ran(r<+s)) in (ran(dom(s)<<|r)\/ran(s))

  RULE SimplifyRelRanXY.14
	always rewrite (ran({a}*v)) in (v)

  RULE SimplifyRelRanXY.15
	always rewrite (ran(r || s)) in (ran(r)*ran(s))

  RULE SimplifyRelRanXY.16
	always rewrite (ran(f><g)) in (f~;g)

  RULE SimplifyRelRanXY.17
	always rewrite (ran(r\/s)) in (ran(r)\/ran(s))

  RULE SimplifyRelRanXY.18
	always rewrite (ran({a|->b})) in ({b})

  RULE SimplifyRelRanXY.19
	always rewrite (ran({})) in ({})

  RULE SimplifyRelRanXY.20
	always rewrite (ran(u<|r)) in (r[u])


-------------------------------------------------------------------
THEORY SimplifyRelRarLongXY IS

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

  RULE SimplifyRelRarLongXY.2
	always rewrite (r/\s|>a) in (r|>a/\(s|>a))

  RULE SimplifyRelRarLongXY.3
	always rewrite (r\/s|>a) in (r|>a\/(s|>a))

  RULE SimplifyRelRarLongXY.4
	always rewrite (r|>a-b) in ((r|>a)-(r|>b))

  RULE SimplifyRelRarLongXY.5
	always rewrite (r|>(a/\b)) in (r|>a/\(r|>b))

  RULE SimplifyRelRarLongXY.6
	always rewrite (r|>(a\/b)) in (r|>a\/(r|>b))


-------------------------------------------------------------------
THEORY SimplifyRelRarXY IS

  RULE SimplifyRelRarXY.1
	rewrite  (f\/{a|->b}|>{b})  in  ({a|->b})
		if (not(b: ran(f))) is in hypothesis
		if (b: ran(f)) does not contain non-free variables in replacement

  RULE SimplifyRelRarXY.2
	rewrite  (r|>ran(s))  in  (r)
		if (r: POW(s)) is in hypothesis
		if (r: POW(s)) does not contain non-free variables in replacement

  RULE SimplifyRelRarXY.3
	rewrite  (u*v|>w)  in  (u*w)
		if (w: POW(v)) is in hypothesis
		if (w: POW(v)) does not contain non-free variables in replacement

  RULE SimplifyRelRarXY.4
	rewrite  (u*v|>w)  in  (u*v)
		if (v: POW(w)) is in hypothesis
		if (v: POW(w)) does not contain non-free variables in replacement

  RULE SimplifyRelRarXY.5
	rewrite  (u*v|>w)  in  ({})
		if (v/\w = {}) is in hypothesis
		if (v/\w = {}) does not contain non-free variables in replacement

  RULE SimplifyRelRarXY.6
	rewrite  ((r;s)|>v)  in  ({})
		if (v/\ran(s) = {}) is in hypothesis
		if (v/\ran(s) = {}) does not contain non-free variables in replacement

  RULE SimplifyRelRarXY.7
	rewrite  (id(u)|>v)  in  (id(v))
		if (v: POW(u)) is in hypothesis
		if (v: POW(u)) does not contain non-free variables in replacement

  RULE SimplifyRelRarXY.8
	rewrite  (id(u)|>v)  in  ({})
		if (u/\v = {}) is in hypothesis
		if (u/\v = {}) does not contain non-free variables in replacement

  RULE SimplifyRelRarXY.9
	rewrite  ({a|->b}|>v)  in  ({a|->b})
		if (b: v) is in hypothesis
		if (b: v) does not contain non-free variables in replacement

  RULE SimplifyRelRarXY.10
	rewrite  ({a|->b}|>v)  in  ({})
		if (not(b: v)) is in hypothesis
		if (not(b: v)) does not contain non-free variables in replacement

  RULE SimplifyRelRarXY.11
	rewrite  (r|>v)  in  (r)
		if (ran(r): POW(v)) is in hypothesis
		if (ran(r): POW(v)) does not contain non-free variables in replacement

  RULE SimplifyRelRarXY.12
	rewrite  (r|>v)  in  ({})
		if (v/\ran(r) = {}) is in hypothesis
		if (v/\ran(r) = {}) does not contain non-free variables in replacement

  RULE SimplifyRelRarXY.13
	rewrite  (r|>v)  in  ({})
		if (ran(r)/\v = {}) is in hypothesis
		if (ran(r)/\v = {}) does not contain non-free variables in replacement

  RULE SimplifyRelRarXY.14
	rewrite  ({a|->b}|>{c})  in  ({})
		if tactic (Fast_Prove_Difference) proves (not(b = c))
		if (not(b = c)) does not contain non-free variables in replacement

  RULE SimplifyRelRarXY.15
	rewrite  (f|>{b})  in  ({f~(b)|->b})
		if (f~: v +-> u) is in hypothesis
		if (b: ran(f)) is in hypothesis
		if (b,f) does not contain non-free variables in replacement

  RULE SimplifyRelRarXY.16
	rewrite  (f|>{f(a)})  in  ({a|->f(a)})
		if (f~: v +-> u) is in hypothesis
		if (f~: v +-> u) does not contain non-free variables in replacement

  RULE SimplifyRelRarXY.17
	rewrite  (r|>{a})  in  ({})
		if (not(a: ran(r))) is in hypothesis
		if (not(a: ran(r))) does not contain non-free variables in replacement

  RULE SimplifyRelRarXY.18
	rewrite  (r~|>{a})  in  ({})
		if (not(a: dom(r))) is in hypothesis
		if (not(a: dom(r))) does not contain non-free variables in replacement

  RULE SimplifyRelRarXY.19
	rewrite  (f|>f[w])  in  (w<|f)
		if (f~: v +-> u) is in hypothesis
		if (f~: v +-> u) does not contain non-free variables in replacement

  RULE SimplifyRelRarXY.20
	rewrite  (SET(x,y).(x: S & y: T & P)|>u)  in  (SET(x,y).(x: S & y: T/\u & P))
		if (x,y) is a variable list whith no free occurences in (u)

  RULE SimplifyRelRarXY.21
	always rewrite (id(u)|>v) in (id(u/\v))

  RULE SimplifyRelRarXY.22
	always rewrite (u*v|>w) in (u*(v/\w))

  RULE SimplifyRelRarXY.23
	always rewrite (r|>v|>w) in (r|>(v/\w))

  RULE SimplifyRelRarXY.24
	always rewrite (r|>>v|>w) in (r|>w-v)

  RULE SimplifyRelRarXY.25
	always rewrite (r><s|>u*v) in (r|>u><(s|>v))

  RULE SimplifyRelRarXY.26
	always rewrite ((r || s)|>u*v) in (r|>u || s|>v)

  RULE SimplifyRelRarXY.27
	always rewrite (r-s|>v) in ((r|>v)-s)

  RULE SimplifyRelRarXY.28
	always rewrite (r~|>dom(r)) in (r~)

  RULE SimplifyRelRarXY.29
	always rewrite (r|>ran(r)) in (r)

  RULE SimplifyRelRarXY.30
	always rewrite (u*v|>v) in (u*v)

  RULE SimplifyRelRarXY.31
	always rewrite ({a|->b}|>{b}) in ({a|->b})

  RULE SimplifyRelRarXY.32
	always rewrite ({}|>a) in ({})

  RULE SimplifyRelRarXY.33
	always rewrite (r|>{}) in ({})


-------------------------------------------------------------------
THEORY SimplifySeqDomXY IS

  RULE SimplifySeqDomXY.1
	always rewrite (dom(s/|\n)) in (1..n)

  RULE SimplifySeqDomXY.2
	rewrite  (dom(conc(s)))  in  (1..SIGMA(y).(y: 1..size(s) | size(s(y))))
		if (y) is a fresh variable in (s)

  RULE SimplifySeqDomXY.3
	rewrite  (dom(f(x)))  in  (1..size(f(x)))
		if (f: s --> seq(t)) is in hypothesis
		if (f: s --> seq(t)) does not contain non-free variables in replacement

  RULE SimplifySeqDomXY.4
	rewrite  (dom(s))  in  (1..size(s))
		if (s: seq(e)) is in hypothesis
		if (s: seq(e)) does not contain non-free variables in replacement

  RULE SimplifySeqDomXY.5
	always rewrite (dom(tail(s))) in (1..size(s)-1)

  RULE SimplifySeqDomXY.6
	always rewrite (dom(s\|/n)) in (1..size(s)-n)

  RULE SimplifySeqDomXY.7
	always rewrite (dom(front(s))) in (1..size(s)-1)

  RULE SimplifySeqDomXY.8
	always rewrite (dom(s^t)) in (1..size(s)+size(t))

  RULE SimplifySeqDomXY.9
	always rewrite (dom(rev(s))) in (dom(s))

  RULE SimplifySeqDomXY.10
	always rewrite (dom(a->s)) in (1..size(s)+1)

  RULE SimplifySeqDomXY.11
	always rewrite (dom(s<-a)) in (1..size(s)+1)


-------------------------------------------------------------------
THEORY SimplifySeqOpeXY IS

  RULE SimplifySeqOpeXY.1
	rewrite  (a/|\n)  in  (a)
		if (size(a)<=n) is in hypothesis
		if (size(a)<=n) does not contain non-free variables in replacement

  RULE SimplifySeqOpeXY.2
	rewrite  (a\|/n)  in  ({})
		if (size(a) = n) is in hypothesis
		if (size(a) = n) does not contain non-free variables in replacement

  RULE SimplifySeqOpeXY.3
	rewrite  (tail(a<-b))  in  (tail(a)<-b)
		if (n<=size(a)) is in hypothesis
		if (n>0) is litteraly true
		if (n<=size(a)) does not contain non-free variables in replacement

  RULE SimplifySeqOpeXY.4
	rewrite  (tail(a^b))  in  (tail(a)^b)
		if (not(a = {})) is in hypothesis
		if (a) does not contain non-free variables in replacement

  RULE SimplifySeqOpeXY.5
	rewrite  (s<+{1|->b})  in  (b->tail(s))
		if (n<=size(s)) is in hypothesis
		if (n>0) is litteraly true
		if (n<=size(s)) does not contain non-free variables in replacement

  RULE SimplifySeqOpeXY.6
	rewrite  (front(a->b))  in  (a->front(b))
		if (n<=size(b)) is in hypothesis
		if (n>0) is litteraly true
		if (n<=size(b)) does not contain non-free variables in replacement

  RULE SimplifySeqOpeXY.7
	rewrite  (front(a^b))  in  (a^front(b))
		if (not(b = {})) is in hypothesis
		if (b) does not contain non-free variables in replacement

  RULE SimplifySeqOpeXY.8
	rewrite  (first(a^b))  in  (first(a))
		if (not(a = {})) is in hypothesis
		if (a^b) does not contain non-free variables in replacement

  RULE SimplifySeqOpeXY.9
	rewrite  (first(a<-b))  in  (first(a))
		if (n<=size(a)) is in hypothesis
		if (n>0) is litteraly true
		if (n<=size(a)) does not contain non-free variables in replacement

  RULE SimplifySeqOpeXY.10
	rewrite  (last(a^b))  in  (last(b))
		if (not(b = {})) is in hypothesis
		if (not(b = {})) does not contain non-free variables in replacement

  RULE SimplifySeqOpeXY.11
	rewrite  (last(s<+{size(s)|->b}))  in  (b)
		if (s: seq(e)) is in hypothesis
		if (n<=size(s)) is in hypothesis
		if (n>0) is litteraly true
		if Q is the list of active non-free variables in replacement
		if (Q) is a variable list whith no free occurences in (s: seq(e))
		if (Q) is a variable list whith no free occurences in (n<=size(s))

  RULE SimplifySeqOpeXY.12
	rewrite  (last(a->b))  in  (last(b))
		if (n<=size(b)) is in hypothesis
		if (n>0) is litteraly true
		if (n<=size(b)) does not contain non-free variables in replacement

  RULE SimplifySeqOpeXY.13
	rewrite  ((s<-b)(n))  in  (s(n))
		if (n: 1..size(s)) is in hypothesis
		if (n: 1..size(s)) does not contain non-free variables in replacement

  RULE SimplifySeqOpeXY.14
	rewrite  ((a->s)(n))  in  (s(n-1))
		if (not(s = {})) is in hypothesis
		if (n: 2..size(s)+1) is in hypothesis
		if Q is the list of active non-free variables in replacement
		if (Q) is a variable list whith no free occurences in (not(s) = {})
		if (Q) is a variable list whith no free occurences in (n: 2..size(s)+1)

  RULE SimplifySeqOpeXY.15
	rewrite  (s<+t<-r)  in  (s<-r<+t)
		if (s: seq(a)) is in hypothesis
		if (t: 1..size(s) +-> b) is in hypothesis
		if Q is the list of active non-free variables in replacement
		if (Q) is a variable list whith no free occurences in (s: seq(a))
		if (Q) is a variable list whith no free occurences in (t: 1..size(s) +-> b)

  RULE SimplifySeqOpeXY.16
	always rewrite (a^{}) in (a)

  RULE SimplifySeqOpeXY.17
	always rewrite ({}^a) in (a)

  RULE SimplifySeqOpeXY.18
	always rewrite (tail(s)) in (s\|/1)

  RULE SimplifySeqOpeXY.19
	always rewrite (tail(a->b)) in (b)

  RULE SimplifySeqOpeXY.20
	rewrite  (tail([a]))  in  ({})
		not if (a) matches on (u,v)

  RULE SimplifySeqOpeXY.21
	always rewrite (tail([a,b])) in (tail([a])<-b)

  RULE SimplifySeqOpeXY.22
	always rewrite (front(s)) in (s/|\size(s)-1)

  RULE SimplifySeqOpeXY.23
	always rewrite (front(a<-b)) in (a)

  RULE SimplifySeqOpeXY.24
	rewrite  (front([a]))  in  ({})
		not if (a) matches on (u,v)

  RULE SimplifySeqOpeXY.25
	always rewrite (front([a,b])) in ([a])

  RULE SimplifySeqOpeXY.26
	rewrite  (first([a]))  in  (a)
		not if (a) matches on (u,v)

  RULE SimplifySeqOpeXY.27
	always rewrite (first([a,b])) in (first([a]))

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

  RULE SimplifySeqOpeXY.29
	always rewrite (first(a->b)) in (a)

  RULE SimplifySeqOpeXY.30
	rewrite  (last([a]))  in  (a)
		not if (a) matches on (u,v)

  RULE SimplifySeqOpeXY.31
	always rewrite (last([a,b])) in (b)

  RULE SimplifySeqOpeXY.32
	always rewrite (last(a<-b)) in (b)

  RULE SimplifySeqOpeXY.33
	rewrite  (rev([a]))  in  ([a])
		not if (a) matches on (u,v)

  RULE SimplifySeqOpeXY.34
	always rewrite (rev([a,b])) in (b->rev([a]))

  RULE SimplifySeqOpeXY.35
	rewrite  ({}<-a)  in  ([a])
		not if (a) matches on (x,y)

  RULE SimplifySeqOpeXY.36
	always rewrite ([a]<-b) in ([a,b])

  RULE SimplifySeqOpeXY.37
	rewrite  (a->{})  in  ([a])
		not if (a) matches on (x,y)

  RULE SimplifySeqOpeXY.38
	rewrite  (a->[b])  in  ([l])
		not if (a) matches on (x,y)
		if tactic (FLAT;RES) proves (bresult(bflat(a,b))) and gives result (l)

  RULE SimplifySeqOpeXY.39
	always rewrite (a->[b,c]) in (a->[b]<-c)

  RULE SimplifySeqOpeXY.40
	always rewrite ((s<-b)(size(s)+1)) in (b)

  RULE SimplifySeqOpeXY.41
	always rewrite ((a->s)(2)) in (first(s))

  RULE SimplifySeqOpeXY.42
	always rewrite ((a->s)(1)) in (a)


-------------------------------------------------------------------
THEORY SimplifySeqRanXY IS

  RULE SimplifySeqRanXY.1
	always rewrite (ran(s/|\n)) in (s[1..n])

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

  RULE SimplifySeqRanXY.3
	rewrite  (ran(conc(s)))  in  (UNION(y).(y: ran(s) | ran(y)))
		if (y) is a fresh variable in (s)

  RULE SimplifySeqRanXY.4
	rewrite  (ran(tail(s)))  in  (ran(s)-{first(s)})
		if (s: seq(A)) is in hypothesis
		if (s~: A +-> NATURAL) is in hypothesis
		if (s: seq(A)) does not contain non-free variables in replacement

  RULE SimplifySeqRanXY.5
	rewrite  (ran(front(s)))  in  (ran(s)-{last(s)})
		if (s: seq(A)) is in hypothesis
		if (s~: A +-> NATURAL) is in hypothesis
		if (s: seq(A)) does not contain non-free variables in replacement

  RULE SimplifySeqRanXY.6
	always rewrite (ran({})) in ({})

  RULE SimplifySeqRanXY.7
	always rewrite (ran(s^t)) in (ran(s)\/ran(t))

  RULE SimplifySeqRanXY.8
	always rewrite (ran(rev(s))) in (ran(s))

  RULE SimplifySeqRanXY.9
	rewrite  (ran(a->s))  in  ({a}\/ran(s))
		not if (a) matches on (x,y)

  RULE SimplifySeqRanXY.10
	rewrite  (ran(s<-a))  in  ({a}\/ran(s))
		not if (a) matches on (x,y)


-------------------------------------------------------------------
THEORY SimplifySeqSizXY IS

  RULE SimplifySeqSizXY.1
	always rewrite (size(tail(s))) in (size(s)-1)

  RULE SimplifySeqSizXY.2
	always rewrite (size(front(s))) in (size(s)-1)

  RULE SimplifySeqSizXY.3
	always rewrite (size(s/|\n)) in (n)

  RULE SimplifySeqSizXY.4
	rewrite  (size(s<+{n|->a}))  in  (size(s))
		if (s: seq(e)) is in hypothesis
		if (n<=size(s)) is in hypothesis
		if (n>0) is litteraly true
		if Q is the list of active non-free variables in replacement
		if (Q) is a variable list whith no free occurences in (s: seq(e))
		if (Q) is a variable list whith no free occurences in (n<=size(s))

  RULE SimplifySeqSizXY.5
	rewrite  (size(s<+{n|->a}))  in  (size(s))
		if (n: dom(s)) is in hypothesis
		if (s: seq(A)) is in hypothesis
		if (n: dom(s)) does not contain non-free variables in replacement

  RULE SimplifySeqSizXY.6
	rewrite  (size(s<+{size(s)|->n}))  in  (size(s))
		if (s: seq(e)) is in hypothesis
		if (n<=size(s)) is in hypothesis
		if (n>0) is litteraly true
		if Q is the list of active non-free variables in replacement
		if (Q) is a variable list whith no free occurences in (s: seq(e))
		if (Q) is a variable list whith no free occurences in (n<=size(s))

  RULE SimplifySeqSizXY.7
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE SimplifySeqSizXY.8
	always rewrite (size(s\|/n)) in (size(s)-n)

  RULE SimplifySeqSizXY.9
	rewrite  (size(%x.(x: 1..n | E)))  in  (n)
		if (0<=n) is in hypothesis
		if (n) does not contain non-free variables in replacement
		if (x) is a variable list whith no free occurences in (n)

  RULE SimplifySeqSizXY.10
	rewrite  (size(s<+t))  in  (size(s))
		if (s: seq(a)) is in hypothesis
		if (t: dom(s) +-> b) is in hypothesis
		if Q is the list of active non-free variables in replacement
		if (Q) is a variable list whith no free occurences in (s: seq(a))
		if (Q) is a variable list whith no free occurences in (t: dom(s) +-> b)

  RULE SimplifySeqSizXY.11
	rewrite  (size(s<+t))  in  (size(s))
		if (s: seq(a)) is in hypothesis
		if (t: 1..size(s) +-> b) is in hypothesis
		if Q is the list of active non-free variables in replacement
		if (Q) is a variable list whith no free occurences in (s: seq(a))
		if (Q) is a variable list whith no free occurences in (t: 1..size(s) +-> b)

  RULE SimplifySeqSizXY.12
	rewrite  (size([a]))  in  (1)
		not if (a) matches on (u,v)

  RULE SimplifySeqSizXY.13
	always rewrite (size(s<-x)) in (size(s)+1)

  RULE SimplifySeqSizXY.14
	always rewrite (size(x->s)) in (size(s)+1)

  RULE SimplifySeqSizXY.15
	always rewrite (size(s^t)) in (size(s)+size(t))

  RULE SimplifySeqSizXY.16
	always rewrite (size(rev(s))) in (size(s))

  RULE SimplifySeqSizXY.17
	always rewrite (size([a,b])) in (size([a])+1)

  RULE SimplifySeqSizXY.18
	always rewrite (size({1|->b})) in (1)

  RULE SimplifySeqSizXY.19
	always rewrite (size({})) in (0)


-------------------------------------------------------------------
THEORY SimplifyTryEnsCard IS

  RULE SimplifyTryEnsCard.1
	rewrite  (card(f|>>u))  in  (card(ran(f))-card(ran(f)/\u))
		if (f~: a +-> b) is in hypothesis
		if we make a successfull attempt to prove (ran(f): FIN(a)) with current prover force
		if (f~: a +-> b) does not contain non-free variables in replacement

  RULE SimplifyTryEnsCard.2
	rewrite  (card(u<<|f))  in  (card(dom(f))-card(u/\dom(f)))
		if (f: a +-> b) is in hypothesis
		if we make a successfull attempt to prove (dom(f): FIN(a)) with current prover force
		if (f: a +-> b) does not contain non-free variables in replacement

  RULE SimplifyTryEnsCard.3
	rewrite  (card(A-B))  in  (card(A)-card(A/\B))
		if we make a successfull attempt to prove (A: FIN(A)) with current prover force
		if (A: FIN(A)) does not contain non-free variables in replacement


-------------------------------------------------------------------
THEORY SimplifyEnsCard IS

  RULE SimplifyEnsCard.1
	rewrite  (card(struct(L)))  in  (R)
		if tactic (CardStructMakeProdX) proves (CardStructMakeProdG(L)) and gives result (R)

  RULE SimplifyEnsCard.2
	rewrite  (card(dom(s)))  in  (size(s))
		if (s: seq(e)) is in hypothesis
		if (s: seq(e)) does not contain non-free variables in replacement

  RULE SimplifyEnsCard.3
	rewrite  (card(f))  in  (card(dom(f)))
		if (f: a +-> b) is in hypothesis
		if (f: a +-> b) does not contain non-free variables in replacement

  RULE SimplifyEnsCard.4
	rewrite  (card(u<|f))  in  (card(u/\dom(f)))
		if (f: a +-> b) is in hypothesis
		if (f: a +-> b) does not contain non-free variables in replacement

  RULE SimplifyEnsCard.5
	rewrite  (card(f|>u))  in  (card(ran(f)/\u))
		if (f~: a +-> b) is in hypothesis
		if (f~: a +-> b) does not contain non-free variables in replacement

  RULE SimplifyEnsCard.6
	rewrite  (card(f~[C]))  in  (card(ran(f)/\C))
		if (f: a +-> b) is in hypothesis
		if (f~: b +-> a) is in hypothesis
		if (f: a +-> b) does not contain non-free variables in replacement

  RULE SimplifyEnsCard.7
	rewrite  (card(f[C]))  in  (card(dom(f)/\C))
		if (f: a +-> b) is in hypothesis
		if (f~: b +-> a) is in hypothesis
		if (f: a +-> b) does not contain non-free variables in replacement

  RULE SimplifyEnsCard.8
	always rewrite (card(A\/B)) in (card(A)+card(B)-card(A/\B))

  RULE SimplifyEnsCard.9
	rewrite  (card(a\/{b}))  in  (card(a)+1)
		if (not(b: a)) is in hypothesis
		if (not(b: a)) does not contain non-free variables in replacement

  RULE SimplifyEnsCard.10
	rewrite  (card(m..n))  in  (n-m+1)
		if tactic (Fast_Prove_Order) proves (m<=n)
		if (m<=n) does not contain non-free variables in replacement

  RULE SimplifyEnsCard.11
	rewrite  (card(1..m))  in  (m)
		if (0<=m) is in hypothesis
		if (m) does not contain non-free variables in replacement

  RULE SimplifyEnsCard.12
	rewrite  (card(A*B))  in  (card(A)*card(B))
		if (not(A = {})) is in hypothesis
		if (not(B = {})) is in hypothesis
		if (A,B) does not contain non-free variables in replacement

  RULE SimplifyEnsCard.13
	rewrite  (card(%a.(a: A | E)))  in  (card(A))
		if (a) is a variable list whith no free occurences in (A)

  RULE SimplifyEnsCard.14
	always rewrite (card(id(s))) in (card(s))

  RULE SimplifyEnsCard.15
	always rewrite (card(r~)) in (card(r))

  RULE SimplifyEnsCard.16
	always rewrite (card({a})) in (1)

  RULE SimplifyEnsCard.17
	always rewrite (card({})) in (0)


-------------------------------------------------------------------
THEORY SimplifySetComXY IS

  RULE SimplifySetComXY.1
	rewrite  (SET(x).P*Q)  in  (SET(x,y).(P & y: Q))
		if (y) is a fresh variable in (x,P,Q)
		if (x) is a variable list whith no free occurences in (Q)

  RULE SimplifySetComXY.2
	rewrite  (Q*SET(y).P)  in  (SET(x,y).(x: Q & P))
		if (x) is a fresh variable in (y,P,Q)
		not if (y) matches on (u,v)
		if (y) is a variable list whith no free occurences in (Q)

  RULE SimplifySetComXY.3
	rewrite  (a..b)  in  ({})
		if (b<a) is litteraly true

  RULE SimplifySetComXY.4
	rewrite  (a..b)  in  ({})
		if (b+1<=a) is in hypothesis
		if (b+1<=a) does not contain non-free variables in replacement

  RULE SimplifySetComXY.5
	always rewrite (p..p-1) in ({})

  RULE SimplifySetComXY.6
	always rewrite (p+1..p) in ({})

  RULE SimplifySetComXY.7
	rewrite  (struct(L,l>>E))  in  ({})
		if list (L,l>>E) contains (i>>{})

  RULE SimplifySetComXY.8
	always rewrite (struct(l>>{})) in ({})

  RULE SimplifySetComXY.9
	always rewrite (p..p) in ({p})

  RULE SimplifySetComXY.10
	always rewrite (SET(x).bfalse) in ({})

  RULE SimplifySetComXY.11
	rewrite  (SET(x).(x: S))  in  (S)
		if (x) is a variable list whith no free occurences in (S)

  RULE SimplifySetComXY.12
	always rewrite (SET(x).(x: {})) in ({})

  RULE SimplifySetComXY.13
	always rewrite (POW({})) in ({{}})

  RULE SimplifySetComXY.14
	always rewrite (POW({a})) in ({{}}\/{{a}})

  RULE SimplifySetComXY.15
	always rewrite (a*{}) in ({})

  RULE SimplifySetComXY.16
	always rewrite ({}*a) in ({})

  RULE SimplifySetComXY.17
	always rewrite ((A\/B)*C) in (A*C\/B*C)

  RULE SimplifySetComXY.18
	always rewrite ((A/\B)*C) in (A*C/\B*C)

  RULE SimplifySetComXY.19
	always rewrite (A*(B\/C)) in (A*B\/A*C)

  RULE SimplifySetComXY.20
	always rewrite (A*(B/\C)) in (A*B/\A*C)

  RULE SimplifySetComXY.21
	always rewrite ((a/\b)*A) in (a*A/\b*A)

  RULE SimplifySetComXY.22
	always rewrite ((a\/b)*A) in (a*A\/b*A)

  RULE SimplifySetComXY.23
	always rewrite ({a}*{b}) in ({a|->b})

  RULE SimplifySetComXY.24
	always rewrite ({} <-> s) in (POW({}))

  RULE SimplifySetComXY.25
	always rewrite (s <-> {}) in (POW({}))

  RULE SimplifySetComXY.26
	always rewrite ({} +-> s) in (POW({}))

  RULE SimplifySetComXY.27
	always rewrite (s +-> {}) in (POW({}))


-------------------------------------------------------------------
THEORY SimplifySetIntXY IS

  RULE SimplifySetIntXY.1
	rewrite  (a..b/\c..d)  in  (max({a}\/{c})..min({b}\/{d}))
		if tactic (Fast_Prove_Order) proves (a<=b)
		if tactic (Fast_Prove_Order) proves (c<=d)

  RULE SimplifySetIntXY.2
	rewrite  (B/\A)  in  (C)
		if (A/\B = C) is in hypothesis
		if (A,B,C) does not contain non-free variables in replacement

  RULE SimplifySetIntXY.3
	rewrite  (a\/b/\c)  in  (e/\c)
		if list (a\/b) contains (d) and gives (e) without this element
		if (d/\c = {}) is in hypothesis
		if (d/\c = {}) does not contain non-free variables in replacement

  RULE SimplifySetIntXY.4
	rewrite  (p..q/\{r})  in  ({r})
		if tactic (Fast_Prove_Order) proves (r<=q)
		if tactic (Fast_Prove_Order) proves (p<=r)
		if (p,q,r) does not contain non-free variables in replacement

  RULE SimplifySetIntXY.5
	rewrite  (p..q/\{q})  in  ({q})
		if tactic (Fast_Prove_Order) proves (p<=q)
		if (p,q) does not contain non-free variables in replacement

  RULE SimplifySetIntXY.6
	rewrite  (p..q/\{p})  in  ({p})
		if tactic (Fast_Prove_Order) proves (p<=q)
		if (p<=q) does not contain non-free variables in replacement

  RULE SimplifySetIntXY.7
	rewrite  (c/\d)  in  (h/\i)
		if list (c/\d) contains (a-{b})
		if list (h/\i) contains (g\/{b},c/\d) and gives (g) without this element
		if (b: a) is in hypothesis
		if (b: a) does not contain non-free variables in replacement

  RULE SimplifySetIntXY.8
	rewrite  (b/\c)  in  ({})
		if list (b/\c) contains ({a})
		if (not(a: d)) is in hypothesis
		if list (b/\c) contains (d)
		if (not(a: d)) does not contain non-free variables in replacement

  RULE SimplifySetIntXY.9
	rewrite  ({a}/\b)  in  ({})
		if (not(a: b)) is in hypothesis
		if (a: b) does not contain non-free variables in replacement

  RULE SimplifySetIntXY.10
	rewrite  (b/\{a})  in  ({})
		if (not(a: b)) is in hypothesis
		if (not(a: b)) does not contain non-free variables in replacement

  RULE SimplifySetIntXY.11
	rewrite  (b/\c)  in  (y/\{a})
		if list (b/\c) contains ({a}) and gives (x/\z) without this element
		if (a: d) is in hypothesis
		if list (x/\z) contains (d) and gives (y) without this element
		if (a: d) does not contain non-free variables in replacement

  RULE SimplifySetIntXY.12
	rewrite  ({b}/\a)  in  ({b})
		if (b: a) is in hypothesis
		if (b: a) does not contain non-free variables in replacement

  RULE SimplifySetIntXY.13
	rewrite  (a/\{b})  in  ({b})
		if (b: a) is in hypothesis
		if (b: a) does not contain non-free variables in replacement

  RULE SimplifySetIntXY.14
	rewrite  (a/\b)  in  ({})
		if (ran(a)/\ran(b) = {}) is in hypothesis
		if (ran(a)/\ran(b) = {}) does not contain non-free variables in replacement

  RULE SimplifySetIntXY.15
	rewrite  (a/\b)  in  ({})
		if (dom(a)/\dom(b) = {}) is in hypothesis
		if (dom(a)/\dom(b) = {}) does not contain non-free variables in replacement

  RULE SimplifySetIntXY.16
	rewrite  ({a|->c}/\{b|->d})  in  ({})
		if tactic (Fast_Prove_Difference) proves (not(a = b))
		if (not(a = b)) does not contain non-free variables in replacement

  RULE SimplifySetIntXY.17
	rewrite  ({a|->c}/\{b|->d})  in  ({})
		if tactic (Fast_Prove_Difference) proves (not(c = d))
		if (not(c = d)) does not contain non-free variables in replacement

  RULE SimplifySetIntXY.18
	rewrite  ({a}/\{b})  in  ({})
		if tactic (Fast_Prove_Difference) proves (not(a = b))
		if (not(a = b)) does not contain non-free variables in replacement

  RULE SimplifySetIntXY.19
	rewrite  (a/\b/\c)  in  (r/\c)
		if (c: POW(x)) is in hypothesis
		if list (a/\b) contains (x) and gives (r) without this element
		if (c: POW(x)) does not contain non-free variables in replacement

  RULE SimplifySetIntXY.20
	rewrite  (a/\b)  in  (a)
		if (a: POW(b)) is in hypothesis
		if (a: POW(b)) does not contain non-free variables in replacement

  RULE SimplifySetIntXY.21
	rewrite  (a/\b)  in  (b)
		if (b: POW(a)) is in hypothesis
		if (b: POW(a)) does not contain non-free variables in replacement

  RULE SimplifySetIntXY.22
	rewrite  (b/\(c\/{a}))  in  (b/\c)
		if (not(a: b)) is in hypothesis
		if (not(a: b)) does not contain non-free variables in replacement

  RULE SimplifySetIntXY.23
	rewrite  (c\/{a}/\b)  in  (c/\b)
		if (not(a: b)) is in hypothesis
		if (not(a: b)) does not contain non-free variables in replacement

  RULE SimplifySetIntXY.24
	rewrite  (A/\SET(a).(a: b & c))  in  (SET(a).(a: A/\b & c))
		if (a) is a variable list whith no free occurences in (A)

  RULE SimplifySetIntXY.25
	always rewrite (a..b/\INTEGER) in (a..b)

  RULE SimplifySetIntXY.26
	always rewrite (x..y/\C-{x}) in (x+1..y/\C)

  RULE SimplifySetIntXY.27
	always rewrite (x..y/\C-{y}) in (x..y-1/\C)

  RULE SimplifySetIntXY.28
	always rewrite (a/\b-c) in ((a/\b)-c)

  RULE SimplifySetIntXY.29
	always rewrite (a/\b-a) in ({})

  RULE SimplifySetIntXY.30
	always rewrite (a-b/\c) in ((a/\c)-b)

  RULE SimplifySetIntXY.31
	always rewrite (a-b/\b) in ({})

  RULE SimplifySetIntXY.32
	always rewrite (p..q/\o..q) in (max({p}\/{o})..q)

  RULE SimplifySetIntXY.33
	always rewrite (p..q/\p..r) in (p..min({q}\/{r}))

  RULE SimplifySetIntXY.34
	always rewrite (p..q/\{p-1}) in ({})

  RULE SimplifySetIntXY.35
	always rewrite (p+1..q/\{p}) in ({})

  RULE SimplifySetIntXY.36
	always rewrite (p..q/\{q+1}) in ({})

  RULE SimplifySetIntXY.37
	always rewrite (n..m-1/\{m}) in ({})

  RULE SimplifySetIntXY.38
	always rewrite (a\/b/\b) in (b)

  RULE SimplifySetIntXY.39
	always rewrite (a/\b/\b) in (a/\b)

  RULE SimplifySetIntXY.40
	always rewrite (a/\b/\a) in (a/\b)

  RULE SimplifySetIntXY.41
	always rewrite (a/\a) in (a)

  RULE SimplifySetIntXY.42
	always rewrite ({}/\a) in ({})

  RULE SimplifySetIntXY.43
	always rewrite (a/\{}) in ({})


-------------------------------------------------------------------
THEORY SimplifyTrySetSubXY IS

  RULE SimplifyTrySetSubXY.1
	rewrite  (a-{b})  in  (a)
		if (b: a) does not contain non-free variables in replacement
		if we make a successfull attempt to prove (not(b: a)) with current prover force


-------------------------------------------------------------------
THEORY SimplifySetSubXY IS

  RULE SimplifySetSubXY.1
	rewrite  (A-SET(a).(a: B & P))  in  (A)
		if (A/\B = {}) is in hypothesis
		if (A/\B) does not contain non-free variables in replacement
		if (a) is a variable list whith no free occurences in (B)

  RULE SimplifySetSubXY.2
	rewrite  (A-r[B])  in  (A)
		if (ran(r)/\A = {}) is in hypothesis
		if (ran(r)/\A) does not contain non-free variables in replacement

  RULE SimplifySetSubXY.3
	rewrite  (A-{r(a)})  in  (A)
		if (ran(r): POW(B)) is in hypothesis
		if (A/\B = {}) is in hypothesis
		if (a: dom(r)) is in hypothesis
		if (ran(r): POW(B) & A/\B = {} & a: dom(r)) does not contain non-free variables in replacement

  RULE SimplifySetSubXY.4
	rewrite  (f-g)  in  (dom(g)<<|f)
		if (f: A +-> B) is in hypothesis
		if (g: POW(f)) is in hypothesis
		if (g: POW(f)) does not contain non-free variables in replacement

  RULE SimplifySetSubXY.5
	rewrite  (a-b-(c-b))  in  (a-b-c)
		if (a: POW(e)) is in hypothesis
		if (a: POW(e)) does not contain non-free variables in replacement

  RULE SimplifySetSubXY.6
	rewrite  (a-(b-a))  in  (a)
		if (b: POW(c)) is in hypothesis
		if (b: POW(c)) does not contain non-free variables in replacement

  RULE SimplifySetSubXY.7
	rewrite  (a-(b-a))  in  (a)
		if (a: POW(c)) is in hypothesis
		if (a: POW(c)) does not contain non-free variables in replacement

  RULE SimplifySetSubXY.8
	rewrite  (a-(a-b))  in  (a/\b)
		if (b: POW(c)) is in hypothesis
		if (b: POW(c)) does not contain non-free variables in replacement

  RULE SimplifySetSubXY.9
	rewrite  (a-(a-b))  in  (a/\b)
		if (a: POW(c)) is in hypothesis
		if (a: POW(c)) does not contain non-free variables in replacement

  RULE SimplifySetSubXY.10
	rewrite  (a-b-b)  in  (a-b)
		if (b: POW(c)) is in hypothesis
		if (b: POW(c)) does not contain non-free variables in replacement

  RULE SimplifySetSubXY.11
	rewrite  (a-b-b)  in  (a-b)
		if (a: POW(c)) is in hypothesis
		if (a: POW(c)) does not contain non-free variables in replacement

  RULE SimplifySetSubXY.12
	rewrite  ((a..b)-(c..d))  in  (a..c-1\/d+1..b)
		if tactic (Fast_Prove_Order) proves (a<=c)
		if tactic (Fast_Prove_Order) proves (d<=b)
		if tactic (Fast_Prove_Order) proves (c<=d)
		if (a,b,c,d) does not contain non-free variables in replacement

  RULE SimplifySetSubXY.13
	rewrite  ((a..b)-(a..b-1))  in  ({b})
		if tactic (Fast_Prove_Order) proves (a<=b)
		if (a<=b) does not contain non-free variables in replacement

  RULE SimplifySetSubXY.14
	rewrite  ((a..b)-(a+1..b))  in  ({a})
		if tactic (Fast_Prove_Order) proves (a<=b)
		if (a<=b) does not contain non-free variables in replacement

  RULE SimplifySetSubXY.15
	rewrite  ((a..b)-(a..c))  in  (c+1..b)
		if tactic (Fast_Prove_Order) proves (a<=b)
		if tactic (Fast_Prove_Order) proves (a<=c)
		if (a,b,c) does not contain non-free variables in replacement

  RULE SimplifySetSubXY.16
	rewrite  ((p..q)-{r})  in  (p..q)
		if tactic (Fast_Prove_Order) proves (r+1<=p)
		if (r+1<=p) does not contain non-free variables in replacement

  RULE SimplifySetSubXY.17
	rewrite  ((p..q)-{r})  in  (p..q)
		if tactic (Fast_Prove_Order) proves (q+1<=r)
		if (q+1<=r) does not contain non-free variables in replacement

  RULE SimplifySetSubXY.18
	rewrite  (a-b)  in  ({})
		if (a: POW(b)) is in hypothesis
		if (a: POW(b)) does not contain non-free variables in replacement

  RULE SimplifySetSubXY.19
	rewrite  (a-b)  in  (a)
		if (a/\b = {}) is in hypothesis
		if (a/\b) does not contain non-free variables in replacement

  RULE SimplifySetSubXY.20
	rewrite  ({a}-{b})  in  ({a})
		if tactic (Fast_Prove_Difference) proves (not(a = b))
		if (not(a = b)) does not contain non-free variables in replacement

  RULE SimplifySetSubXY.21
	rewrite  (a-(b\/c))  in  (a-r)
		if (not(x: a)) is in hypothesis
		if list (b\/c) contains ({x}) and gives (r) without this element
		if (x: a) does not contain non-free variables in replacement

  RULE SimplifySetSubXY.22
	rewrite  (b-{a})  in  (b)
		if (not(a: b)) is in hypothesis
		if (not(a: b)) does not contain non-free variables in replacement

  RULE SimplifySetSubXY.23
	rewrite  ({a}-b)  in  ({a})
		if (not(a: b)) is in hypothesis
		if (not(a: b)) does not contain non-free variables in replacement

  RULE SimplifySetSubXY.24
	rewrite  ({a}-b)  in  ({})
		if (a: b) is in hypothesis
		if (a: b) does not contain non-free variables in replacement

  RULE SimplifySetSubXY.25
	rewrite  (a-a)  in  ({})
		if (a: POW(b)) is in hypothesis
		if (a: POW(b)) does not contain non-free variables in replacement

  RULE SimplifySetSubXY.26
	rewrite  ((a\/b)-c)  in  (r-c)
		if list (a\/b) contains (c) and gives (r) without this element

  RULE SimplifySetSubXY.27
	rewrite  ((a/\b)-c)  in  ({})
		if list (a/\b) contains (c)

  RULE SimplifySetSubXY.28
	rewrite  (SET(a).(a: b & c)-A)  in  (SET(a).(a: b-A & c))
		if (a) is a variable list whith no free occurences in (A)

  RULE SimplifySetSubXY.29
	always rewrite ((p..q)-{p-1}) in (p..q)

  RULE SimplifySetSubXY.30
	always rewrite ((p..q)-{p}) in (p+1..q)

  RULE SimplifySetSubXY.31
	always rewrite ((p..q)-{q}) in (p..q-1)

  RULE SimplifySetSubXY.32
	always rewrite ((p+1..q)-{p}) in (p+1..q)

  RULE SimplifySetSubXY.33
	always rewrite ((p..q-1)-{q}) in (p..q-1)

  RULE SimplifySetSubXY.34
	always rewrite ((p..q)-{q+1}) in (p..q)

  RULE SimplifySetSubXY.35
	always rewrite (a-{b}-{b}) in (a-{b})

  RULE SimplifySetSubXY.36
	always rewrite ((a\/c)-(b-c)) in (a-b\/c)

  RULE SimplifySetSubXY.37
	always rewrite (a-(b\/c)) in (a-b-c)

  RULE SimplifySetSubXY.38
	always rewrite (a-{}) in (a)

  RULE SimplifySetSubXY.39
	always rewrite ({}-a) in ({})

  RULE SimplifySetSubXY.40
	always rewrite ({a}-{a}) in ({})


-------------------------------------------------------------------
THEORY SimplifySetUniXY IS

  RULE SimplifySetUniXY.1
	rewrite  (B\/SET(a).(a: A & P))  in  (B)
		if (A: POW(B)) is in hypothesis
		if (A: POW(B)) does not contain non-free variables in replacement
		if (a) is a variable list whith no free occurences in (A)

  RULE SimplifySetUniXY.2
	rewrite  (A\/r[B])  in  (A)
		if (ran(r): POW(A)) is in hypothesis
		if (ran(r): POW(A)) does not contain non-free variables in replacement

  RULE SimplifySetUniXY.3
	rewrite  (A\/{r(a)})  in  (A)
		if (ran(r): POW(A)) is in hypothesis
		if (a: dom(r)) is in hypothesis
		if (a: dom(r) & ran(r): POW(A)) does not contain non-free variables in replacement

  RULE SimplifySetUniXY.4
	rewrite  (a..b\/c..d)  in  (min({a}\/{c})..max({b}\/{d}))
		if tactic (Fast_Prove_Order) proves (a<=b)
		if tactic (Fast_Prove_Order) proves (c<=d)
		if tactic (Fast_Prove_Order) proves (a<=c)
		if tactic (Fast_Prove_Order) proves (c<=b)
		if (a<=b & c<=d) does not contain non-free variables in replacement

  RULE SimplifySetUniXY.5
	rewrite  (s[1..m]\/s[n..size(s)])  in  (ran(s)-s[m+1..n-1])
		if (s: seq(a)) is in hypothesis
		if (s~: a +-> NATURAL) is in hypothesis
		if (s: seq(a)) does not contain non-free variables in replacement

  RULE SimplifySetUniXY.6
	rewrite  (p..q\/{n})  in  (p..q)
		if tactic (Fast_Prove_Order) proves (p<=n)
		if tactic (Fast_Prove_Order) proves (n<=q)
		if (n: p..q) does not contain non-free variables in replacement

  RULE SimplifySetUniXY.7
	rewrite  (p..q-1\/{q})  in  (p..q)
		if tactic (Fast_Prove_Order) proves (p<=q)
		if (p<=q) does not contain non-free variables in replacement

  RULE SimplifySetUniXY.8
	rewrite  (p+1..q\/{p})  in  (p..q)
		if tactic (Fast_Prove_Order) proves (p<=q)
		if (p<=q) does not contain non-free variables in replacement

  RULE SimplifySetUniXY.9
	rewrite  (p..q\/{p-1})  in  (p-1..q)
		if tactic (Fast_Prove_Order) proves (p<=q)
		if (p<=q) does not contain non-free variables in replacement

  RULE SimplifySetUniXY.10
	rewrite  (p..q\/{q+1})  in  (p..q+1)
		if tactic (Fast_Prove_Order) proves (p<=q)
		if (p<=q) does not contain non-free variables in replacement

  RULE SimplifySetUniXY.11
	rewrite  (1..q\/{q+1})  in  (1..q+1)
		if (q: INTEGER) is in hypothesis
		if (0<=q) is in hypothesis
		if (q: INTEGER) does not contain non-free variables in replacement

  RULE SimplifySetUniXY.12
	rewrite  (p..q\/{q})  in  (p..q)
		if tactic (Fast_Prove_Order) proves (p<=q)
		if (p<=q) does not contain non-free variables in replacement

  RULE SimplifySetUniXY.13
	rewrite  (p..q\/{p})  in  (p..q)
		if tactic (Fast_Prove_Order) proves (p<=q)
		if (p<=q) does not contain non-free variables in replacement

  RULE SimplifySetUniXY.14
	rewrite  (a\/b\/c)  in  (a\/b)
		if (c: POW(x)) is in hypothesis
		if list (a\/b) contains (x)
		if (c: POW(x)) does not contain non-free variables in replacement

  RULE SimplifySetUniXY.15
	rewrite  (a\/b)  in  (b)
		if (a: POW(b)) is in hypothesis
		if (a: POW(b)) does not contain non-free variables in replacement

  RULE SimplifySetUniXY.16
	rewrite  (a\/b)  in  (a)
		if (b: POW(a)) is in hypothesis
		if (b: POW(a)) does not contain non-free variables in replacement

  RULE SimplifySetUniXY.17
	rewrite  (b\/c)  in  (x\/z)
		if list (b\/c) contains ({a}) and gives (x\/z) without this element
		if (a: d) is in hypothesis
		if list (x\/z) contains (d)
		if (a: d) does not contain non-free variables in replacement

  RULE SimplifySetUniXY.18
	rewrite  (b\/{a})  in  (b)
		if (a: b) is in hypothesis
		if (a: b) does not contain non-free variables in replacement

  RULE SimplifySetUniXY.19
	rewrite  ({a}\/b)  in  (b)
		if (a: b) is in hypothesis
		if (a: b) does not contain non-free variables in replacement

  RULE SimplifySetUniXY.20
	rewrite  (a\/b\/c)  in  (r\/c)
		if list (a\/b) contains (x/\c) and gives (r) without this element

  RULE SimplifySetUniXY.21
	rewrite  (a\/b\/c-d)  in  (a\/b\/c)
		if list (a\/b) contains (d)

  RULE SimplifySetUniXY.22
	rewrite  (a\/b\/c)  in  (r\/c)
		if list (r) contains (x-c,a\/b) and gives (x) without this element

  RULE SimplifySetUniXY.23
	rewrite  (a\/b\/c)  in  (a\/b)
		if list (a\/b) contains (c)

  RULE SimplifySetUniXY.24
	rewrite  (a..b\/{c})  in  (a..c)
		if tactic (ARI;RES) proves (bresult(b+1)) and gives result (r)
		if (r = c) is litteraly true
		if tactic (Fast_Prove_Order) proves (a<=c)
		if (a) does not contain non-free variables in replacement

  RULE SimplifySetUniXY.25
	rewrite  (a..b\/{c})  in  (c..b)
		if tactic (ARI;RES) proves (bresult(a-1)) and gives result (r)
		if (r = c) is litteraly true
		if tactic (Fast_Prove_Order) proves (c<=b)
		if (b) does not contain non-free variables in replacement

  RULE SimplifySetUniXY.26
	always rewrite (ran({x}<<|f)\/{f(x)}) in (ran(f))

  RULE SimplifySetUniXY.27
	always rewrite (dom(r-s)\/dom(s)) in (dom(r)\/dom(s))

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

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

  RULE SimplifySetUniXY.30
	always rewrite (ran(u<<|r)\/r[u]) in (ran(r))

  RULE SimplifySetUniXY.31
	always rewrite (r[u]\/ran(u<<|r)) in (ran(r))

  RULE SimplifySetUniXY.32
	always rewrite (a/\b\/b) in (b)

  RULE SimplifySetUniXY.33
	always rewrite (a-b\/b) in (a\/b)

  RULE SimplifySetUniXY.34
	always rewrite (a\/a) in (a)

  RULE SimplifySetUniXY.35
	always rewrite ({}\/a) in (a)

  RULE SimplifySetUniXY.36
	always rewrite (a\/{}) in (a)


-------------------------------------------------------------------
THEORY SimplifyStructXY IS

  RULE SimplifyStructXY.1
	rewrite  ((a<<<{b = c})'d)  in  (a'd)
		not if (b) matches on (d)

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

  RULE SimplifyStructXY.3
	always rewrite (a<<<{b = c}<<<{b = d}) in (a<<<{b = d})


-------------------------------------------------------------------
THEORY ContradictionTryXY IS

  RULE ContradictionTryXY.1
	if goal is (P)
		if (not(c: d[{l}])) is in hypothesis
		if (d(l) = c) is in hypothesis
		if (d: s +-> t) is in hypothesis
		if we make a successfull attempt to prove (l: dom(d)) with current prover force
		then initial goal is proved

  RULE ContradictionTryXY.2
	if goal is (P)
		if (n: a) is in hypothesis
		if (not(n: b)) is in hypothesis
		if we make a successfull attempt to prove (a: POW(b)) with current prover force
		then initial goal is proved


-------------------------------------------------------------------
THEORY ContradictionXY IS

  RULE ContradictionXY.1
	if goal is (p)
		if (not(v = a)) is in hypothesis
		if (not(v = b)) is in hypothesis
		not if (a) matches on (b)
		if (v: (i..j)*{E}) is in hypothesis
		if (i) is a numerical constant
		if (j>=i) is litteraly true
		if tactic (ContraEnumAllNotX;ARI~) proves (ContraEnumAllNotG(i | j | v | E))
		then initial goal is proved

  RULE ContradictionXY.2
	if goal is (p)
		if (not(v = a)) is in hypothesis
		if (not(v = b)) is in hypothesis
		not if (a) matches on (b)
		if (v: L\/{e}) is in hypothesis
		if tactic (ContraExtAllNotX) proves (ContraExtAllNotG(L\/{e} | v))
		then initial goal is proved

  RULE ContradictionXY.3
	if goal is (P)
		if (a+1<=card({})) is in hypothesis
		if (a) is a numerical constant
		then initial goal is proved

  RULE ContradictionXY.4
	if goal is (P)
		if (a = b) is in hypothesis
		if (a) is a numerical constant
		if (b) is a numerical constant
		if (a/=b) is litteraly true
		then initial goal is proved

  RULE ContradictionXY.5
	if goal is (P)
		if (a = b) is in hypothesis
		if (c<=a) is in hypothesis
		if (b<c) is litteraly true
		then initial goal is proved

  RULE ContradictionXY.6
	if goal is (P)
		if (not(a = b)) is in hypothesis
		if (a) is a numerical constant
		if (b) is a numerical constant
		if (a = b) is litteraly true
		then initial goal is proved

  RULE ContradictionXY.7
	if goal is (P)
		if (x = x+a) is in hypothesis
		if (a>0) is litteraly true
		then initial goal is proved

  RULE ContradictionXY.8
	if goal is (P)
		if (x+a = x) is in hypothesis
		if (a>0) is litteraly true
		then initial goal is proved

  RULE ContradictionXY.9
	if goal is (P)
		if (x+a = b) is in hypothesis
		if (x) is a numerical constant
		if (a>b) is litteraly true
		then initial goal is proved

  RULE ContradictionXY.10
	if goal is (P)
		if (a+x = b) is in hypothesis
		if (x) is a numerical constant
		if (a>b) is litteraly true
		then initial goal is proved

  RULE ContradictionXY.11
	if goal is (P)
		if (n<=m) is in hypothesis
		if (m<n) is litteraly true
		then initial goal is proved

  RULE ContradictionXY.12
	if goal is (P)
		if (n<=size({})) is in hypothesis
		if (0<n) is litteraly true
		then initial goal is proved

  RULE ContradictionXY.13
	if goal is (P)
		if (m<=n) is in hypothesis
		if (n<=p) is in hypothesis
		if (p<m) is litteraly true
		then initial goal is proved

  RULE ContradictionXY.14
	if goal is (P)
		if (1<=size(s)) is in hypothesis
		if (not(a = first(s))) is in hypothesis
		if (2<=n) is in hypothesis
		if (card(ran(a->s/|\n)) = 1) is in hypothesis
		then initial goal is proved

  RULE ContradictionXY.15
	if goal is (P)
		if (m = n+p) is in hypothesis
		if (m<p) is litteraly true
		if (n: a..b) is in hypothesis
		if (0<=a) is litteraly true
		then initial goal is proved

  RULE ContradictionXY.16
	if goal is (P)
		if (m = n+p) is in hypothesis
		if (m<p) is litteraly true
		if (0<=a) is in hypothesis
		if (n: a..b) is in hypothesis
		then initial goal is proved

  RULE ContradictionXY.17
	if goal is (P)
		if (m = n+p) is in hypothesis
		if (m+1<=p) is in hypothesis
		if (n: a..b) is in hypothesis
		if (0<=a) is litteraly true
		then initial goal is proved

  RULE ContradictionXY.18
	if goal is (P)
		if (m = n+p) is in hypothesis
		if (m+1<=p) is in hypothesis
		if (0<=a) is in hypothesis
		if (n: a..b) is in hypothesis
		then initial goal is proved

  RULE ContradictionXY.19
	if goal is (P)
		if (m = n+p) is in hypothesis
		if (m<p) is litteraly true
		if (n: INTEGER) is in hypothesis
		if (0<=n) is in hypothesis
		then initial goal is proved

  RULE ContradictionXY.20
	if goal is (P)
		if (m = n+p) is in hypothesis
		if (m+1<=p) is in hypothesis
		if (n: INTEGER) is in hypothesis
		if (0<=n) is in hypothesis
		then initial goal is proved

  RULE ContradictionXY.21
	if goal is (P)
		if (m+n<=p) is in hypothesis
		if (p<=m) is in hypothesis
		if (0<n) is litteraly true
		then initial goal is proved

  RULE ContradictionXY.22
	if goal is (P)
		if (m+n<=p) is in hypothesis
		if (p<=n) is in hypothesis
		if (0<m) is litteraly true
		then initial goal is proved

  RULE ContradictionXY.23
	if goal is (P)
		if (m+n<=p) is in hypothesis
		if (p<=m) is litteraly true
		if (0<n) is litteraly true
		then initial goal is proved

  RULE ContradictionXY.24
	if goal is (P)
		if (m+n<=p) is in hypothesis
		if (p<=n) is litteraly true
		if (0<m) is litteraly true
		then initial goal is proved

  RULE ContradictionXY.25
	if goal is (P)
		if (m+n<=p) is in hypothesis
		if (p<=m) is in hypothesis
		if (1<=n) is in hypothesis
		then initial goal is proved

  RULE ContradictionXY.26
	if goal is (P)
		if (m+n<=p) is in hypothesis
		if (p<=n) is in hypothesis
		if (1<=m) is in hypothesis
		then initial goal is proved

  RULE ContradictionXY.27
	if goal is (P)
		if (m+n<=p) is in hypothesis
		if (p<=m) is litteraly true
		if (1<=n) is in hypothesis
		then initial goal is proved

  RULE ContradictionXY.28
	if goal is (P)
		if (m+n<=p) is in hypothesis
		if (p<=n) is litteraly true
		if (1<=m) is in hypothesis
		then initial goal is proved

  RULE ContradictionXY.29
	if goal is (P)
		if (n = m) is in hypothesis
		if (n) is a numerical constant
		if (m) is a numerical constant
		if (m/=n) is litteraly true
		then initial goal is proved

  RULE ContradictionXY.30
	if goal is (P)
		if (a = n) is in hypothesis
		if (n) is a numerical constant
		if (a = m) is in hypothesis
		if (m) is a numerical constant
		if (m/=n) is litteraly true
		then initial goal is proved

  RULE ContradictionXY.31
	if goal is (P)
		if (n/p = n) is in hypothesis
		if (n>0) is litteraly true
		if (p>1) is litteraly true
		then initial goal is proved

  RULE ContradictionXY.32
	if goal is (P)
		if (n = n/p) is in hypothesis
		if (n>0) is litteraly true
		if (p>1) is litteraly true
		then initial goal is proved

  RULE ContradictionXY.33
	if goal is (P)
		if (n*p = n) is in hypothesis
		if (n>1) is litteraly true
		if (p>1) is litteraly true
		then initial goal is proved

  RULE ContradictionXY.34
	if goal is (P)
		if (n = n*p) is in hypothesis
		if (n>1) is litteraly true
		if (p>1) is litteraly true
		then initial goal is proved

  RULE ContradictionXY.35
	if goal is (P)
		if (n+p = n) is in hypothesis
		if (p>0) is litteraly true
		if (n: INTEGER) is in hypothesis
		then initial goal is proved

  RULE ContradictionXY.36
	if goal is (P)
		if (n+p = n) is in hypothesis
		if (p>0) is litteraly true
		if (n) is a numerical constant
		then initial goal is proved

  RULE ContradictionXY.37
	if goal is (P)
		if (n = n+p) is in hypothesis
		if (p>0) is litteraly true
		if (n: INTEGER) is in hypothesis
		then initial goal is proved

  RULE ContradictionXY.38
	if goal is (P)
		if (n = n+p) is in hypothesis
		if (p>0) is litteraly true
		if (n) is a numerical constant
		then initial goal is proved

  RULE ContradictionXY.39
	if goal is (P)
		if (m = n+p) is in hypothesis
		if (n: INTEGER) is in hypothesis
		if (0<=n) is in hypothesis
		if (m<p) is litteraly true
		then initial goal is proved

  RULE ContradictionXY.40
	if goal is (P)
		if (n: INTEGER) is in hypothesis
		if (n<0) is in hypothesis
		if (n) is a numerical constant
		then initial goal is proved

  RULE ContradictionXY.41
	if goal is (P)
		if (x: dom(r)) is in hypothesis
		if (r: a <-> b) is in hypothesis
		if (not(x: a)) is in hypothesis
		then initial goal is proved

  RULE ContradictionXY.42
	if goal is (P)
		if (not(b: (r<+{a|->b})[{a}])) is in hypothesis
		then initial goal is proved

  RULE ContradictionXY.43
	if goal is (P)
		if (not(A & B)) is in hypothesis
		if (A) is in hypothesis
		if (B) is in hypothesis
		then initial goal is proved


-------------------------------------------------------------------
THEORY ContraEnumAllNotX IS

  RULE ContraEnumAllNotX.1
	if goal is (ContraEnumAllNotG(i | j | v | E))
		if (not(v = i|->E)) is in hypothesis
		prove (ContraEnumAllNotG(i+1 | j | v | E))
		then initial goal is proved

  RULE ContraEnumAllNotX.2
	if goal is (ContraEnumAllNotG(j | j | v | E))
		if (not(v = j|->E)) is in hypothesis
		then initial goal is proved


-------------------------------------------------------------------
THEORY ContraExtAllNotX IS

  RULE ContraExtAllNotX.1
	if goal is (ContraExtAllNotG(L\/{e} | v))
		if (not(v = e)) is in hypothesis
		prove (ContraExtAllNotG(L | v))
		then initial goal is proved

  RULE ContraExtAllNotX.2
	if goal is (ContraExtAllNotG({e} | v))
		if (not(v = e)) is in hypothesis
		then initial goal is proved


-------------------------------------------------------------------
THEORY DifferenceTryXY IS

  RULE DifferenceTryXY.1
	if goal is (not(n = 0))
		if we make a successfull attempt to prove (n: INTEGER & 0<=n) with current prover force
		prove (1<=n)
		then initial goal is proved


-------------------------------------------------------------------
THEORY DifferenceXY IS

  RULE DifferenceXY.1
	if goal is (not(s = {}))
		if (s: seq(e)) is in hypothesis
		prove (1<=size(s))
		then initial goal is proved

  RULE DifferenceXY.2
	if goal is (not(x = TRUE))
		prove (x = FALSE)
		then initial goal is proved

  RULE DifferenceXY.3
	if goal is (not(x = FALSE))
		prove (x = TRUE)
		then initial goal is proved

  RULE DifferenceXY.4
	if goal is (not(a = 0))
		if (a: b..c) is in hypothesis
		if tactic (Fast_Prove_All_Order) proves (b<=c)
		if tactic (Fast_Prove_All_Order) proves (1<=b)
		then initial goal is proved

  RULE DifferenceXY.5
	if goal is (not(a = 0))
		if (a: b..c) is in hypothesis
		if tactic (Fast_Prove_All_Order) proves (b<=c)
		if tactic (Fast_Prove_All_Order) proves (c+1<=0)
		then initial goal is proved

  RULE DifferenceXY.6
	if goal is (not(a = 0))
		if (b<=a) is in hypothesis
		if (1<=b) is in hypothesis
		then initial goal is proved

  RULE DifferenceXY.7
	if goal is (not(a = 0))
		if (a<=b) is in hypothesis
		if (b+1<=0) is in hypothesis
		then initial goal is proved

  RULE DifferenceXY.8
	if goal is (not(a = f(x)))
		if (not(a: ran(f))) is in hypothesis
		then initial goal is proved

  RULE DifferenceXY.9
	if goal is (not(f(x) = a))
		if (not(a: ran(f))) is in hypothesis
		then initial goal is proved

  RULE DifferenceXY.10
	if goal is (not(a = {}))
		if (b: POW(a)) is in hypothesis
		if (not(b = {})) is in hypothesis
		then initial goal is proved

  RULE DifferenceXY.11
	if goal is (not(a = {}))
		if (not(a/\b = {})) is in hypothesis
		then initial goal is proved

  RULE DifferenceXY.12
	if goal is (not(a = {}))
		if (not(b/\a = {})) is in hypothesis
		then initial goal is proved

  RULE DifferenceXY.13
	if goal is (not(A = B))
		if (not(card(A) = card(B))) is in hypothesis
		then initial goal is proved

  RULE DifferenceXY.14
	if goal is (not(a = b))
		if (not(b = a)) is in hypothesis
		then initial goal is proved

  RULE DifferenceXY.15
	if goal is (not(a = b))
		if (a: c) is in hypothesis
		if (not(b: c)) is in hypothesis
		then initial goal is proved

  RULE DifferenceXY.16
	if goal is (not(a = b))
		if (b: c) is in hypothesis
		if (not(a: c)) is in hypothesis
		then initial goal is proved

  RULE DifferenceXY.17
	if goal is (not(a = b))
		if (a: c) is in hypothesis
		if (not(b: c)) is in hypothesis
		then initial goal is proved

  RULE DifferenceXY.18
	if goal is (not(a = b))
		if (b: c) is in hypothesis
		if (not(a: c)) is in hypothesis
		then initial goal is proved

  RULE DifferenceXY.19
	if goal is (not(a = b))
		if (not(f(a) = f(b))) is in hypothesis
		if (f~: t +-> s) is in hypothesis
		then initial goal is proved

  RULE DifferenceXY.20
	if goal is (not(A/\B = {}))
		if (x: A) is in hypothesis
		if (x: B) is in hypothesis
		then initial goal is proved

  RULE DifferenceXY.21
	goal (not(BOOL = {})) is always TRUE

  RULE DifferenceXY.22
	goal (not(INTEGER = {})) is always TRUE

  RULE DifferenceXY.23
	goal (not(INT = {})) is always TRUE

  RULE DifferenceXY.24
	goal (not(NATURAL = {})) is always TRUE

  RULE DifferenceXY.25
	goal (not(NAT = {})) is always TRUE


-------------------------------------------------------------------
THEORY EqualityXY IS

  RULE EqualityXY.1
	if goal is (rec(L) = X)
		if tactic (RecordMakeListX) proves (RecordMakeListG(Eg,L,X)) and gives result (R)
		prove (R)
		then initial goal is proved

  RULE EqualityXY.2
	if goal is (dom(f;g) = s)
		if (dom(f) = s) is in hypothesis
		if (f: a +-> b) is in hypothesis
		prove (ran(f): POW(dom(g)))
		then initial goal is proved

  RULE EqualityXY.3
	if goal is (a..b/\c..d = {})
		if (a<=b) is in hypothesis
		if (c<=d) is in hypothesis
		prove (c<=b => d+1<=a)
		then initial goal is proved

  RULE EqualityXY.4
	if goal is (a+e..b+e/\c+e..d+e = {})
		prove (a..b/\c..d = {})
		then initial goal is proved

  RULE EqualityXY.5
	if goal is (a..b/\A = {})
		if (b: A) is in hypothesis
		if (not(a..b = {})) is in hypothesis
		prove (bfalse)
		then initial goal is proved

  RULE EqualityXY.6
	if goal is (a..b/\A = {})
		if (a: A) is in hypothesis
		if (not(a..b = {})) is in hypothesis
		prove (bfalse)
		then initial goal is proved

  RULE EqualityXY.7
	if goal is (a..b+1/\A = {})
		if (not(b+1: A)) is in hypothesis
		prove (a..b/\A = {})
		then initial goal is proved

  RULE EqualityXY.8
	if goal is (a-1..b/\A = {})
		if (not(a-1: A)) is in hypothesis
		prove (a..b/\A = {})
		then initial goal is proved

  RULE EqualityXY.9
	if goal is (a..b+1/\A = {})
		if (a<=b+1) is in hypothesis
		if (a..b/\A = {}) is in hypothesis
		prove (not(b+1: A))
		then initial goal is proved

  RULE EqualityXY.10
	if goal is (a-1..b/\A = {})
		if (a-1<=b) is in hypothesis
		if (a..b/\A = {}) is in hypothesis
		prove (not(a-1: A))
		then initial goal is proved

  RULE EqualityXY.11
	if goal is (c..d+1/\a..b = {})
		if tactic (Fast_Prove_Order) proves (a<=b)
		if tactic (Fast_Prove_Order) proves (c<=d)
		if (a..b/\c..d = {}) is in hypothesis
		prove (not(d+1 = a))
		then initial goal is proved

  RULE EqualityXY.12
	if goal is (c..d+1/\a..b = {})
		if tactic (Fast_Prove_Order) proves (a<=b)
		if tactic (Fast_Prove_Order) proves (c<=d)
		if (c..d/\a..b = {}) is in hypothesis
		prove (not(d+1 = a))
		then initial goal is proved

  RULE EqualityXY.13
	if goal is (a..b = c..d)
		if tactic (Fast_Prove_Order) proves (a<=b)
		prove (a = c)
		prove (b = d)
		then initial goal is proved

  RULE EqualityXY.14
	if goal is (a..b = c..d)
		if tactic (Fast_Prove_Order) proves (c<=d)
		prove (a = c)
		prove (b = d)
		then initial goal is proved

  RULE EqualityXY.15
	if goal is (a..b = {})
		prove (b+1<=a)
		then initial goal is proved

  RULE EqualityXY.16
	if goal is (b = bool(P))
		prove (P => b = TRUE)
		prove (b = TRUE => P)
		then initial goal is proved

  RULE EqualityXY.17
	if goal is (bool(P) = b)
		prove (P => b = TRUE)
		prove (b = TRUE => P)
		then initial goal is proved

  RULE EqualityXY.18
	if goal is (bool(a) = FALSE)
		prove (not(a))
		then initial goal is proved

  RULE EqualityXY.19
	if goal is (bool(a) = TRUE)
		prove (a)
		then initial goal is proved

  RULE EqualityXY.20
	if goal is (bool(a) = bool(b))
		prove (a => b)
		prove (b => a)
		then initial goal is proved

  RULE EqualityXY.21
	if goal is (bool(not(a)) = bool(not(b)))
		prove (a => b)
		prove (b => a)
		then initial goal is proved

  RULE EqualityXY.22
	if goal is (FALSE = a)
		prove (a = FALSE)
		then initial goal is proved

  RULE EqualityXY.23
	if goal is (TRUE = a)
		prove (a = TRUE)
		then initial goal is proved

  RULE EqualityXY.24
	if goal is (TRUE = FALSE)
		prove (bfalse)
		then initial goal is proved

  RULE EqualityXY.25
	if goal is (FALSE = TRUE)
		prove (bfalse)
		then initial goal is proved

  RULE EqualityXY.26
	if goal is (s^t = s)
		prove (t = {})
		then initial goal is proved

  RULE EqualityXY.27
	if goal is (t^s = s)
		prove (t = {})
		then initial goal is proved

  RULE EqualityXY.28
	if goal is (c = a^b)
		prove (a^b = c)
		then initial goal is proved

  RULE EqualityXY.29
	if goal is (b\|/c = a)
		prove (a = b\|/c)
		then initial goal is proved

  RULE EqualityXY.30
	if goal is (b/|\c = a)
		prove (a = b/|\c)
		then initial goal is proved

  RULE EqualityXY.31
	if goal is (c = a->b)
		prove (a->b = c)
		then initial goal is proved

  RULE EqualityXY.32
	if goal is (c = a<-b)
		prove (a<-b = c)
		then initial goal is proved

  RULE EqualityXY.33
	if goal is ([b] = a)
		prove (a = [b])
		then initial goal is proved

  RULE EqualityXY.34
	if goal is (s/|\n = s\|/n)
		if (s: iseq(A)) is in hypothesis
		prove (s = {})
		then initial goal is proved

  RULE EqualityXY.35
	if goal is (s\|/n = s/|\n)
		if (s: iseq(A)) is in hypothesis
		prove (s = {})
		then initial goal is proved

  RULE EqualityXY.36
	if goal is (last(a->b) = c)
		prove (size(b) = 0 => a = c)
		prove (1<=size(b) => last(b) = c)
		then initial goal is proved

  RULE EqualityXY.37
	if goal is (first(a<-b) = c)
		prove (size(a) = 0 => b = c)
		prove (1<=size(a) => first(a) = c)
		then initial goal is proved

  RULE EqualityXY.38
	if goal is (first(a<+{size(a)|->b}) = c)
		if (n<=size(a)) is in hypothesis
		if (n>0) is litteraly true
		prove (size(a) = 1 => b = c)
		prove (2<=size(a) => first(a) = c)
		then initial goal is proved

  RULE EqualityXY.39
	if goal is (front(s) = {})
		prove (size(s) = 1)
		then initial goal is proved

  RULE EqualityXY.40
	if goal is (tail(s) = {})
		prove (size(s) = 1)
		then initial goal is proved

  RULE EqualityXY.41
	if goal is (s/|\n = {})
		prove (1<=n => s = {})
		then initial goal is proved

  RULE EqualityXY.42
	if goal is (s\|/n = {})
		prove (size(s)<=n)
		then initial goal is proved

  RULE EqualityXY.43
	if goal is ({a}<|{b|->c} = {b}<|{a|->d})
		prove (a = b => c = d)
		then initial goal is proved

  RULE EqualityXY.44
	if goal is (a = b/\c)
		if list (b/\c) contains (a) and gives (r) without this element
		prove (a: POW(r))
		then initial goal is proved

  RULE EqualityXY.45
	if goal is (b/\c = a)
		if list (b/\c) contains (a) and gives (r) without this element
		prove (a: POW(r))
		then initial goal is proved

  RULE EqualityXY.46
	if goal is (b\/c = a)
		if list (b\/c) contains (a) and gives (r) without this element
		prove (r: POW(a))
		then initial goal is proved

  RULE EqualityXY.47
	if goal is (a = b\/c)
		if list (b\/c) contains (a) and gives (r) without this element
		prove (r: POW(a))
		then initial goal is proved

  RULE EqualityXY.48
	if goal is (g[a] = t)
		if (g~: u +-> v) is in hypothesis
		if (ran(g) = t) is in hypothesis
		prove (dom(g): POW(a))
		then initial goal is proved

  RULE EqualityXY.49
	if goal is (f~[a] = s)
		if (f: u +-> v) is in hypothesis
		if (dom(f) = s) is in hypothesis
		prove (ran(f): POW(a))
		then initial goal is proved

  RULE EqualityXY.50
	if goal is (f[u]/\f[v] = {})
		if (f~: A +-> B) is in hypothesis
		prove (u/\v/\dom(f) = {})
		then initial goal is proved

  RULE EqualityXY.51
	if goal is (f<+g = f\/g)
		if (g: s +-> t) is in hypothesis
		prove (dom(f)/\dom(g)<|f = dom(f)/\dom(g)<|g)
		then initial goal is proved

  RULE EqualityXY.52
	if goal is (ran(f) = {})
		prove (dom(f) = {})
		then initial goal is proved

  RULE EqualityXY.53
	if goal is (r[u] = {})
		prove (u/\dom(r) = {})
		then initial goal is proved

  RULE EqualityXY.54
	if goal is (u<|f = {})
		prove (u/\dom(f) = {})
		then initial goal is proved

  RULE EqualityXY.55
	if goal is (u<<|f = {})
		prove (dom(f): POW(u))
		then initial goal is proved

  RULE EqualityXY.56
	if goal is (f|>u = {})
		prove (u/\ran(f) = {})
		then initial goal is proved

  RULE EqualityXY.57
	if goal is (f|>>u = {})
		prove (ran(f): POW(u))
		then initial goal is proved

  RULE EqualityXY.58
	if goal is (f<+g = {})
		prove (dom(g)<<|f = {})
		prove (g = {})
		then initial goal is proved

  RULE EqualityXY.59
	if goal is (a*b = 0)
		prove (not(a = 0) => b = 0)
		then initial goal is proved

  RULE EqualityXY.60
	if goal is (n = a)
		if (n) is a numerical constant
		prove (a = n)
		then initial goal is proved

  RULE EqualityXY.61
	if goal is (min(A) = min(B))
		if (A: POW(B)) is in hypothesis
		prove (not(B-A = {}) => min(A)<=min(B-A))
		then initial goal is proved

  RULE EqualityXY.62
	if goal is (min(A) = min(B))
		if (B: POW(A)) is in hypothesis
		prove (min(B) = min(A))
		then initial goal is proved

  RULE EqualityXY.63
	if goal is (max(A) = max(B))
		if (A: POW(B)) is in hypothesis
		prove (not(B-A = {}) => max(B-A)<=max(A))
		then initial goal is proved

  RULE EqualityXY.64
	if goal is (max(A) = max(B))
		if (B: POW(A)) is in hypothesis
		prove (max(B) = max(A))
		then initial goal is proved

  RULE EqualityXY.65
	if goal is (card(A) = 0)
		prove (A = {})
		then initial goal is proved

  RULE EqualityXY.66
	if goal is (size(A) = 0)
		prove (A = {})
		then initial goal is proved

  RULE EqualityXY.67
	if goal is (a = c)
		if (a+b<=c) is in hypothesis
		if (b>0) is litteraly true
		prove (bfalse)
		then initial goal is proved

  RULE EqualityXY.68
	if goal is (a = c)
		if (c+b<=a) is in hypothesis
		if (b>0) is litteraly true
		prove (bfalse)
		then initial goal is proved

  RULE EqualityXY.69
	if goal is (a = n)
		if (m<=a) is in hypothesis
		if (n<m) is litteraly true
		prove (bfalse)
		then initial goal is proved

  RULE EqualityXY.70
	if goal is (a = b)
		if (a) is a numerical constant
		if (b) is a numerical constant
		if (a/=b) is litteraly true
		prove (bfalse)
		then initial goal is proved

  RULE EqualityXY.71
	if goal is (A\/B = {})
		prove (A = {})
		prove (B = {})
		then initial goal is proved

  RULE EqualityXY.72
	if goal is (A/\(B\/C) = {})
		prove (A/\B = {})
		prove (A/\C = {})
		then initial goal is proved

  RULE EqualityXY.73
	if goal is (B\/C/\A = {})
		prove (B/\A = {})
		prove (C/\A = {})
		then initial goal is proved

  RULE EqualityXY.74
	if goal is (A-B = A)
		if (A: POW(C)) is in hypothesis
		prove (A/\B = {})
		then initial goal is proved

  RULE EqualityXY.75
	if goal is (A = A-B)
		if (A: POW(C)) is in hypothesis
		prove (A/\B = {})
		then initial goal is proved

  RULE EqualityXY.76
	if goal is (A = A-{a})
		prove (A/\{a} = {})
		then initial goal is proved

  RULE EqualityXY.77
	if goal is (A-{a} = A)
		prove (A/\{a} = {})
		then initial goal is proved

  RULE EqualityXY.78
	if goal is ({a}-A = {a})
		prove (A/\{a} = {})
		then initial goal is proved

  RULE EqualityXY.79
	if goal is (A-B = {})
		prove (A: POW(B))
		then initial goal is proved

  RULE EqualityXY.80
	if goal is (A\/B = B)
		prove (A: POW(B))
		then initial goal is proved

  RULE EqualityXY.81
	if goal is (A\/B = A)
		prove (B: POW(A))
		then initial goal is proved

  RULE EqualityXY.82
	if goal is (A/\B = A)
		prove (A: POW(B))
		then initial goal is proved

  RULE EqualityXY.83
	if goal is (A/\B = B)
		prove (B: POW(A))
		then initial goal is proved

  RULE EqualityXY.84
	if goal is (B = A\/B)
		prove (A: POW(B))
		then initial goal is proved

  RULE EqualityXY.85
	if goal is (A = A\/B)
		prove (B: POW(A))
		then initial goal is proved

  RULE EqualityXY.86
	if goal is (A = A/\B)
		prove (A: POW(B))
		then initial goal is proved

  RULE EqualityXY.87
	if goal is (B = A/\B)
		prove (B: POW(A))
		then initial goal is proved

  RULE EqualityXY.88
	if goal is ((A\/B)-C = A\/B-C)
		prove (A/\C = {})
		then initial goal is proved

  RULE EqualityXY.89
	if goal is (A\/B-C = (A\/B)-C)
		prove (A/\C = {})
		then initial goal is proved

  RULE EqualityXY.90
	if goal is ((A\/B)-C = A-C\/B)
		prove (B/\C = {})
		then initial goal is proved

  RULE EqualityXY.91
	if goal is (A-C\/B = (A\/B)-C)
		prove (B/\C = {})
		then initial goal is proved

  RULE EqualityXY.92
	if goal is (A\/{a} = A\/{b})
		if (not(a: A)) is in hypothesis
		prove (a = b)
		then initial goal is proved

  RULE EqualityXY.93
	if goal is (A\/{a} = A\/{b})
		if (not(b: A)) is in hypothesis
		prove (a = b)
		then initial goal is proved

  RULE EqualityXY.94
	if goal is (f(a) = f(b))
		if (f~: t +-> s) is in hypothesis
		prove (a = b)
		then initial goal is proved

  RULE EqualityXY.95
	if goal is (x|->y = w|->z)
		prove (x = w)
		prove (y = z)
		then initial goal is proved

  RULE EqualityXY.96
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE EqualityXY.97
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE EqualityXY.98
	if goal is (A/\B = {})
		if list (A/\B) contains ({x}) and gives (R) without this element
		prove (not(x: R))
		then initial goal is proved

  RULE EqualityXY.99
	if goal is (A/\SET(x).P = {})
		if (x) is a variable list whith no free occurences in (A)
		prove (!x.not(P & x: A))
		then initial goal is proved

  RULE EqualityXY.100
	if goal is ({a} = {})
		prove (bfalse)
		then initial goal is proved

  RULE EqualityXY.101
	if goal is (SET(x).(P & Q) = {})
		if list (P & Q) contains (x: a) and gives (R) without this element
		prove (!x.(x: a => not(R)))
		then initial goal is proved

  RULE EqualityXY.102
	if goal is (SET(x).(P & Q) = {})
		if list (P & Q) contains (x = a) and gives (R) without this element
		prove (!x.(x = a => not(R)))
		then initial goal is proved

  RULE EqualityXY.103
	if goal is ([a] = {})
		prove (bfalse)
		then initial goal is proved

  RULE EqualityXY.104
	if goal is (s^t = {})
		prove (s = {})
		prove (t = {})
		then initial goal is proved

  RULE EqualityXY.105
	if goal is (A = {a})
		if (A: POW({a})) is in hypothesis
		prove (not(A = {}))
		then initial goal is proved

  RULE EqualityXY.106
	if goal is (A = SET(x).P)
		if (y) is a fresh variable in (A = SET(x).P)
		if (A: POW(SET(x).P)) is in hypothesis
		prove (!y.([x:=y]P => y: A))
		then initial goal is proved

  RULE EqualityXY.107
	if goal is (A = {})
		if (1<=card(A)) is in hypothesis
		prove (bfalse)
		then initial goal is proved

  RULE EqualityXY.108
	if goal is (A = {})
		if (x: A) is in hypothesis
		prove (bfalse)
		then initial goal is proved

  RULE EqualityXY.109
	if goal is ({a} = A)
		prove (A = {a})
		then initial goal is proved

  RULE EqualityXY.110
	if goal is ({a} = {b})
		prove (a = b)
		then initial goal is proved

  RULE EqualityXY.111
	if goal is (BOOL = {})
		prove (bfalse)
		then initial goal is proved

  RULE EqualityXY.112
	if goal is (NATURAL = {})
		prove (bfalse)
		then initial goal is proved

  RULE EqualityXY.113
	if goal is (INTEGER = {})
		prove (bfalse)
		then initial goal is proved

  RULE EqualityXY.114
	if goal is ({a} = {})
		prove (bfalse)
		then initial goal is proved

  RULE EqualityXY.115
	if goal is ({} = A)
		prove (A = {})
		then initial goal is proved

  RULE EqualityXY.116
	if goal is (a..b/\c..d = {})
		if (d+1<=a) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.117
	if goal is (a..b/\c..d = {})
		if (b+1<=c) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.118
	if goal is (a..b/\A = {})
		if (c..b/\A = {}) is in hypothesis
		if (c<=a) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.119
	if goal is (a..b/\A = {})
		if (a..c/\A = {}) is in hypothesis
		if (b<=c) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.120
	if goal is (f[b]/\a = {})
		if (ran(f)/\a = {}) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.121
	if goal is (ran(b<<|f)/\a = {})
		if (ran(f)/\a = {}) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.122
	if goal is (a/\f~[c] = {})
		if (a/\dom(f) = {}) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.123
	if goal is (a/\dom(f|>>c) = {})
		if (a/\dom(f) = {}) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.124
	if goal is (A/\B = {})
		if (A: POW(C)) is in hypothesis
		if (B/\C = {}) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.125
	if goal is (A/\B = {})
		if (B: POW(C)) is in hypothesis
		if (A/\C = {}) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.126
	if goal is (z = y)
		if (x|->y: t) is in hypothesis
		if (x|->z: t) is in hypothesis
		if (t: a +-> b) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.127
	if goal is (y = z)
		if (x|->y: t) is in hypothesis
		if (x|->z: t) is in hypothesis
		if (t: a +-> b) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.128
	if goal is (A = B)
		if (A: POW(B)) is in hypothesis
		if (B: POW(A)) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.129
	if goal is (A = B)
		if (A: POW(B)) is in hypothesis
		if (card(A) = card(B)) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.130
	if goal is (A = B)
		if (B: POW(A)) is in hypothesis
		if (card(A) = card(B)) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.131
	if goal is (A/\B = C)
		if (B/\A = C) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.132
	if goal is (A\/B = C)
		if (B\/A = C) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.133
	if goal is (a = b)
		if (f(a) = f(b)) is in hypothesis
		if (f~: t +-> s) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.134
	goal (a = a-0) is always TRUE

  RULE EqualityXY.135
	if goal is (a = b)
		if ({a} = {b}) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.136
	goal (A/\(B\/C) = A/\B\/(A/\C)) is always TRUE

  RULE EqualityXY.137
	goal (B\/C/\A = B/\A\/(C/\A)) is always TRUE

  RULE EqualityXY.138
	goal (A/\B\/C = A\/C/\(B\/C)) is always TRUE

  RULE EqualityXY.139
	goal (A\/(B/\C) = A\/B/\(A\/C)) is always TRUE

  RULE EqualityXY.140
	goal (A/\B\/(A/\C) = A/\(B\/C)) is always TRUE

  RULE EqualityXY.141
	goal (B/\A\/(C/\A) = B\/C/\A) is always TRUE

  RULE EqualityXY.142
	goal (A\/C/\(B\/C) = A/\B\/C) is always TRUE

  RULE EqualityXY.143
	goal (A\/B/\(A\/C) = A\/(B/\C)) is always TRUE

  RULE EqualityXY.144
	if goal is (V = A)
		if (U*V = U*A) is in hypothesis
		if (not(U = {})) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.145
	if goal is (V = A)
		if (V*U = A*U) is in hypothesis
		if (not(U = {})) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.146
	if goal is (dom(S*T) = S)
		if (not(T = {})) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.147
	if goal is (ran(S*T) = T)
		if (not(S = {})) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.148
	goal (POW(A)/\POW(B) = POW(A/\B)) is always TRUE

  RULE EqualityXY.149
	if goal is (dom(p;q) = dom(p))
		if (ran(p): POW(dom(q))) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.150
	if goal is (ran(p;q) = ran(q))
		if (dom(q): POW(ran(p))) is in hypothesis
		then initial goal is proved

  RULE EqualityXY.151
	goal (dom(A*A) = A) is always TRUE

  RULE EqualityXY.152
	goal (A\/B = B\/A) is always TRUE

  RULE EqualityXY.153
	goal (A/\B = B/\A) is always TRUE

  RULE EqualityXY.154
	goal (A\/B\/C = A\/C\/B) is always TRUE

  RULE EqualityXY.155
	goal (A\/B\/C = C\/A\/B) is always TRUE

  RULE EqualityXY.156
	goal (A\/B\/C = B\/A\/C) is always TRUE

  RULE EqualityXY.157
	goal (A\/B\/C = B\/C\/A) is always TRUE

  RULE EqualityXY.158
	goal (A\/B\/C = C\/B\/A) is always TRUE

  RULE EqualityXY.159
	goal (A/\B/\C = A/\C/\B) is always TRUE

  RULE EqualityXY.160
	goal (A/\B/\C = C/\A/\B) is always TRUE

  RULE EqualityXY.161
	goal (A/\B/\C = B/\A/\C) is always TRUE

  RULE EqualityXY.162
	goal (A/\B/\C = B/\C/\A) is always TRUE

  RULE EqualityXY.163
	goal (A/\B/\C = C/\B/\A) is always TRUE

  RULE EqualityXY.164
	goal (a = a) is always TRUE

  RULE EqualityXY.165
	goal (a-a = 0) is always TRUE


-------------------------------------------------------------------
THEORY ExistTryXY IS

  RULE ExistTryXY.1
	if goal is (#x.P)
		if list (P & btrue) contains (x: s) and gives (Q & btrue) without this element
		if (x) is a variable list whith no free occurences in (s)
		if (y: s) is in hypothesis
		if (y) is a variable list whith no free occurences in (s)
		if we make a successfull attempt to prove ([x:=y]Q) with current prover force
		then initial goal is proved


-------------------------------------------------------------------
THEORY ExistXY IS

  RULE ExistXY.1
	if goal is (#(L,v).P)
		if list (P & btrue) contains (Q) and gives (S) without this element
		if (L) is a variable list whith no free occurences in (S)
		if (v) is a variable list whith no free occurences in (Q)
		prove (#L.Q)
		prove (#v.S)
		then initial goal is proved

  RULE ExistXY.2
	if goal is (#x.P)
		if list (P & btrue) contains (x: INTEGER)
		if we make a successfull attempt to prove ([x:=0]P) with current prover force
		then initial goal is proved

  RULE ExistXY.3
	if goal is (#x.(P & Q))
		if (x) is a variable list whith no free occurences in (P)
		prove (P)
		prove (#x.Q)
		then initial goal is proved

  RULE ExistXY.4
	if goal is (#x.(P & Q))
		if (x) is a variable list whith no free occurences in (Q)
		prove (#x.P)
		prove (Q)
		then initial goal is proved

  RULE ExistXY.5
	if goal is (#(x,y).(P & Q))
		if (y) is a variable list whith no free occurences in (P)
		prove (#x.(P & #y.Q))
		then initial goal is proved

  RULE ExistXY.6
	if goal is (#x.(P or Q))
		prove (#x.P or #x.Q)
		then initial goal is proved

  RULE ExistXY.7
	if goal is (#x.(P or Q))
		if (x) is a variable list whith no free occurences in (P)
		prove (P or #x.Q)
		then initial goal is proved

  RULE ExistXY.8
	if goal is (#x.(P or Q))
		if (x) is a variable list whith no free occurences in (Q)
		prove (#x.P or Q)
		then initial goal is proved

  RULE ExistXY.9
	if goal is (#(x,y).(P or Q))
		if (y) is a variable list whith no free occurences in (P)
		prove (#x.(P or #y.Q))
		then initial goal is proved

  RULE ExistXY.10
	if goal is (#f.(f: A +-> B & dom(f) = A))
		prove (B = {} => A = {})
		if (f) is a variable list whith no free occurences in (A,B)
		then initial goal is proved

  RULE ExistXY.11
	if goal is (#x.P)
		if list (P & btrue) contains (x = E) and gives (Q & btrue) without this element
		if (x) is a variable list whith no free occurences in (E)
		prove (WD(expr(E),Z))
		prove ([x:=E]Q)
		then initial goal is proved

  RULE ExistXY.12
	if goal is (#x.P)
		if list (P & btrue) contains (E = x) and gives (Q & btrue) without this element
		if (x) is a variable list whith no free occurences in (E)
		prove (WD(expr(E),Z))
		prove ([x:=E]Q)
		then initial goal is proved

  RULE ExistXY.13
	if goal is (#(w,x).P)
		if list (P & btrue) contains (y = E) and gives (Q & btrue) without this element
		if (y) is a variable list whith no free occurences in (E)
		if list (w,x) contains (y)
		prove (WD(expr(E),Z))
		prove (#z.[y:=E]Q)
		then initial goal is proved

  RULE ExistXY.14
	if goal is (#(w,x).P)
		if list (P & btrue) contains (E = y) and gives (Q & btrue) without this element
		if (y) is a variable list whith no free occurences in (E)
		if list (w,x) contains (y)
		prove (WD(expr(E),Z))
		prove (#z.[y:=E]Q)
		then initial goal is proved

  RULE ExistXY.15
	if goal is (#x.(not(P) => Q))
		prove (not(#x.P) => #x.Q)
		then initial goal is proved

  RULE ExistXY.16
	if goal is (#a.(a: A))
		if (a) is a variable list whith no free occurences in (A)
		prove (not(A = {}))
		then initial goal is proved

  RULE ExistXY.17
	goal (#x.(x: POW(A))) is always TRUE

  RULE ExistXY.18
	if goal is (#x.(x = E))
		if (x) is a variable list whith no free occurences in (E)
		then initial goal is proved

  RULE ExistXY.19
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE ExistXY.20
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE ExistXY.21
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE ExistXY.22
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE ExistXY.23
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE ExistXY.24
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE ExistXY.25
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE ExistXY.26
	goal (#x.(x: INTEGER)) is always TRUE

  RULE ExistXY.27
	goal (#x.(x: BOOL)) is always TRUE

  RULE ExistXY.28
	goal (#f.(f: A +-> B & f~: B +-> A)) is always TRUE

  RULE ExistXY.29
	goal (#f.(f: A +-> B)) is always TRUE

  RULE ExistXY.30
	goal (#x.(x: INTEGER & 0<=x & 1<=x)) is always TRUE

  RULE ExistXY.31
	goal (#x.btrue) is always TRUE


-------------------------------------------------------------------
THEORY ForAllX IS

  RULE ForAllX.1
	if goal is (!a.(P => Q))
		if list (P & btrue) contains (a = b) and gives (R) without this element
		if (a) is a variable list whith no free occurences in (b)
		prove (WD(expr(b),Z))
		prove ([a:=b](R => Q))
		then initial goal is proved

  RULE ForAllX.2
	if goal is (!a.(P => Q))
		if list (P & btrue) contains (b = a) and gives (R) without this element
		if (a) is a variable list whith no free occurences in (b)
		prove (WD(expr(b),Z))
		prove ([a:=b](R => Q))
		then initial goal is proved

  RULE ForAllX.3
	if goal is (!a.not(a: A))
		if (a) is a variable list whith no free occurences in (A)
		prove (A = {})
		then initial goal is proved

  RULE ForAllX.4
	if goal is (!a.bfalse)
		prove (bfalse)
		then initial goal is proved

  RULE ForAllX.5
	goal (!a.btrue) is always TRUE


-------------------------------------------------------------------
THEORY ImplicationXY IS

  RULE ImplicationXY.1
	if goal is (P => Q)
		if (not(Q)) is in hypothesis
		prove (P => bfalse)
		then initial goal is proved

  RULE ImplicationXY.2
	if goal is (A => not(A))
		prove (not(A))
		then initial goal is proved

  RULE ImplicationXY.3
	if goal is (not(A) => A)
		prove (A)
		then initial goal is proved

  RULE ImplicationXY.4
	if goal is (btrue => P)
		prove (P)
		then initial goal is proved


-------------------------------------------------------------------
THEORY b1 IS

  RULE b1.1
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE b1.2
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE b1.3
	if goal is (E<|{a|->b}: A +-> B)
		prove (a: E =>
			a: A
		&	b: B)
		then initial goal is proved

  RULE b1.4
	if goal is (X<<|(f\/g): POW(A))
		prove (X<<|f: POW(A))
		prove (X<<|g: POW(A))
		then initial goal is proved

  RULE b1.5
	if goal is (X<|(f\/g): POW(A))
		prove (X<|f: POW(A))
		prove (X<|g: POW(A))
		then initial goal is proved

  RULE b1.6
	if goal is (A\/{b} <: C)
		prove (A <: C)
		prove ({b} <: C)
		then initial goal is proved

  RULE b1.7
	if goal is (not(a: A\/{b}))
		prove (not(a: A))
		prove (not(a = b))
		then initial goal is proved

  RULE b1.8
	if goal is (not(a: (A\/{b})[c]))
		prove (not(a: A[c]))
		prove (not(a: {b}[c]))
		then initial goal is proved

  RULE b1.9
	if goal is (not(a*b = {}))
		prove (not(a = {}))
		prove (not(b = {}))
		then initial goal is proved

  RULE b1.10
	if goal is (max(A\/B)<=c)
		if (max(A)<=a) is in hypothesis
		if (max(B)<=b) is in hypothesis
		if tactic (Fast_Prove_Order) proves (a<=c)
		if tactic (Fast_Prove_Order) proves (b<=c)
		then initial goal is proved

  RULE b1.11
	if goal is (c<=min(A\/B))
		if (a<=min(A)) is in hypothesis
		if (b<=min(B)) is in hypothesis
		if tactic (Fast_Prove_Order) proves (c<=a)
		if tactic (Fast_Prove_Order) proves (c<=b)
		then initial goal is proved

  RULE b1.12
	if goal is (P)
		if (g = v) is in hypothesis
		if (v) is a numerical constant
		if (g = w) is in hypothesis
		if (w) is a numerical constant
		not if (v = w) is litteraly true
		then initial goal is proved

  RULE b1.13
	if goal is (a or b)
		if (c) is in hypothesis
		if list (a or b) contains (c)
		then initial goal is proved

  RULE b1.14
	if goal is (x: f<+A)
		if we make a successfull attempt to prove (x: A) with current prover force
		then initial goal is proved

  RULE b1.15
	if goal is (f(x): t)
		if we make a successfull attempt to prove (ran(f): POW(t)) with current prover force
		then initial goal is proved

  RULE b1.16
	if goal is (f<+a: A +-> B)
		if we make a successfull attempt to prove (f: A +-> B) with current prover force
		if we make a successfull attempt to prove (a: A +-> B) with current prover force
		then initial goal is proved

  RULE b1.17
	if goal is (x|->y: f)
		if we make a successfull attempt to prove (x: f~[{y}]) with current prover force
		then initial goal is proved

  RULE b1.18
	if goal is (f(x): f[X])
		if we make a successfull attempt to prove (x: dom(f)) with current prover force
		if we make a successfull attempt to prove (x: X) with current prover force
		then initial goal is proved

  RULE b1.19
	if goal is (A<<|f|>B: POW(E))
		if (f: POW(E)) is in hypothesis
		then initial goal is proved

  RULE b1.20
	if goal is (f|>B: POW(E))
		if (f: POW(E)) is in hypothesis
		then initial goal is proved

  RULE b1.21
	if goal is (A<|f: POW(E))
		if (f: POW(E)) is in hypothesis
		then initial goal is proved

  RULE b1.22
	if goal is (f|>>B: POW(E))
		if (f: POW(E)) is in hypothesis
		then initial goal is proved

  RULE b1.23
	if goal is (A<<|f: POW(E))
		if (f: POW(E)) is in hypothesis
		then initial goal is proved

  RULE b1.24
	if goal is (A/\B: POW(C\/D))
		if list (C\/D) contains (B)
		then initial goal is proved

  RULE b1.25
	if goal is (A/\B: POW(C\/D))
		if list (C\/D) contains (A)
		then initial goal is proved

  RULE b1.26
	if goal is (A<|f|>>B: POW(E))
		if (f: POW(E)) is in hypothesis
		then initial goal is proved

  RULE b1.27
	if goal is (id(1..n): seq(S))
		if we make a successfull attempt to prove (1..n: POW(S)) with current prover force
		then initial goal is proved

  RULE b1.28
	if goal is (id(f): A +-> B)
		if we make a successfull attempt to prove (f: POW(A)) with current prover force
		if we make a successfull attempt to prove (f: POW(B)) with current prover force
		then initial goal is proved

  RULE b1.29
	if goal is (min(E): F)
		if we make a successfull attempt to prove (E: POW(F)) with current prover force
		then initial goal is proved

  RULE b1.30
	if goal is (max(E): F)
		if we make a successfull attempt to prove (E: POW(F)) with current prover force
		then initial goal is proved

  RULE b1.31
	if goal is (a,b: E\/F)
		if list (E\/F) contains ({a|->b})
		then initial goal is proved

  RULE b1.32
	if goal is (dom(B)<|A = dom(A)<|B)
		if (dom(A)/\dom(B) = {}) is in hypothesis
		then initial goal is proved

  RULE b1.33
	if goal is (dom(B)<|A = dom(A)<|B)
		if (dom(B)/\dom(A) = {}) is in hypothesis
		then initial goal is proved

  RULE b1.34
	if goal is (f(x) = y)
		if (f: A +-> B) is in hypothesis
		if (x: f~[{y}]) is in hypothesis
		then initial goal is proved

  RULE b1.35
	if goal is (f<+h = g<+h)
		if we make a successfull attempt to prove (f = g) with current prover force
		then initial goal is proved

  RULE b1.36
	if goal is (f<+{h|->i} = {h|->i})
		if we make a successfull attempt to prove ({h}<<|f = {}) with current prover force
		then initial goal is proved

  RULE b1.37
	if goal is (H<<|(f<+{h|->i}) = {h|->i})
		if we make a successfull attempt to prove ({h}\/H<<|f = {}) with current prover force
		if we make a successfull attempt to prove (not(h: H)) with current prover force
		then initial goal is proved

  RULE b1.38
	if goal is (f<+{h|->i} = g\/{h|->i})
		if we make a successfull attempt to prove ({h}<<|f = g) with current prover force
		then initial goal is proved

  RULE b1.39
	if goal is (H<<|(f<+{h|->i}) = g\/{h|->i})
		if we make a successfull attempt to prove ({h}\/H<<|f = g) with current prover force
		if we make a successfull attempt to prove (not(h: H)) with current prover force
		then initial goal is proved

  RULE b1.40
	if goal is (d<|(f<+g) = g)
		if we make a successfull attempt to prove (dom(d<|f) <: dom(g)) with current prover force
		if we make a successfull attempt to prove (dom(g) <: d) with current prover force
		then initial goal is proved

  RULE b1.41
	if goal is (f(x) = g(x))
		if (A<<|f = A<<|g) is in hypothesis
		if we make a successfull attempt to prove (not(x: A)) with current prover force
		then initial goal is proved

  RULE b1.42
	if goal is (f(x) = g(x))
		if (A<|f = A<|g) is in hypothesis
		if we make a successfull attempt to prove (x: A) with current prover force
		then initial goal is proved

  RULE b1.43
	if goal is (not(a: b))
		if (b = {}) is in hypothesis
		then initial goal is proved

  RULE b1.44
	if goal is (not(x|->y: f))
		if we make a successfull attempt to prove (not(x: dom(f))) with current prover force
		then initial goal is proved

  RULE b1.45
	if goal is (not((A\/{b})[{V}] = {}))
		if list (A\/{b}) contains ({V|->v})
		then initial goal is proved

  RULE b1.46
	if goal is (a mod b<=c)
		if tactic (Fast_Prove_Order) proves (b<=c)
		then initial goal is proved

  RULE b1.47
	if goal is (N<=SIGMA(j).(j: a..b | f(j)))
		if (j) is a variable list whith no free occurences in (a,b,f)
		if (f: A +-> B) is in hypothesis
		if we make a successfull attempt to prove (a<=b) with current prover force
		if we make a successfull attempt to prove (not(B = {})) with current prover force
		if we make a successfull attempt to prove (B: FIN(B)) with current prover force
		if we make a successfull attempt to prove (N<=(b-a+1)*min(B)) with current prover force
		then initial goal is proved

  RULE b1.48
	if goal is (SIGMA(j).(j: a..b | f(j))<=N)
		if (j) is a variable list whith no free occurences in (a,b,f)
		if (f: A +-> B) is in hypothesis
		if we make a successfull attempt to prove (a<=b) with current prover force
		if we make a successfull attempt to prove (not(B = {})) with current prover force
		if we make a successfull attempt to prove (B: FIN(B)) with current prover force
		if we make a successfull attempt to prove ((b-a+1)*max(B)<=N) with current prover force
		then initial goal is proved

  RULE b1.49
	if goal is (a<=f(x))
		if (f: A +-> B) is in hypothesis
		if we make a successfull attempt to prove (not(B = {})) with current prover force
		if we make a successfull attempt to prove (B: FIN(B)) with current prover force
		if we make a successfull attempt to prove (a<=min(B)) with current prover force
		then initial goal is proved

  RULE b1.50
	if goal is (f(x)<=b)
		if (f: A +-> B) is in hypothesis
		if we make a successfull attempt to prove (not(B = {})) with current prover force
		if we make a successfull attempt to prove (B: FIN(B)) with current prover force
		if we make a successfull attempt to prove (max(B)<=b) with current prover force
		then initial goal is proved

  RULE b1.51
	if goal is (a/b<=MAXINT)
		if tactic (Fast_Prove_Order) proves (1<=b)
		if (a: 0..n) is in hypothesis
		if tactic (Fast_Prove_Order) proves (n<=MAXINT)
		then initial goal is proved

  RULE b1.52
	if goal is (c<=a/b)
		if tactic (Fast_Prove_Order) proves (c<=0)
		if tactic (Fast_Prove_Order) proves (1<=b)
		if (a: 0..n) is in hypothesis
		then initial goal is proved

  RULE b1.53
	if goal is (0<=max(E))
		if (E <: NATURAL) is in hypothesis
		then initial goal is proved

  RULE b1.54
	if goal is (a<=max(A\/B))
		if list (A\/B) contains ({a})
		then initial goal is proved

  RULE b1.55
	if goal is (min(A\/B)<=b)
		if list (A\/B) contains ({b})
		then initial goal is proved

  RULE b1.56
	goal (f~[A]: POW(dom(f))) is always TRUE

  RULE b1.57
	goal (A<<|f|>>B: POW(f)) is always TRUE

  RULE b1.58
	goal (min({a}\/{b})+c = min({a+c}\/{b+c})) is always TRUE

  RULE b1.59
	goal (0<=a mod b) is always TRUE

  RULE b1.60
	goal (a mod b+1<=b) is always TRUE

  RULE b1.61
	goal (a mod b: INTEGER) is always TRUE

  RULE b1.62
	goal (a/b: INTEGER) is always TRUE


-------------------------------------------------------------------
THEORY s1 IS

  RULE s1.1
	always rewrite (SIGMA(x).(A | b+c)) in (SIGMA(x).(A | b)+SIGMA(x).(A | c))

  RULE s1.2
	always rewrite (SIGMA(x).(A | b-c)) in (SIGMA(x).(A | b)-SIGMA(x).(A | c))

  RULE s1.3
	rewrite  (SIGMA(x).(x: a\/b | e))  in  (SIGMA(x).(x: a | e)+SIGMA(x).(x: b | e))
		if (a/\b = {}) is in hypothesis
		if (b,a) does not contain non-free variables in replacement

  RULE s1.4
	rewrite  (SIGMA(x).(x = b | P))  in  ([x:=b]P)
		not if (x) matches on (y,z)
		if (x) is a variable list whith no free occurences in (b)

  RULE s1.5
	always rewrite (SIGMA(x).(P | 0)) in (0)

  RULE s1.6
	always rewrite (SIGMA(x).(bfalse | e)) in (0)

  RULE s1.7
	always rewrite (PI(x).(bfalse | e)) in (1)

  RULE s1.8
	always rewrite (PI(x).(P | 1)) in (1)

  RULE s1.9
	rewrite  (bool(H))  in  (TRUE)
		if (H) is in hypothesis
		if (H) does not contain non-free variables in replacement

  RULE s1.10
	rewrite  (bool(H))  in  (FALSE)
		if (not(H)) is in hypothesis
		if (H) does not contain non-free variables in replacement

  RULE s1.11
	rewrite  ((A\/B)(x))  in  (y)
		if list (A\/B) contains ({x|->y})

  RULE s1.12
	rewrite  ((F<+{x|->y})(a))  in  (F(a))
		if (F: A +-> B) is in hypothesis
		if tactic (Fast_Prove_Difference) proves (not(x = a))
		if (x = a,A,B,F) does not contain non-free variables in replacement

  RULE s1.13
	always rewrite ((F<+{a|->b})(a)) in (b)

  RULE s1.14
	rewrite  (a..b<|(f<+{c|->d}))  in  (a..b<|f)
		if tactic (Fast_Prove_Order) proves (a<=b)
		if tactic (Fast_Prove_All_Order) proves (c+1<=a)
		if (c,a,b) does not contain non-free variables in replacement

  RULE s1.15
	rewrite  (a..b<|(f<+{c|->d}))  in  (a..b<|f)
		if tactic (Fast_Prove_Order) proves (a<=b)
		if tactic (Fast_Prove_All_Order) proves (b+1<=c)
		if (c,a,b) does not contain non-free variables in replacement

  RULE s1.16
	rewrite  ({a}<|{b|->c})  in  ({})
		if tactic (Fast_Prove_Difference) proves (not(b = a))
		if (a,b) does not contain non-free variables in replacement

  RULE s1.17
	rewrite  ({x}<<|(A\/B))  in  ({x}<<|C)
		if list (A\/B) contains ({x|->y}) and gives (C) without this element

  RULE s1.18
	always rewrite (f<+{a|->b}|>>{b}) in ({a}<<|f|>>{b})

  RULE s1.19
	rewrite  (f~[{a}])  in  ({f~(a)})
		if (a: ran(f)) is in hypothesis
		if (f~: A +-> B) is in hypothesis
		if (f,a) does not contain non-free variables in replacement

  RULE s1.20
	rewrite  ((A\/B)[{a}])  in  (C[{a}]\/{b})
		if list (A\/B) contains ({a|->b}) and gives (C) without this element

  RULE s1.21
	rewrite  (f[A\/B])  in  (f[C])
		prove (band(binhyp(not(x: dom(f)),bsearch({x},A\/B,C))))
		if (x,f) does not contain non-free variables in replacement

  RULE s1.22
	always rewrite ({(x,y)|->z}~[{z}]) in ({x|->y})

  RULE s1.23
	always rewrite ((a\/{(x,y)|->z})~[{z}]) in (a~[{z}]\/{x|->y})

  RULE s1.24
	rewrite  ((a+b) mod b)  in  (a mod b)
		if tactic (Fast_Prove_Order) proves (0<=a)
		if (a) does not contain non-free variables in replacement

  RULE s1.25
	rewrite  (a mod b)  in  (a)
		if tactic (Fast_Prove_Order) proves (a+1<=b)
		if (a,b) does not contain non-free variables in replacement


-------------------------------------------------------------------
THEORY f1 IS

  RULE f1.1
	if goal is (B)
		prove (A or a => B)
		not if (B) is in hypothesis
		if list (A or a) contains (X)
		if we make a successfull attempt to prove (X) with current prover force
		then initial goal is proved

  RULE f1.2
	if goal is (B)
		prove (A & a => B)
		not if (B) is in hypothesis
		if we make a successfull attempt to prove (a) with current prover force
		if we make a successfull attempt to prove (A) with current prover force
		then initial goal is proved

  RULE f1.3
	if goal is (S => Q)
		prove (H)
		if (P or R => Q) is in hypothesis
		if list (P or R) contains (H) and gives (S) without this element
		not if (S => Q) is in hypothesis
		then initial goal is proved


-------------------------------------------------------------------
THEORY InFINXY IS

  RULE InFINXY.1
	if goal is (struct(M): FIN(struct(L)))
		if tactic (RecordMakeListX) proves (RecordMakeListG(InFin,L,M)) and gives result (R)
		prove (R)
		then initial goal is proved

  RULE InFINXY.2
	if goal is (A: FIN(B))
		prove (A: POW(B))
		prove (A: POW(B) => A: FIN(B))
		then initial goal is proved

  RULE InFINXY.3
	if goal is (a: FIN({}))
		prove (a = {})
		then initial goal is proved

  RULE InFINXY.4
	if goal is (a: FIN({b}))
		prove (a: POW({b}))
		then initial goal is proved

  RULE InFINXY.5
	if goal is (a: FIN(b\/c))
		if (b: FIN(B)) is in hypothesis
		if (c: FIN(C)) is in hypothesis
		prove (a: POW(b\/c))
		then initial goal is proved

  RULE InFINXY.6
	if goal is (a: FIN(b/\c))
		if (c: FIN(C)) is in hypothesis
		prove (a: POW(b/\c))
		then initial goal is proved

  RULE InFINXY.7
	if goal is (a: FIN(b/\c))
		if (b: FIN(B)) is in hypothesis
		prove (a: POW(b/\c))
		then initial goal is proved

  RULE InFINXY.8
	if goal is (a: FIN(b-c))
		if (b: FIN(B)) is in hypothesis
		prove (a: POW(b-c))
		then initial goal is proved

  RULE InFINXY.9
	if goal is (r: FIN((a..b)*(c..d)))
		prove (r: POW((a..b)*(c..d)))
		then initial goal is proved

  RULE InFINXY.10
	if goal is (a: FIN(dom(r)))
		if (r: B <-> C) is in hypothesis
		if (B: FIN(D)) is in hypothesis
		prove (a: POW(dom(r)))
		then initial goal is proved

  RULE InFINXY.11
	if goal is (a: FIN(dom(r)))
		if (r: B <-> C) is in hypothesis
		if (dom(r): FIN(D)) is in hypothesis
		prove (a: POW(dom(r)))
		then initial goal is proved

  RULE InFINXY.12
	if goal is (a: FIN(dom(r)))
		if (r~: C +-> B) is in hypothesis
		if (C: FIN(D)) is in hypothesis
		prove (a: POW(dom(r)))
		then initial goal is proved

  RULE InFINXY.13
	if goal is (a: FIN(dom(r)))
		if (r~: C +-> B) is in hypothesis
		if (ran(r): FIN(D)) is in hypothesis
		prove (a: POW(dom(r)))
		then initial goal is proved

  RULE InFINXY.14
	if goal is (a: FIN(ran(r)))
		if (r: B +-> C) is in hypothesis
		if (B: FIN(D)) is in hypothesis
		prove (a: POW(ran(r)))
		then initial goal is proved

  RULE InFINXY.15
	if goal is (a: FIN(ran(r)))
		if (r: B +-> C) is in hypothesis
		if (dom(r): FIN(D)) is in hypothesis
		prove (a: POW(ran(r)))
		then initial goal is proved

  RULE InFINXY.16
	if goal is (a: FIN(ran(r)))
		if (r: B <-> C) is in hypothesis
		if (C: FIN(D)) is in hypothesis
		prove (a: POW(ran(r)))
		then initial goal is proved

  RULE InFINXY.17
	if goal is (a: FIN(ran(r)))
		if (r: B <-> C) is in hypothesis
		if (ran(r): FIN(D)) is in hypothesis
		prove (a: POW(ran(r)))
		then initial goal is proved

  RULE InFINXY.18
	if goal is (a: FIN(u<|r))
		if (r: B +-> C) is in hypothesis
		if (B: FIN(D)) is in hypothesis
		prove (a: POW(u<|r))
		then initial goal is proved

  RULE InFINXY.19
	if goal is (a: FIN(u<|r))
		if (r: B +-> C) is in hypothesis
		if (dom(r): FIN(B)) is in hypothesis
		prove (a: POW(u<|r))
		then initial goal is proved

  RULE InFINXY.20
	if goal is (a: FIN(u<|r))
		if (r~: C +-> B) is in hypothesis
		if (C: FIN(D)) is in hypothesis
		prove (a: POW(u<|r))
		then initial goal is proved

  RULE InFINXY.21
	if goal is (a: FIN(u<|r))
		if (r~: C +-> B) is in hypothesis
		if (ran(r): FIN(D)) is in hypothesis
		prove (a: POW(u<|r))
		then initial goal is proved

  RULE InFINXY.22
	if goal is (a: FIN(u<|r))
		if (r: B +-> C) is in hypothesis
		if (dom(r)/\u: FIN(D)) is in hypothesis
		prove (a: POW(u<|r))
		then initial goal is proved

  RULE InFINXY.23
	if goal is (a: FIN(u<|r))
		if (r: B +-> C) is in hypothesis
		if (u/\dom(r): FIN(D)) is in hypothesis
		prove (a: POW(u<|r))
		then initial goal is proved

  RULE InFINXY.24
	if goal is (a: FIN(u<|r))
		if (r: B +-> C) is in hypothesis
		if (u: FIN(D)) is in hypothesis
		prove (a: POW(u<|r))
		then initial goal is proved

  RULE InFINXY.25
	if goal is (a: FIN(u<<|r))
		if (r: B +-> C) is in hypothesis
		if (B: FIN(D)) is in hypothesis
		prove (a: POW(u<<|r))
		then initial goal is proved

  RULE InFINXY.26
	if goal is (a: FIN(u<<|r))
		if (r: B +-> C) is in hypothesis
		if (dom(r): FIN(B)) is in hypothesis
		prove (a: POW(u<<|r))
		then initial goal is proved

  RULE InFINXY.27
	if goal is (a: FIN(u<<|r))
		if (r~: C +-> B) is in hypothesis
		if (C: FIN(D)) is in hypothesis
		prove (a: POW(u<<|r))
		then initial goal is proved

  RULE InFINXY.28
	if goal is (a: FIN(u<<|r))
		if (r~: C +-> B) is in hypothesis
		if (ran(r): FIN(D)) is in hypothesis
		prove (a: POW(u<<|r))
		then initial goal is proved

  RULE InFINXY.29
	if goal is (a: FIN(u<<|r))
		if (r: B +-> C) is in hypothesis
		if (dom(r)-u: FIN(D)) is in hypothesis
		prove (a: POW(u<<|r))
		then initial goal is proved

  RULE InFINXY.30
	if goal is (a: FIN(r|>u))
		if (r: B +-> C) is in hypothesis
		if (B: FIN(D)) is in hypothesis
		prove (a: POW(r|>u))
		then initial goal is proved

  RULE InFINXY.31
	if goal is (a: FIN(r|>u))
		if (r: B +-> C) is in hypothesis
		if (dom(r): FIN(B)) is in hypothesis
		prove (a: POW(r|>u))
		then initial goal is proved

  RULE InFINXY.32
	if goal is (a: FIN(r|>u))
		if (r~: C +-> B) is in hypothesis
		if (C: FIN(D)) is in hypothesis
		prove (a: POW(r|>u))
		then initial goal is proved

  RULE InFINXY.33
	if goal is (a: FIN(r|>u))
		if (r~: C +-> B) is in hypothesis
		if (ran(r): FIN(D)) is in hypothesis
		prove (a: POW(r|>u))
		then initial goal is proved

  RULE InFINXY.34
	if goal is (a: FIN(r|>u))
		if (r~: C +-> B) is in hypothesis
		if (ran(r)/\u: FIN(D)) is in hypothesis
		prove (a: POW(r|>u))
		then initial goal is proved

  RULE InFINXY.35
	if goal is (a: FIN(r|>u))
		if (r~: C +-> B) is in hypothesis
		if (u/\ran(r): FIN(D)) is in hypothesis
		prove (a: POW(r|>u))
		then initial goal is proved

  RULE InFINXY.36
	if goal is (a: FIN(r|>u))
		if (r~: C +-> B) is in hypothesis
		if (u: FIN(D)) is in hypothesis
		prove (a: POW(r|>u))
		then initial goal is proved

  RULE InFINXY.37
	if goal is (a: FIN(r|>>u))
		if (r: B +-> C) is in hypothesis
		if (B: FIN(D)) is in hypothesis
		prove (a: POW(r|>>u))
		then initial goal is proved

  RULE InFINXY.38
	if goal is (a: FIN(r|>>u))
		if (r: B +-> C) is in hypothesis
		if (dom(r): FIN(B)) is in hypothesis
		prove (a: POW(r|>>u))
		then initial goal is proved

  RULE InFINXY.39
	if goal is (a: FIN(r|>>u))
		if (r~: C +-> B) is in hypothesis
		if (C: FIN(D)) is in hypothesis
		prove (a: POW(r|>>u))
		then initial goal is proved

  RULE InFINXY.40
	if goal is (a: FIN(r|>>u))
		if (r~: C +-> B) is in hypothesis
		if (ran(r): FIN(D)) is in hypothesis
		prove (a: POW(r|>>u))
		then initial goal is proved

  RULE InFINXY.41
	if goal is (a: FIN(r|>>u))
		if (r~: C +-> B) is in hypothesis
		if (ran(r)-u: FIN(D)) is in hypothesis
		prove (a: POW(r|>>u))
		then initial goal is proved

  RULE InFINXY.42
	if goal is (a: FIN(r<+{x}))
		if (r: B +-> C) is in hypothesis
		if (B: FIN(D)) is in hypothesis
		prove (a: POW(r<+{x}))
		then initial goal is proved

  RULE InFINXY.43
	if goal is (a: FIN(r<+{x}))
		if (r: B +-> C) is in hypothesis
		if (dom(r): FIN(D)) is in hypothesis
		prove (a: POW(r<+{x}))
		then initial goal is proved

  RULE InFINXY.44
	if goal is (a: FIN(r<+{x}))
		if (r~: C +-> B) is in hypothesis
		if (C: FIN(D)) is in hypothesis
		prove (a: POW(r<+{x}))
		then initial goal is proved

  RULE InFINXY.45
	if goal is (a: FIN(r<+{x}))
		if (r~: C +-> B) is in hypothesis
		if (ran(r): FIN(D)) is in hypothesis
		prove (a: POW(r<+{x}))
		then initial goal is proved

  RULE InFINXY.46
	if goal is (x: FIN(a..b))
		prove (x: POW(a..b))
		then initial goal is proved

  RULE InFINXY.47
	if goal is (a: FIN(r[u]))
		if (r: B +-> C) is in hypothesis
		if (B: FIN(D)) is in hypothesis
		prove (a: POW(r[u]))
		then initial goal is proved

  RULE InFINXY.48
	if goal is (a: FIN(r[u]))
		if (r: B +-> C) is in hypothesis
		if (dom(r): FIN(D)) is in hypothesis
		prove (a: POW(r[u]))
		then initial goal is proved

  RULE InFINXY.49
	if goal is (a: FIN(r[u]))
		if (r: B <-> C) is in hypothesis
		if (C: FIN(D)) is in hypothesis
		prove (a: POW(r[u]))
		then initial goal is proved

  RULE InFINXY.50
	if goal is (a: FIN(r[u]))
		if (r: B <-> C) is in hypothesis
		if (ran(r): FIN(D)) is in hypothesis
		prove (a: POW(r[u]))
		then initial goal is proved

  RULE InFINXY.51
	if goal is (a: FIN(r[u]))
		if (r: B +-> C) is in hypothesis
		if (u: FIN(D)) is in hypothesis
		prove (a: POW(r[u]))
		then initial goal is proved

  RULE InFINXY.52
	if goal is (a: FIN(r[u]))
		if (r: B +-> C) is in hypothesis
		if (dom(r)/\u: FIN(D)) is in hypothesis
		prove (a: POW(r[u]))
		then initial goal is proved

  RULE InFINXY.53
	if goal is (a: FIN(r[u]))
		if (r: B +-> C) is in hypothesis
		if (u/\dom(r): FIN(D)) is in hypothesis
		prove (a: POW(r[u]))
		then initial goal is proved

  RULE InFINXY.54
	if goal is ({a}: FIN(S))
		prove (a: S)
		then initial goal is proved

  RULE InFINXY.55
	if goal is (a\/{b}: FIN(S))
		prove (b: S)
		prove (a: FIN(S))
		then initial goal is proved

  RULE InFINXY.56
	if goal is (SET(x).(x: T): FIN(S))
		if (x) is a variable list whith no free occurences in (T)
		prove (T: FIN(S))
		then initial goal is proved

  RULE InFINXY.57
	if goal is (a\/b: FIN(S))
		prove (a: FIN(S))
		prove (b: FIN(S))
		then initial goal is proved

  RULE InFINXY.58
	if goal is (s/\{a}: FIN(S))
		prove (s/\{a}: POW(S))
		then initial goal is proved

  RULE InFINXY.59
	if goal is ({a}/\s: FIN(S))
		prove (s/\{a}: POW(S))
		then initial goal is proved

  RULE InFINXY.60
	if goal is (s/\t: FIN(S))
		if (t: FIN(T)) is in hypothesis
		prove (s/\t: POW(S))
		then initial goal is proved

  RULE InFINXY.61
	if goal is (s/\t: FIN(T))
		if (s: FIN(S)) is in hypothesis
		prove (s/\t: POW(T))
		then initial goal is proved

  RULE InFINXY.62
	if goal is ({a}-t: FIN(S))
		prove ({a}-t: POW(S))
		then initial goal is proved

  RULE InFINXY.63
	if goal is ((n..p)-t: FIN(S))
		prove ((n..p)-t: POW(S))
		then initial goal is proved

  RULE InFINXY.64
	if goal is (s-t: FIN(T))
		if (s: FIN(S)) is in hypothesis
		prove (s-t: POW(T))
		then initial goal is proved

  RULE InFINXY.65
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE InFINXY.66
	if goal is (dom(r): FIN(S))
		if (r: n..p <-> B) is in hypothesis
		prove (dom(r): POW(S))
		then initial goal is proved

  RULE InFINXY.67
	if goal is (dom(r): FIN(S))
		if (r: A <-> B) is in hypothesis
		if (A: FIN(D)) is in hypothesis
		prove (dom(r): POW(S))
		then initial goal is proved

  RULE InFINXY.68
	if goal is (dom(r): FIN(S))
		if (r: A <-> B) is in hypothesis
		if (dom(r): FIN(D)) is in hypothesis
		prove (dom(r): POW(S))
		then initial goal is proved

  RULE InFINXY.69
	if goal is (dom(r): FIN(S))
		if (r~: B +-> A) is in hypothesis
		if (B: FIN(D)) is in hypothesis
		prove (dom(r): POW(S))
		then initial goal is proved

  RULE InFINXY.70
	if goal is (dom(r): FIN(S))
		if (r~: B +-> A) is in hypothesis
		if (ran(r): FIN(D)) is in hypothesis
		prove (dom(r): POW(S))
		then initial goal is proved

  RULE InFINXY.71
	if goal is (ran(r): FIN(S))
		if (r: A <-> n..p) is in hypothesis
		prove (ran(r): POW(S))
		then initial goal is proved

  RULE InFINXY.72
	if goal is (ran(r): FIN(S))
		if (r: A +-> B) is in hypothesis
		if (A: FIN(D)) is in hypothesis
		prove (ran(r): POW(S))
		then initial goal is proved

  RULE InFINXY.73
	if goal is (ran(r): FIN(S))
		if (r: A +-> B) is in hypothesis
		if (dom(r): FIN(D)) is in hypothesis
		prove (ran(r): POW(S))
		then initial goal is proved

  RULE InFINXY.74
	if goal is (ran(r): FIN(S))
		if (r: A <-> B) is in hypothesis
		if (B: FIN(D)) is in hypothesis
		prove (ran(r): POW(S))
		then initial goal is proved

  RULE InFINXY.75
	if goal is (ran(r): FIN(S))
		if (r: A <-> B) is in hypothesis
		if (ran(r): FIN(D)) is in hypothesis
		prove (ran(r): POW(S))
		then initial goal is proved

  RULE InFINXY.76
	if goal is (u<|r: FIN(S))
		if (r: B +-> C) is in hypothesis
		if (B: FIN(D)) is in hypothesis
		prove (u<|r: POW(S))
		then initial goal is proved

  RULE InFINXY.77
	if goal is (u<|r: FIN(S))
		if (r: B +-> C) is in hypothesis
		if (dom(r): FIN(B)) is in hypothesis
		prove (u<|r: POW(S))
		then initial goal is proved

  RULE InFINXY.78
	if goal is (u<|r: FIN(S))
		if (r~: C +-> B) is in hypothesis
		if (C: FIN(D)) is in hypothesis
		prove (u<|r: POW(S))
		then initial goal is proved

  RULE InFINXY.79
	if goal is (u<|r: FIN(S))
		if (r~: C +-> B) is in hypothesis
		if (ran(r): FIN(D)) is in hypothesis
		prove (u<|r: POW(S))
		then initial goal is proved

  RULE InFINXY.80
	if goal is (u<|r: FIN(S))
		if (r: B +-> C) is in hypothesis
		if (dom(r)/\u: FIN(D)) is in hypothesis
		prove (u<|r: POW(S))
		then initial goal is proved

  RULE InFINXY.81
	if goal is (u<|r: FIN(S))
		if (r: B +-> C) is in hypothesis
		if (u/\dom(r): FIN(D)) is in hypothesis
		prove (u<|r: POW(S))
		then initial goal is proved

  RULE InFINXY.82
	if goal is (u<|r: FIN(S))
		if (r: B +-> C) is in hypothesis
		if (u: FIN(D)) is in hypothesis
		prove (u<|r: POW(S))
		then initial goal is proved

  RULE InFINXY.83
	if goal is (u<<|r: FIN(S))
		if (r: B +-> C) is in hypothesis
		if (B: FIN(D)) is in hypothesis
		prove (u<<|r: POW(S))
		then initial goal is proved

  RULE InFINXY.84
	if goal is (u<<|r: FIN(S))
		if (r: B +-> C) is in hypothesis
		if (dom(r): FIN(B)) is in hypothesis
		prove (u<<|r: POW(S))
		then initial goal is proved

  RULE InFINXY.85
	if goal is (u<<|r: FIN(S))
		if (r~: C +-> B) is in hypothesis
		if (C: FIN(D)) is in hypothesis
		prove (u<<|r: POW(S))
		then initial goal is proved

  RULE InFINXY.86
	if goal is (u<<|r: FIN(S))
		if (r~: C +-> B) is in hypothesis
		if (ran(r): FIN(D)) is in hypothesis
		prove (u<<|r: POW(S))
		then initial goal is proved

  RULE InFINXY.87
	if goal is (u<<|r: FIN(S))
		if (r: B +-> C) is in hypothesis
		if (dom(r)-u: FIN(D)) is in hypothesis
		prove (u<<|r: POW(S))
		then initial goal is proved

  RULE InFINXY.88
	if goal is (r|>u: FIN(S))
		if (r: B +-> C) is in hypothesis
		if (B: FIN(D)) is in hypothesis
		prove (r|>u: POW(S))
		then initial goal is proved

  RULE InFINXY.89
	if goal is (r|>u: FIN(S))
		if (r: B +-> C) is in hypothesis
		if (dom(r): FIN(B)) is in hypothesis
		prove (r|>u: POW(S))
		then initial goal is proved

  RULE InFINXY.90
	if goal is (r|>u: FIN(S))
		if (r~: C +-> B) is in hypothesis
		if (C: FIN(D)) is in hypothesis
		prove (r|>u: POW(S))
		then initial goal is proved

  RULE InFINXY.91
	if goal is (r|>u: FIN(S))
		if (r~: C +-> B) is in hypothesis
		if (ran(r): FIN(D)) is in hypothesis
		prove (r|>u: POW(S))
		then initial goal is proved

  RULE InFINXY.92
	if goal is (r|>u: FIN(S))
		if (r~: C +-> B) is in hypothesis
		if (ran(r)/\u: FIN(D)) is in hypothesis
		prove (r|>u: POW(S))
		then initial goal is proved

  RULE InFINXY.93
	if goal is (r|>u: FIN(S))
		if (r~: C +-> B) is in hypothesis
		if (u/\ran(r): FIN(D)) is in hypothesis
		prove (r|>u: POW(S))
		then initial goal is proved

  RULE InFINXY.94
	if goal is (r|>u: FIN(S))
		if (r~: C +-> B) is in hypothesis
		if (u: FIN(D)) is in hypothesis
		prove (r|>u: POW(S))
		then initial goal is proved

  RULE InFINXY.95
	if goal is (r|>>u: FIN(S))
		if (r: B +-> C) is in hypothesis
		if (B: FIN(D)) is in hypothesis
		prove (r|>>u: POW(S))
		then initial goal is proved

  RULE InFINXY.96
	if goal is (r|>>u: FIN(S))
		if (r: B +-> C) is in hypothesis
		if (dom(r): FIN(B)) is in hypothesis
		prove (r|>>u: POW(S))
		then initial goal is proved

  RULE InFINXY.97
	if goal is (r|>>u: FIN(S))
		if (r~: C +-> B) is in hypothesis
		if (C: FIN(D)) is in hypothesis
		prove (r|>>u: POW(S))
		then initial goal is proved

  RULE InFINXY.98
	if goal is (r|>>u: FIN(S))
		if (r~: C +-> B) is in hypothesis
		if (ran(r): FIN(D)) is in hypothesis
		prove (r|>>u: POW(S))
		then initial goal is proved

  RULE InFINXY.99
	if goal is (r|>>u: FIN(S))
		if (r~: C +-> B) is in hypothesis
		if (ran(r)-u: FIN(D)) is in hypothesis
		prove (r|>>u: POW(S))
		then initial goal is proved

  RULE InFINXY.100
	if goal is (r<+{x|->y}: FIN(S))
		if (r: B +-> C) is in hypothesis
		if (B: FIN(D)) is in hypothesis
		prove (r<+{x|->y}: POW(S))
		then initial goal is proved

  RULE InFINXY.101
	if goal is (r<+{x|->y}: FIN(S))
		if (r: B +-> C) is in hypothesis
		if (dom(r): FIN(D)) is in hypothesis
		prove (r<+{x|->y}: POW(S))
		then initial goal is proved

  RULE InFINXY.102
	if goal is (r<+{x|->y}: FIN(S))
		if (r~: C +-> B) is in hypothesis
		if (C: FIN(D)) is in hypothesis
		prove (r<+{x|->y}: POW(S))
		then initial goal is proved

  RULE InFINXY.103
	if goal is (r<+{x|->y}: FIN(S))
		if (r~: C +-> B) is in hypothesis
		if (ran(r): FIN(D)) is in hypothesis
		prove (r<+{x|->y}: POW(S))
		then initial goal is proved

  RULE InFINXY.104
	if goal is (r~: FIN(S))
		if (r: B +-> C) is in hypothesis
		if (B: FIN(D)) is in hypothesis
		prove (r~: POW(S))
		then initial goal is proved

  RULE InFINXY.105
	if goal is (r~: FIN(S))
		if (r: B +-> C) is in hypothesis
		if (dom(r): FIN(D)) is in hypothesis
		prove (r~: POW(S))
		then initial goal is proved

  RULE InFINXY.106
	if goal is (r~: FIN(S))
		if (r~: C +-> B) is in hypothesis
		if (C: FIN(D)) is in hypothesis
		prove (r~: POW(S))
		then initial goal is proved

  RULE InFINXY.107
	if goal is (r~: FIN(S))
		if (r~: C +-> B) is in hypothesis
		if (ran(r): FIN(D)) is in hypothesis
		prove (r~: POW(S))
		then initial goal is proved

  RULE InFINXY.108
	if goal is (n..p: FIN(S))
		prove (n..p: POW(S))
		then initial goal is proved

  RULE InFINXY.109
	if goal is (r[u]: FIN(S))
		if (r: B +-> C) is in hypothesis
		if (B: FIN(D)) is in hypothesis
		prove (r[u]: POW(S))
		then initial goal is proved

  RULE InFINXY.110
	if goal is (r[u]: FIN(S))
		if (r: B +-> C) is in hypothesis
		if (dom(r): FIN(D)) is in hypothesis
		prove (r[u]: POW(S))
		then initial goal is proved

  RULE InFINXY.111
	if goal is (r[u]: FIN(S))
		if (r: B <-> C) is in hypothesis
		if (C: FIN(D)) is in hypothesis
		prove (r[u]: POW(S))
		then initial goal is proved

  RULE InFINXY.112
	if goal is (r[u]: FIN(S))
		if (r: B <-> C) is in hypothesis
		if (ran(r): FIN(D)) is in hypothesis
		prove (r[u]: POW(S))
		then initial goal is proved

  RULE InFINXY.113
	if goal is (r[u]: FIN(S))
		if (r: B +-> C) is in hypothesis
		if (u: FIN(D)) is in hypothesis
		prove (r[u]: POW(S))
		then initial goal is proved

  RULE InFINXY.114
	if goal is (r[u]: FIN(S))
		if (r: B +-> C) is in hypothesis
		if (dom(r)/\u: FIN(D)) is in hypothesis
		prove (r[u]: POW(S))
		then initial goal is proved

  RULE InFINXY.115
	if goal is (r[u]: FIN(S))
		if (r: B +-> C) is in hypothesis
		if (u/\dom(r): FIN(D)) is in hypothesis
		prove (r[u]: POW(S))
		then initial goal is proved

  RULE InFINXY.116
	if goal is (a: FIN(B))
		if (B: FIN(C)) is in hypothesis
		prove (a: POW(B))
		then initial goal is proved

  RULE InFINXY.117
	if goal is (a: FIN(B))
		if (a: FIN(A)) is in hypothesis
		prove (a: POW(B))
		then initial goal is proved

  RULE InFINXY.118
	if goal is ({a}: FIN(INTEGER))
		prove (a: INTEGER)
		then initial goal is proved

  RULE InFINXY.119
	goal ({}: FIN(S)) is always TRUE

  RULE InFINXY.120
	if goal is (a: FIN(c))
		if (a: FIN(b)) is in hypothesis
		if (b: FIN(c)) is in hypothesis
		then initial goal is proved

  RULE InFINXY.121
	if goal is (a: FIN(c))
		if (b: FIN(c)) is in hypothesis
		if (a: FIN(b)) is in hypothesis
		then initial goal is proved

  RULE InFINXY.122
	if goal is (a: FIN(c))
		if (a: FIN(b)) is in hypothesis
		if (b: POW(c)) is in hypothesis
		then initial goal is proved

  RULE InFINXY.123
	if goal is (a: FIN(c))
		if (b: POW(c)) is in hypothesis
		if (a: FIN(b)) is in hypothesis
		then initial goal is proved

  RULE InFINXY.124
	if goal is (a: FIN(c))
		if (a: POW(b)) is in hypothesis
		if (b: FIN(c)) is in hypothesis
		then initial goal is proved

  RULE InFINXY.125
	if goal is (a: FIN(c))
		if (b: FIN(c)) is in hypothesis
		if (a: POW(b)) is in hypothesis
		then initial goal is proved

  RULE InFINXY.126
	if goal is (s: FIN(INTEGER))
		if (s: POW(a..b)) is in hypothesis
		then initial goal is proved

  RULE InFINXY.127
	goal (p..q: FIN(INTEGER)) is always TRUE

  RULE InFINXY.128
	goal (BOOL: FIN(BOOL)) is always TRUE

  RULE InFINXY.129
	goal (NAT: FIN(INTEGER)) is always TRUE

  RULE InFINXY.130
	goal (INT: FIN(INTEGER)) is always TRUE


-------------------------------------------------------------------
THEORY InFunctionTryXY IS

  RULE InFunctionTryXY.1
	if goal is (f(x): a +-> b)
		if (f: s +-> (t --> u)) is in hypothesis
		if we make a successfull attempt to prove (t: POW(a) & u: POW(b)) with current prover force
		then initial goal is proved


-------------------------------------------------------------------
THEORY InFunctionXY IS

  RULE InFunctionXY.1
	if goal is (f: u +-> v)
		if (f: s +-> t) is in hypothesis
		prove (dom(f): POW(u))
		prove (ran(f): POW(v))
		then initial goal is proved

  RULE InFunctionXY.2
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE InFunctionXY.3
	if goal is ((f<-e)~: s +-> NATURAL)
		prove (f~: s +-> NATURAL)
		prove (e: s)
		prove (not(e: ran(f)))
		then initial goal is proved

  RULE InFunctionXY.4
	if goal is ((e->f)~: s +-> NATURAL)
		prove (f~: s +-> NATURAL)
		prove (e: s)
		prove (not(e: ran(f)))
		then initial goal is proved

  RULE InFunctionXY.5
	if goal is (a*b: c +-> d)
		if (not(a = {})) is in hypothesis
		if (b: FIN(b)) is in hypothesis
		prove (a: POW(c))
		prove (b: POW(d))
		prove (card(b)<=1)
		then initial goal is proved

  RULE InFunctionXY.6
	if goal is ((f;g): s +-> u)
		if (f: s +-> t) is in hypothesis
		prove (ran(f)<|g: t +-> u)
		then initial goal is proved

  RULE InFunctionXY.7
	if goal is ((f;g): w +-> x)
		if (f: s +-> t) is in hypothesis
		if (g: u +-> v) is in hypothesis
		prove (dom(f;g): POW(w))
		prove (ran(f;g): POW(x))
		then initial goal is proved

  RULE InFunctionXY.8
	if goal is (a<|f: s +-> t)
		if (f: u +-> v) is in hypothesis
		prove (dom(f)/\a: POW(s))
		prove (f[a]: POW(t))
		then initial goal is proved

  RULE InFunctionXY.9
	if goal is (f|>a: s +-> t)
		if (f: u +-> v) is in hypothesis
		prove (dom(f|>a): POW(s))
		prove (ran(f)/\a: POW(t))
		then initial goal is proved

  RULE InFunctionXY.10
	if goal is (a<<|f: s +-> t)
		if (f: u +-> v) is in hypothesis
		prove (dom(f)-a: POW(s))
		prove (ran(a<<|f): POW(t))
		then initial goal is proved

  RULE InFunctionXY.11
	if goal is (f|>>a: s +-> t)
		if (f: u +-> v) is in hypothesis
		prove (dom(f|>>a): POW(s))
		prove (ran(f)-a: POW(t))
		then initial goal is proved

  RULE InFunctionXY.12
	if goal is (a\/b: s +-> t)
		prove (a: s +-> t)
		prove (b: s +-> t)
		prove (dom(a)<|b = dom(b)<|a)
		then initial goal is proved

  RULE InFunctionXY.13
	if goal is (f-g: s +-> t)
		if (f: u +-> v) is in hypothesis
		prove (dom(f-g): POW(s))
		prove (ran(f-g): POW(t))
		then initial goal is proved

  RULE InFunctionXY.14
	if goal is (f<+g: s +-> t)
		prove (dom(g)<<|f: s +-> t)
		prove (g: s +-> t)
		then initial goal is proved

  RULE InFunctionXY.15
	if goal is (f><g: s +-> U*V)
		prove (dom(f)<|g: s +-> V)
		prove (dom(g)<|f: s +-> U)
		then initial goal is proved

  RULE InFunctionXY.16
	if goal is ((f || g): s*t +-> U*V)
		if (not(f = {})) is in hypothesis
		if (not(g = {})) is in hypothesis
		prove (f: s +-> U)
		prove (g: t +-> V)
		then initial goal is proved

  RULE InFunctionXY.17
	if goal is ({a|->b}: s +-> t)
		prove (a: s)
		prove (b: t)
		then initial goal is proved

  RULE InFunctionXY.18
	if goal is (fnc(r): s +-> t)
		if (x) is a fresh variable in (fnc(r): s +-> t)
		prove (dom(r): POW(s))
		prove (!x.(x: dom(r) => r[{x}]: t))
		then initial goal is proved

  RULE InFunctionXY.19
	if goal is (%x.(p | e): s +-> t)
		if (x) is a variable list whith no free occurences in (s +-> t)
		prove (!x.(p => x: s & e: t))
		then initial goal is proved

  RULE InFunctionXY.20
	if goal is (f: s-a +-> t)
		if (f: s +-> t) is in hypothesis
		prove (a/\dom(f) = {})
		then initial goal is proved

  RULE InFunctionXY.21
	if goal is (f: s +-> t-a)
		if (f: s +-> t) is in hypothesis
		prove (a/\ran(f) = {})
		then initial goal is proved

  RULE InFunctionXY.22
	if goal is (f<+g: s +-> t)
		if (f: s +-> t) is in hypothesis
		prove (g: s +-> t)
		then initial goal is proved

  RULE InFunctionXY.23
	if goal is (tail(f)~: s +-> NATURAL)
		if (f~: s +-> NATURAL) is in hypothesis
		then initial goal is proved

  RULE InFunctionXY.24
	if goal is (front(f)~: s +-> NATURAL)
		if (f~: s +-> NATURAL) is in hypothesis
		then initial goal is proved

  RULE InFunctionXY.25
	if goal is ((f/|\n)~: s +-> NATURAL)
		if (f~: s +-> NATURAL) is in hypothesis
		then initial goal is proved

  RULE InFunctionXY.26
	if goal is ((f\|/n)~: s +-> NATURAL)
		if (f~: s +-> NATURAL) is in hypothesis
		then initial goal is proved

  RULE InFunctionXY.27
	if goal is ((f;g): s +-> v)
		if (f: s +-> t) is in hypothesis
		if (g: u +-> v) is in hypothesis
		then initial goal is proved

  RULE InFunctionXY.28
	if goal is (f/\g: s +-> t)
		if (g: s +-> t) is in hypothesis
		if (f: u <-> v) is in hypothesis
		then initial goal is proved

  RULE InFunctionXY.29
	if goal is (f/\g: s +-> t)
		if (f: s +-> t) is in hypothesis
		if (g: u <-> v) is in hypothesis
		then initial goal is proved

  RULE InFunctionXY.30
	if goal is (f|>a: s +-> t)
		if (f: s +-> t) is in hypothesis
		then initial goal is proved

  RULE InFunctionXY.31
	if goal is (f|>>a: s +-> t)
		if (f: s +-> t) is in hypothesis
		then initial goal is proved

  RULE InFunctionXY.32
	if goal is (a<|f: s +-> t)
		if (f: s +-> t) is in hypothesis
		then initial goal is proved

  RULE InFunctionXY.33
	if goal is (a<<|f: s +-> t)
		if (f: s +-> t) is in hypothesis
		then initial goal is proved

  RULE InFunctionXY.34
	if goal is (f-a: s +-> t)
		if (f: s +-> t) is in hypothesis
		if (a: u <-> v) is in hypothesis
		then initial goal is proved

  RULE InFunctionXY.35
	if goal is (f\/{a|->b}: s\/{a} +-> t\/{b})
		if (f: s +-> t) is in hypothesis
		if (not(a: s)) is in hypothesis
		then initial goal is proved

  RULE InFunctionXY.36
	goal ({}: s +-> t) is always TRUE


-------------------------------------------------------------------
THEORY InINTEGERTryXY IS

  RULE InINTEGERTryXY.1
	if goal is (n: INTEGER)
		if (n: T) is in hypothesis
		if we make a successfull attempt to prove (T: POW(INTEGER)) with current prover force
		then initial goal is proved


-------------------------------------------------------------------
THEORY InINTEGERXY IS

  RULE InINTEGERXY.1
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE InINTEGERXY.2
	if goal is (n*m: INTEGER)
		prove (n: INTEGER)
		prove (m: INTEGER)
		then initial goal is proved

  RULE InINTEGERXY.3
	if goal is (n-m: INTEGER)
		prove (n: INTEGER)
		prove (m: INTEGER)
		then initial goal is proved

  RULE InINTEGERXY.4
	if goal is (n+m: INTEGER)
		prove (n: INTEGER)
		prove (m: INTEGER)
		then initial goal is proved

  RULE InINTEGERXY.5
	if goal is (n: INTEGER)
		if (n: a..b) is in hypothesis
		then initial goal is proved

  RULE InINTEGERXY.6
	if goal is (n: INTEGER)
		if (n) is a numerical constant
		then initial goal is proved

  RULE InINTEGERXY.7
	if goal is (-n: INTEGER)
		if (n) is a numerical constant
		then initial goal is proved

  RULE InINTEGERXY.8
	if goal is (n-p: INTEGER)
		if (n: INTEGER) is in hypothesis
		then initial goal is proved

  RULE InINTEGERXY.9
	if goal is (n-p: INTEGER)
		if (p: INTEGER) is in hypothesis
		then initial goal is proved

  RULE InINTEGERXY.10
	goal (n**p: INTEGER) is always TRUE

  RULE InINTEGERXY.11
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE InINTEGERXY.12
	if goal is (n*p: INTEGER)
		if (n: INTEGER) is in hypothesis
		then initial goal is proved

  RULE InINTEGERXY.13
	if goal is (n*p: INTEGER)
		if (p: INTEGER) is in hypothesis
		then initial goal is proved

  RULE InINTEGERXY.14
	goal (n/p: INTEGER) is always TRUE

  RULE InINTEGERXY.15
	goal (PI(x).(P | E): INTEGER) is always TRUE

  RULE InINTEGERXY.16
	if goal is (PI(x).(x: S | E): INTEGER)
		if (S: FIN(T)) is in hypothesis
		then initial goal is proved

  RULE InINTEGERXY.17
	if goal is (SIGMA(x).(P | E): INTEGER)
		if list (P & btrue) contains (x: p..q)
		if (x) is a variable list whith no free occurences in (p,q)
		then initial goal is proved

  RULE InINTEGERXY.18
	if goal is (SIGMA(x).(P | E): INTEGER)
		if (P) matches on (u & v)
		if list (P & btrue) contains (x<=q)
		if list (P & btrue) contains (p<=x)
		if (x) is a variable list whith no free occurences in (p,q)
		then initial goal is proved

  RULE InINTEGERXY.19
	goal (max(S): INTEGER) is always TRUE

  RULE InINTEGERXY.20
	goal (min(S): INTEGER) is always TRUE

  RULE InINTEGERXY.21
	goal (card(S): INTEGER) is always TRUE

  RULE InINTEGERXY.22
	goal (size(s): INTEGER) is always TRUE

  RULE InINTEGERXY.23
	goal (card(n..p): INTEGER) is always TRUE

  RULE InINTEGERXY.24
	if goal is (n: INTEGER)
		if (n: T) is in hypothesis
		if (T: POW(NATURAL)) is in hypothesis
		then initial goal is proved

  RULE InINTEGERXY.25
	if goal is (s(a): INTEGER)
		if (s: seq(T)) is in hypothesis
		if (T: POW(NATURAL)) is in hypothesis
		then initial goal is proved

  RULE InINTEGERXY.26
	if goal is (s(a): INTEGER)
		if (s: S +-> T) is in hypothesis
		if (T: POW(NATURAL)) is in hypothesis
		then initial goal is proved

  RULE InINTEGERXY.27
	goal (succ(n): INTEGER) is always TRUE

  RULE InINTEGERXY.28
	goal (pred(n): INTEGER) is always TRUE

  RULE InINTEGERXY.29
	goal (n+p: INTEGER) is always TRUE

  RULE InINTEGERXY.30
	goal (PI(x).(x: p..q | E): INTEGER) is always TRUE


-------------------------------------------------------------------
THEORY InREALTryXY IS

  RULE InREALTryXY.1
	if goal is (n: REAL)
		if (n: T) is in hypothesis
		if we make a successfull attempt to prove (T: POW(REAL)) with current prover force
		then initial goal is proved


-------------------------------------------------------------------
THEORY InREALXY IS

  RULE InREALXY.1
	if goal is (n: REAL)
		prove (breal(n))
		then initial goal is proved

  RULE InREALXY.2
	if goal is (s(a): REAL)
		if (s: seq(T)) is in hypothesis
		if (T: POW(REAL)) is in hypothesis
		then initial goal is proved

  RULE InREALXY.3
	if goal is (s(a): REAL)
		if (s: S +-> T) is in hypothesis
		if (T: POW(REAL)) is in hypothesis
		then initial goal is proved

  RULE InREALXY.4
	goal (n rplus p: REAL) is always TRUE

  RULE InREALXY.5
	goal (n rminus p: REAL) is always TRUE

  RULE InREALXY.6
	goal (n rmul p: REAL) is always TRUE

  RULE InREALXY.7
	goal (n rdiv p: REAL) is always TRUE

  RULE InREALXY.8
	goal (n rpow p: REAL) is always TRUE

  RULE InREALXY.9
	goal (n rdiv p: REAL) is always TRUE

  RULE InREALXY.10
	goal (rPI(x).(P | E): REAL) is always TRUE

  RULE InREALXY.11
	goal (rSIGMA(x).(P | E): REAL) is always TRUE

  RULE InREALXY.12
	goal (rmax(S): REAL) is always TRUE

  RULE InREALXY.13
	goal (rmin(S): REAL) is always TRUE


-------------------------------------------------------------------
THEORY InPOWTryXY IS

  RULE InPOWTryXY.1
	if goal is (s +-> t: POW(a +-> b))
		if we make a successfull attempt to prove (s: POW(a)) with current prover force
		if we make a successfull attempt to prove (t: POW(b)) with current prover force
		then initial goal is proved

  RULE InPOWTryXY.2
	if goal is (a: POW(b\/c))
		if we make a successfull attempt to prove (a: POW(b)) with current prover force
		then initial goal is proved

  RULE InPOWTryXY.3
	if goal is (a: POW(b\/c))
		if we make a successfull attempt to prove (a: POW(c)) with current prover force
		then initial goal is proved

  RULE InPOWTryXY.4
	if goal is (dom(a): POW(dom(b)))
		if we make a successfull attempt to prove (a: POW(b)) with current prover force
		then initial goal is proved

  RULE InPOWTryXY.5
	if goal is (ran(a): POW(ran(b)))
		if we make a successfull attempt to prove (a: POW(b)) with current prover force
		then initial goal is proved


-------------------------------------------------------------------
THEORY InPOWXY IS

  RULE InPOWXY.1
	if goal is (a: POW({}))
		prove (a = {})
		then initial goal is proved

  RULE InPOWXY.2
	if goal is (a: POW({b}))
		prove (not(a = {}) => a = {b})
		then initial goal is proved

  RULE InPOWXY.3
	if goal is (a: POW(b\/{c}))
		if (not(c: a)) is in hypothesis
		prove (a: POW(b))
		then initial goal is proved

  RULE InPOWXY.4
	if goal is (a: POW(SET(x).p))
		if (y) is a fresh variable in (a: POW(SET(x).p))
		prove (!y.(y: a => [x:=y]p))
		then initial goal is proved

  RULE InPOWXY.5
	if goal is (a: POW(b/\c))
		prove (a: POW(c))
		prove (a: POW(b))
		then initial goal is proved

  RULE InPOWXY.6
	if goal is (a: POW(b-c))
		prove (a: POW(b))
		prove (a/\c = {})
		then initial goal is proved

  RULE InPOWXY.7
	if goal is (r: POW(A*B))
		prove (dom(r): POW(A))
		prove (ran(r): POW(B))
		then initial goal is proved

  RULE InPOWXY.8
	if goal is (a: POW(u<|r))
		prove (a: POW(r))
		prove (dom(a): POW(u))
		then initial goal is proved

  RULE InPOWXY.9
	if goal is (a: POW(u<<|r))
		prove (a: POW(r))
		prove (dom(a)/\u = {})
		then initial goal is proved

  RULE InPOWXY.10
	if goal is (a: POW(r|>u))
		prove (a: POW(r))
		prove (ran(a): POW(u))
		then initial goal is proved

  RULE InPOWXY.11
	if goal is (a: POW(r|>>u))
		prove (a: POW(r))
		prove (ran(a)/\u = {})
		then initial goal is proved

  RULE InPOWXY.12
	if goal is (a: POW(p..q))
		prove (not(a = {}) =>
			a: FIN(INTEGER)
		&	p<=min(a)
		&	max(a)<=q)
		then initial goal is proved

  RULE InPOWXY.13
	if goal is ({a}: POW(b))
		prove (a: b)
		then initial goal is proved

  RULE InPOWXY.14
	if goal is (SET(x).p: POW(a))
		if (x) is a variable list whith no free occurences in (a)
		prove (!x.(p => x: a))
		then initial goal is proved

  RULE InPOWXY.15
	if goal is (a\/b: POW(c))
		prove (a: POW(c))
		prove (b: POW(c))
		then initial goal is proved

  RULE InPOWXY.16
	if goal is (a/\{b}: POW(c))
		prove (b: a => b: c)
		then initial goal is proved

  RULE InPOWXY.17
	if goal is (a/\{b}: POW({}))
		prove (not(b: a))
		then initial goal is proved

  RULE InPOWXY.18
	if goal is ({a}/\b: POW(c))
		prove (a: b => a: c)
		then initial goal is proved

  RULE InPOWXY.19
	if goal is ({a}/\b: POW({}))
		prove (not(a: b))
		then initial goal is proved

  RULE InPOWXY.20
	if goal is (a/\(b\/c): POW(d))
		prove (a/\b: POW(d))
		prove (a/\c: POW(d))
		then initial goal is proved

  RULE InPOWXY.21
	if goal is (a\/b/\c: POW(d))
		prove (b/\c: POW(d))
		prove (a/\c: POW(d))
		then initial goal is proved

  RULE InPOWXY.22
	if goal is (a/\(b\/{c}): POW({}))
		prove (not(c: a))
		prove (a/\b: POW({}))
		then initial goal is proved

  RULE InPOWXY.23
	if goal is (a/\SET(x).P: POW({}))
		if (x) is a variable list whith no free occurences in (a)
		prove (!x.(P => not(x: a)))
		then initial goal is proved

  RULE InPOWXY.24
	if goal is (a-b: POW(c))
		prove (a: POW(c\/b))
		then initial goal is proved

  RULE InPOWXY.25
	if goal is (a-b: POW(c))
		if (b/\a = {}) is in hypothesis
		prove (a: POW(c))
		then initial goal is proved

  RULE InPOWXY.26
	if goal is (a-b: POW(c))
		if (a/\b = {}) is in hypothesis
		prove (a: POW(c))
		then initial goal is proved

  RULE InPOWXY.27
	if goal is ((r;s): POW({}))
		prove (ran(r)/\dom(s): POW({}))
		then initial goal is proved

  RULE InPOWXY.28
	if goal is (dom(r/\{a|->b}): POW(c))
		prove (b: r[{a}] => a: c)
		then initial goal is proved

  RULE InPOWXY.29
	if goal is (ran(r/\{a|->b}): POW(c))
		prove (b: r[{a}] => b: c)
		then initial goal is proved

  RULE InPOWXY.30
	if goal is (u<|r: POW({}))
		prove (dom(r)/\u: POW({}))
		then initial goal is proved

  RULE InPOWXY.31
	if goal is (u<<|r: POW({}))
		prove (dom(r): POW(u))
		then initial goal is proved

  RULE InPOWXY.32
	if goal is (r|>u: POW({}))
		prove (ran(r)/\u: POW({}))
		then initial goal is proved

  RULE InPOWXY.33
	if goal is (r|>>u: POW({}))
		prove (ran(r): POW(u))
		then initial goal is proved

  RULE InPOWXY.34
	if goal is (p..q: POW(a))
		if (x) is a fresh variable in (p..q: POW(a))
		prove (!x.(x: INTEGER & p<=x & x<=q => x: a))
		then initial goal is proved

  RULE InPOWXY.35
	if goal is (p..q: POW(a..b))
		prove (p<=q =>
			a<=p
		&	q<=b)
		then initial goal is proved

  RULE InPOWXY.36
	if goal is (p..q: POW(NATURAL))
		prove (p<=q =>
			p: INTEGER
		&	0<=p)
		then initial goal is proved

  RULE InPOWXY.37
	if goal is (POW(a): POW(POW(b)))
		prove (a: POW(b))
		then initial goal is proved

  RULE InPOWXY.38
	if goal is (A\/{a}<|f: POW(g))
		prove (A<|f: POW(g))
		prove ({a}<|f: POW(g))
		then initial goal is proved

  RULE InPOWXY.39
	if goal is (f|>(A\/{a}): POW(g))
		prove (f|>A: POW(g))
		prove (f|>{a}: POW(g))
		then initial goal is proved

  RULE InPOWXY.40
	if goal is (dom(g)<|(f\/{a|->b}): POW(g))
		prove (dom(g)<|f: POW(g))
		prove (a: dom(g) => b: g[{a}])
		then initial goal is proved

  RULE InPOWXY.41
	if goal is (f\/{a|->b}|>ran(g): POW(g))
		prove (f|>ran(g): POW(g))
		prove (b: ran(g) => a: g~[{b}])
		then initial goal is proved

  RULE InPOWXY.42
	if goal is (dom(g)<|(f\/{a|->b}): POW(g\/{a|->b}))
		prove (dom(g)<|f: POW(g\/{a|->b}))
		then initial goal is proved

  RULE InPOWXY.43
	if goal is (f\/{a|->b}|>ran(g): POW(g\/{a|->b}))
		prove (f|>ran(g): POW(g\/{a|->b}))
		then initial goal is proved

  RULE InPOWXY.44
	if goal is (struct(E): POW(struct(F)))
		if tactic (StructDecompX) proves (StructDecompG(Inc,E,F)) and gives result (R)
		prove (R)
		then initial goal is proved


-------------------------------------------------------------------
THEORY InPOWLeavesXY IS

  RULE InPOWLeavesXY.1
	if goal is (a: POW(r<+s))
		if (a: POW(r)) is in hypothesis
		if (dom(s)/\dom(a) = {}) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.2
	if goal is (a: POW(r<+s))
		if (a: POW(r)) is in hypothesis
		if (dom(a)/\dom(s) = {}) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.3
	if goal is (a: POW(r<+s))
		if (a: POW(s)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.4
	if goal is (a: POW(b..c+1))
		if (a: POW(b..c)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.5
	goal ({}: POW(a)) is always TRUE

  RULE InPOWLeavesXY.6
	goal (a/\b: POW(a)) is always TRUE

  RULE InPOWLeavesXY.7
	goal (a/\b: POW(b)) is always TRUE

  RULE InPOWLeavesXY.8
	if goal is (a/\b: POW(c/\d))
		if (a: POW(c)) is in hypothesis
		if (b: POW(d)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.9
	if goal is (a/\b: POW(c/\d))
		if (a: POW(d)) is in hypothesis
		if (b: POW(c)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.10
	if goal is (a/\b: POW(a/\d))
		if (b: POW(d)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.11
	if goal is (a/\b: POW(d/\a))
		if (b: POW(d)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.12
	if goal is (a/\b: POW(b/\d))
		if (a: POW(d)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.13
	if goal is (a/\b: POW(d/\b))
		if (a: POW(d)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.14
	if goal is (a/\b: POW(c))
		if (a\/d = c) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.15
	if goal is (a/\b: POW(c))
		if (b: POW(c-d)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.16
	if goal is (a/\b: POW(c))
		if (b\/d = c) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.17
	if goal is (a/\b: POW(c))
		if (a: POW(c)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.18
	if goal is (a/\b: POW(c))
		if (b: POW(c)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.19
	if goal is (a/\b: POW(c))
		if (b/\a: POW(c)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.20
	goal (r[u]-s[u]: POW((r-s)[u])) is always TRUE

  RULE InPOWLeavesXY.21
	goal (r[u]-r[v]: POW(r[u-v])) is always TRUE

  RULE InPOWLeavesXY.22
	goal ((r;s)-(r;t): POW(r;s-t)) is always TRUE

  RULE InPOWLeavesXY.23
	goal ((r;t)-(s;t): POW(r-s;t)) is always TRUE

  RULE InPOWLeavesXY.24
	goal (dom(r)-dom(s): POW(dom(r-s))) is always TRUE

  RULE InPOWLeavesXY.25
	goal (ran(r)-ran(s): POW(ran(r-s))) is always TRUE

  RULE InPOWLeavesXY.26
	goal ((r;s/\t): POW((r;s)/\(r;t))) is always TRUE

  RULE InPOWLeavesXY.27
	goal ((r/\s;t): POW((r;t)/\(s;t))) is always TRUE

  RULE InPOWLeavesXY.28
	if goal is (dom(r-s): POW(a))
		if (dom(r): POW(a)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.29
	if goal is (dom(a): POW(dom(b)))
		if (a: POW(b)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.30
	if goal is (dom(r|>a): POW(b))
		if (dom(r): POW(b)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.31
	if goal is (dom(r|>>a): POW(b))
		if (dom(r): POW(b)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.32
	if goal is (ran(a): POW(ran(b)))
		if (a: POW(b)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.33
	if goal is (ran(r): POW(v))
		if (r: u +-> v) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.34
	if goal is (r[a]: POW(b))
		if (ran(r): POW(b)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.35
	if goal is (ran(a<<|r): POW(b))
		if (ran(r): POW(b)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.36
	if goal is (ran(r-s): POW(b))
		if (ran(r): POW(b)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.37
	if goal is (u<|r: POW(s))
		if (v<|r: POW(s)) is in hypothesis
		if (u: POW(v)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.38
	goal (u<|r: POW(r)) is always TRUE

  RULE InPOWLeavesXY.39
	if goal is (u<<|r: POW(s))
		if (v<<|r: POW(s)) is in hypothesis
		if (v: POW(u)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.40
	goal (u<<|r: POW(r)) is always TRUE

  RULE InPOWLeavesXY.41
	if goal is (r|>u: POW(s))
		if (r|>v: POW(s)) is in hypothesis
		if (u: POW(v)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.42
	goal (r|>u: POW(r)) is always TRUE

  RULE InPOWLeavesXY.43
	if goal is (r|>>u: POW(s))
		if (r|>>v: POW(s)) is in hypothesis
		if (v: POW(u)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.44
	goal (r|>>u: POW(r)) is always TRUE

  RULE InPOWLeavesXY.45
	if goal is (r[u-A]: POW(v))
		if (r[u] = v) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.46
	if goal is (r[u]: POW(b))
		if (ran(r): POW(b)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.47
	if goal is (r[u]: POW(b))
		if (r: a <-> b) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.48
	if goal is (r[u]: POW(r[v]))
		if (u: POW(v)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.49
	if goal is (r[u]: POW(s[u]))
		if (r: POW(s)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.50
	if goal is (r[u-v]: POW(a))
		if (r[u]: POW(a)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.51
	if goal is (A/\B: POW(C\/D))
		if (A: POW(C)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.52
	if goal is (A/\B: POW(C\/D))
		if (A: POW(D)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.53
	if goal is (A/\B: POW(C\/D))
		if (B: POW(C)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.54
	if goal is (A/\B: POW(C\/D))
		if (B: POW(D)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.55
	if goal is (a: POW(c\/b))
		if list (c\/b) contains (a)
		then initial goal is proved

  RULE InPOWLeavesXY.56
	if goal is (a: POW(b\/c))
		if (a\/d = c) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.57
	if goal is (a: POW(b\/c))
		if (a: POW(c)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.58
	if goal is (a: POW(b\/c))
		if (a\/d = b) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.59
	if goal is (a: POW(b\/c))
		if (a: POW(b)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.60
	if goal is (a: POW(b\/c))
		if (a: POW(c\/b)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.61
	if goal is (a: POW(SET(x).(x: s & p)))
		if (a = SET(x).(x: s & p & q)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.62
	if goal is (a: POW(SET(x).(x: s & q)))
		if (a = SET(x).(x: s & p & q)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.63
	if goal is (a: POW(SET(x).(x: s & p)))
		if (a: POW(SET(x).(x: s & p & q))) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.64
	if goal is (a: POW(SET(x).(x: s & q)))
		if (a: POW(SET(x).(x: s & p & q))) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.65
	goal (a: POW(a)) is always TRUE

  RULE InPOWLeavesXY.66
	if goal is (a: POW(b))
		if (a: FIN(b)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.67
	if goal is (a: POW(c))
		if (b = c) is in hypothesis
		if (a: POW(b)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.68
	if goal is (a: POW(c))
		if (a: POW(b)) is in hypothesis
		if (b: POW(c)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.69
	if goal is (a: POW(c))
		if (b: POW(c)) is in hypothesis
		if (a: POW(b)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.70
	if goal is (a: POW(c))
		if (a = b) is in hypothesis
		if (b = c) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.71
	if goal is (a: POW(c))
		if (b = c) is in hypothesis
		if (a = b) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.72
	if goal is (a: POW(r))
		if (u<|r = a) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.73
	if goal is (x: POW(s<-r))
		if (x: POW(s)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.74
	if goal is (s: POW(NATURAL))
		if (s: POW(a..b)) is in hypothesis
		if tactic (Fast_Prove_Positif) proves (a)
		then initial goal is proved

  RULE InPOWLeavesXY.75
	goal (s: POW(INTEGER)) is always TRUE

  RULE InPOWLeavesXY.76
	goal (s: POW(INTEGER*INTEGER)) is always TRUE

  RULE InPOWLeavesXY.77
	if goal is (dom(f): POW(s))
		if (f: s +-> t) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.78
	if goal is (ran(f): POW(t))
		if (f: s +-> t) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.79
	if goal is (a: POW(b))
		if (a = b) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.80
	if goal is (a: POW(b))
		if (b = a) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.81
	if goal is (a: POW(b))
		if (a: POW(b/\a)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.82
	if goal is (a: POW(b))
		if (a: POW(a/\b)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.83
	if goal is (a: POW(b\/{c}))
		if (not(c: a)) is in hypothesis
		if (a: POW(b)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.84
	if goal is (dom(a<|r): POW(b))
		if (dom(r): POW(b)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.85
	if goal is (dom(a<<|r): POW(b))
		if (dom(r): POW(b)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.86
	if goal is (ran(r|>a): POW(b))
		if (ran(r): POW(b)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.87
	if goal is (ran(r|>>a): POW(b))
		if (ran(r): POW(b)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.88
	if goal is (a-b: POW(c))
		if (a: POW(c)) is in hypothesis
		then initial goal is proved

  RULE InPOWLeavesXY.89
	if goal is (SET(x).(x: a & p): POW(a))
		if (x) is a variable list whith no free occurences in (a)
		then initial goal is proved

  RULE InPOWLeavesXY.90
	goal (dom(r/\s): POW(dom(r)/\dom(s))) is always TRUE

  RULE InPOWLeavesXY.91
	goal (ran(r/\s): POW(ran(r)/\ran(s))) is always TRUE

  RULE InPOWLeavesXY.92
	goal (r[u/\v]: POW(r[u]/\r[v])) is always TRUE


-------------------------------------------------------------------
THEORY InRelationXY IS

  RULE InRelationXY.1
	if goal is (a: s <-> t)
		prove (dom(a): POW(s))
		prove (ran(a): POW(t))
		then initial goal is proved

  RULE InRelationXY.2
	if goal is (a*b: s <-> t)
		prove (not(a = {}) & not(b = {}) =>
			a: POW(s)
		&	b: POW(t))
		then initial goal is proved

  RULE InRelationXY.3
	if goal is (a~: s <-> t)
		prove (a: t <-> s)
		then initial goal is proved

  RULE InRelationXY.4
	if goal is (a\/b: s <-> t)
		prove (a: s <-> t)
		prove (b: s <-> t)
		then initial goal is proved

  RULE InRelationXY.5
	if goal is (a/\b: s <-> t)
		if (x,y) is a fresh variable in (a/\b: s <-> t)
		prove (!(x,y).(x|->y: a/\b => x|->y: s*t))
		then initial goal is proved

  RULE InRelationXY.6
	if goal is (a-b: s <-> t)
		if (x,y) is a fresh variable in (a-b: s <-> t)
		prove (!(x,y).(x|->y: a-b => x|->y: s*t))
		then initial goal is proved

  RULE InRelationXY.7
	if goal is (a<+b: s <-> t)
		prove (dom(b)<<|a: s <-> t)
		prove (b: s <-> t)
		then initial goal is proved

  RULE InRelationXY.8
	if goal is (r<+q: s <-> t)
		if (r: s <-> t) is in hypothesis
		prove (q: s <-> t)
		then initial goal is proved

  RULE InRelationXY.9
	if goal is (fnc(r): s <-> t)
		if (x) is a fresh variable in (fnc(r): s <-> t)
		prove (dom(r): POW(s))
		prove (!x.(x: dom(r) => r[{x}]: t))
		then initial goal is proved

  RULE InRelationXY.10
	if goal is (%x.(p | e): s <-> t)
		if (x) is a variable list whith no free occurences in (s,t)
		prove (!x.(p => x: s & e: t))
		then initial goal is proved

  RULE InRelationXY.11
	if goal is (r: s-a <-> t)
		if (r: s <-> t) is in hypothesis
		prove (a/\dom(r) = {})
		then initial goal is proved

  RULE InRelationXY.12
	if goal is (r: s <-> t-a)
		if (r: s <-> t) is in hypothesis
		prove (a/\ran(r) = {})
		then initial goal is proved

  RULE InRelationXY.13
	if goal is (r/\q: s <-> t)
		if (r: s <-> t) is in hypothesis
		if (q: s <-> t) is in hypothesis
		then initial goal is proved

  RULE InRelationXY.14
	if goal is (r-s: a <-> b)
		if (r: a <-> b) is in hypothesis
		then initial goal is proved

  RULE InRelationXY.15
	goal ({}: a <-> b) is always TRUE

  RULE InRelationXY.16
	if goal is (r: s\/u <-> t\/v)
		if (r: s <-> v) is in hypothesis
		then initial goal is proved

  RULE InRelationXY.17
	if goal is (r: s\/u <-> t\/v)
		if (r: u <-> t) is in hypothesis
		then initial goal is proved

  RULE InRelationXY.18
	if goal is (r: s\/u <-> t\/v)
		if (r: u <-> v) is in hypothesis
		then initial goal is proved

  RULE InRelationXY.19
	if goal is (r: s\/u <-> t\/v)
		if (r: s <-> t) is in hypothesis
		then initial goal is proved

  RULE InRelationXY.20
	if goal is (r: s\/u <-> t)
		if (r: s <-> t) is in hypothesis
		then initial goal is proved

  RULE InRelationXY.21
	if goal is (r: s\/u <-> t)
		if (r: u <-> t) is in hypothesis
		then initial goal is proved

  RULE InRelationXY.22
	if goal is (r: s <-> t\/v)
		if (r: s <-> t) is in hypothesis
		then initial goal is proved

  RULE InRelationXY.23
	if goal is (r: s <-> t\/v)
		if (r: s <-> v) is in hypothesis
		then initial goal is proved


-------------------------------------------------------------------
THEORY InSequenceXY IS

  RULE InSequenceXY.1
	if goal is (%x.(x: 1..m | E): seq(S))
		prove (!x.(x: 1..m => E: S))
		if (x) is a variable list whith no free occurences in (S)
		then initial goal is proved

  RULE InSequenceXY.2
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE InSequenceXY.3
	if goal is ({x|->a}: seq(S))
		prove (x = 1)
		prove (a: S)
		then initial goal is proved

  RULE InSequenceXY.4
	if goal is ([a]: seq(S))
		not if (a) matches on (u,v)
		prove (a: S)
		then initial goal is proved

  RULE InSequenceXY.5
	if goal is ([a,b]: seq(S))
		prove ([a]: seq(S))
		prove (b: S)
		then initial goal is proved

  RULE InSequenceXY.6
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE InSequenceXY.7
	if goal is (a/|\n: seq(S))
		prove (a[1..n]: POW(S))
		then initial goal is proved

  RULE InSequenceXY.8
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE InSequenceXY.9
	if goal is (a\|/n: seq(S))
		prove (a[n+1..size(a)]: POW(S))
		then initial goal is proved

  RULE InSequenceXY.10
	if goal is (a<-b: seq(S))
		prove (a: seq(S))
		prove (b: S)
		then initial goal is proved

  RULE InSequenceXY.11
	if goal is (a->b: seq(S))
		prove (b: seq(S))
		prove (a: S)
		then initial goal is proved

  RULE InSequenceXY.12
	if goal is (rev(a): seq(S))
		prove (a: seq(S))
		then initial goal is proved

  RULE InSequenceXY.13
	if goal is (a^b: seq(S))
		prove (a: seq(S))
		prove (b: seq(S))
		then initial goal is proved

  RULE InSequenceXY.14
	if goal is (tail(a): seq(S))
		prove (a[2..size(a)]: POW(S))
		then initial goal is proved

  RULE InSequenceXY.15
	if goal is (front(a): seq(S))
		prove (a[1..size(a)-1]: POW(S))
		then initial goal is proved

  RULE InSequenceXY.16
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE InSequenceXY.17
	if goal is (1..n<|s: seq(S))
		if (s: seq(E)) is in hypothesis
		prove (s[1..n]: POW(S))
		then initial goal is proved

  RULE InSequenceXY.18
	if goal is (s<+{a|->b}: seq(A))
		if (s: seq(A)) is in hypothesis
		prove (1<=a)
		prove (a<=size(s)+1)
		prove (b: A)
		then initial goal is proved

  RULE InSequenceXY.19
	goal ({}: seq(S)) is always TRUE

  RULE InSequenceXY.20
	if goal is (s<+{size(s)+1|->b}: seq(S))
		if (s: seq(S)) is in hypothesis
		prove (b: S)
		then initial goal is proved

  RULE InSequenceXY.21
	if goal is (a/|\n: seq(S))
		if (a: seq(S)) is in hypothesis
		then initial goal is proved

  RULE InSequenceXY.22
	if goal is (a\|/n: seq(S))
		if (a: seq(S)) is in hypothesis
		then initial goal is proved

  RULE InSequenceXY.23
	if goal is (tail(a): seq(S))
		if (a: seq(S)) is in hypothesis
		then initial goal is proved

  RULE InSequenceXY.24
	if goal is (front(a): seq(S))
		if (a: seq(S)) is in hypothesis
		then initial goal is proved

  RULE InSequenceXY.25
	if goal is ((1..n<|succ;t): seq(S))
		if (t: seq(S)) is in hypothesis
		then initial goal is proved

  RULE InSequenceXY.26
	if goal is (1..n<|s: seq(S))
		if (s: seq(S)) is in hypothesis
		then initial goal is proved

  RULE InSequenceXY.27
	if goal is ({size(s)}<<|s: seq(S))
		if (s: seq(S)) is in hypothesis
		then initial goal is proved

  RULE InSequenceXY.28
	if goal is (f<+g: seq(s))
		if (f: seq(s)) is in hypothesis
		if (g: dom(f) +-> s) is in hypothesis
		then initial goal is proved

  RULE InSequenceXY.29
	if goal is (f<+g: seq(s))
		if (f: seq(s)) is in hypothesis
		if (g: 1..size(f) +-> s) is in hypothesis
		then initial goal is proved


-------------------------------------------------------------------
THEORY InSetTryXY IS

  RULE InSetTryXY.1
	if goal is (x: t)
		if (x: s) is in hypothesis
		if we make a successfull attempt to prove (s: POW(t)) with current prover force
		then initial goal is proved


-------------------------------------------------------------------
THEORY InSetXY IS

  RULE InSetXY.1
	if goal is (y: f[{x}])
		prove (x|->y: f)
		then initial goal is proved

  RULE InSetXY.2
	if goal is (x: a|>>b)
		not if (x) matches on (y,z)
		prove (x: a)
		prove (not(ran({x}): POW(b)))
		then initial goal is proved

  RULE InSetXY.3
	if goal is (x: a<<|b)
		not if (x) matches on (y,z)
		prove (x: b)
		prove (not(dom({x}): POW(a)))
		then initial goal is proved

  RULE InSetXY.4
	if goal is (x: a|>b)
		not if (x) matches on (y,z)
		prove (x: a)
		prove (ran({x}): POW(b))
		then initial goal is proved

  RULE InSetXY.5
	if goal is (x: a<|b)
		not if (x) matches on (y,z)
		prove (x: b)
		prove (dom({x}): POW(a))
		then initial goal is proved

  RULE InSetXY.6
	if goal is (x|->y: a~)
		prove (y|->x: a)
		then initial goal is proved

  RULE InSetXY.7
	if goal is (x,y: a~)
		prove (y,x: a)
		then initial goal is proved

  RULE InSetXY.8
	if goal is (x|->y: id(a))
		prove (x = y)
		prove (x: a)
		then initial goal is proved

  RULE InSetXY.9
	if goal is (x,y: id(a))
		prove (x = y)
		prove (x: a)
		then initial goal is proved

  RULE InSetXY.10
	if goal is (a|->b: (p;q))
		prove (a: dom(p|>dom(q|>{b})))
		then initial goal is proved

  RULE InSetXY.11
	if goal is (a|->b: S*T)
		prove (a: S)
		prove (b: T)
		then initial goal is proved

  RULE InSetXY.12
	if goal is (a,b: S*T)
		prove (a: S)
		prove (b: T)
		then initial goal is proved

  RULE InSetXY.13
	if goal is (a: n..p)
		prove (n<=a)
		prove (a<=p)
		then initial goal is proved

  RULE InSetXY.14
	if goal is (p: n..p)
		prove (n<=p)
		then initial goal is proved

  RULE InSetXY.15
	if goal is (n: n..p)
		prove (n<=p)
		then initial goal is proved

  RULE InSetXY.16
	if goal is (a: S-T)
		prove (a: S)
		prove (not(a: T))
		then initial goal is proved

  RULE InSetXY.17
	if goal is (a: S\/T)
		prove (not(a: T) => a: S)
		then initial goal is proved

  RULE InSetXY.18
	if goal is (a: b\/{c})
		if tactic (Fast_Prove_Difference) proves (not(a = c))
		prove (a: b)
		then initial goal is proved

  RULE InSetXY.19
	if goal is (a: S/\T)
		prove (a: S)
		prove (a: T)
		then initial goal is proved

  RULE InSetXY.20
	if goal is (a: union(S))
		if (x) is a fresh variable in (a: S)
		prove (#x.(x: S & a: x))
		then initial goal is proved

  RULE InSetXY.21
	if goal is (a: inter(S))
		if (x) is a fresh variable in (a: S)
		prove (!x.(x: S => a: x))
		then initial goal is proved

  RULE InSetXY.22
	if goal is (a: UNION(x).(P | E))
		if (x) is a variable list whith no free occurences in (a)
		prove (#x.(P & a: E))
		then initial goal is proved

  RULE InSetXY.23
	if goal is (a: INTER(x).(P | E))
		if (x) is a variable list whith no free occurences in (a)
		prove (!x.(P => a: E))
		then initial goal is proved

  RULE InSetXY.24
	if goal is (a: {b})
		prove (a = b)
		then initial goal is proved

  RULE InSetXY.25
	if goal is (a: SET(x).P)
		if tactic (SUB;RES) proves (bresult([x:=a]P)) and gives result (R)
		not if (R) matches on ([y:=z]S)
		prove (R)
		then initial goal is proved

  RULE InSetXY.26
	if goal is (a|->b: SET(x,y).P)
		not if (y) matches on (u,v)
		if (x) is a variable list whith no free occurences in (b)
		if tactic (SUB;RES) proves (bresult([y:=b]P)) and gives result (R)
		not if (R) matches on ([t:=z]S)
		prove (a: SET(x).R)
		then initial goal is proved

  RULE InSetXY.27
	if goal is (first(s): A)
		prove (s(1): A)
		then initial goal is proved

  RULE InSetXY.28
	if goal is (last(s): A)
		prove (s(size(s)): A)
		then initial goal is proved

  RULE InSetXY.29
	if goal is (x: dom(f|>{l}))
		if (f: a +-> b) is in hypothesis
		if (x: dom(f)) is in hypothesis
		prove (f(x) = l)
		then initial goal is proved

  RULE InSetXY.30
	if goal is (a: f~[u])
		if (f: A +-> B) is in hypothesis
		prove (a: dom(f))
		prove (f(a): u)
		then initial goal is proved

  RULE InSetXY.31
	if goal is (f(a): A)
		if (ran(f)/\A = {}) is in hypothesis
		prove (bfalse)
		then initial goal is proved

  RULE InSetXY.32
	if goal is (f(a): A)
		if (A/\ran(f) = {}) is in hypothesis
		prove (bfalse)
		then initial goal is proved

  RULE InSetXY.33
	if goal is (c: A)
		if (max(A)<=b) is in hypothesis
		if (b+1<=c) is in hypothesis
		prove (bfalse)
		then initial goal is proved

  RULE InSetXY.34
	if goal is (c: A)
		if (b<=min(A)) is in hypothesis
		if (c+1<=b) is in hypothesis
		prove (bfalse)
		then initial goal is proved

  RULE InSetXY.35
	if goal is (f~(a): A)
		if (dom(f)/\A = {}) is in hypothesis
		prove (bfalse)
		then initial goal is proved

  RULE InSetXY.36
	if goal is (f~(a): A)
		if (A/\dom(f) = {}) is in hypothesis
		prove (bfalse)
		then initial goal is proved

  RULE InSetXY.37
	if goal is (a: {})
		prove (bfalse)
		then initial goal is proved

  RULE InSetXY.38
	if goal is (a: A-A)
		prove (bfalse)
		then initial goal is proved


-------------------------------------------------------------------
THEORY InSetLeavesXY IS

  RULE InSetLeavesXY.1
	if goal is (front(s)~: E +-> NATURAL)
		if (s~: E +-> NATURAL) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.2
	if goal is (tail(s)~: E +-> NATURAL)
		if (s~: E +-> NATURAL) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.3
	if goal is (a: A\/B)
		if list (A\/B) contains ({a})
		then initial goal is proved

  RULE InSetLeavesXY.4
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE InSetLeavesXY.5
	if goal is (a: A)
		if (A = b\/{c}) is in hypothesis
		if list (b\/{c}) contains ({a})
		then initial goal is proved

  RULE InSetLeavesXY.6
	if goal is (a: b\/{c})
		if (c = a) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.7
	if goal is (a: b\/{c})
		if (a = c) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.8
	if goal is (a: b)
		if (a: b\/c) is in hypothesis
		if (not(a: c)) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.9
	if goal is (a: c)
		if (a: b\/c) is in hypothesis
		if (not(a: b)) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.10
	if goal is (a: c)
		if (a: b) is in hypothesis
		if (b: POW(c)) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.11
	if goal is (a: c)
		if (a: b) is in hypothesis
		if (b = c) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.12
	if goal is (a: c)
		if (a: b) is in hypothesis
		if (c = b) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.13
	if goal is (a: c)
		if (b = c) is in hypothesis
		if (a: b) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.14
	if goal is (a: c)
		if (c = b) is in hypothesis
		if (a: b) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.15
	if goal is (f(a): T)
		if (ran(f): POW(T)) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.16
	if goal is (f(a): T)
		if (f: seq(T)) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.17
	if goal is (f(a): T)
		if (f: S +-> T) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.18
	goal (f(a): ran(f)) is always TRUE

  RULE InSetLeavesXY.19
	if goal is (a: A)
		if (a: f~[{c}]) is in hypothesis
		if (dom(f) = A) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.20
	goal (max(s): s) is always TRUE

  RULE InSetLeavesXY.21
	goal (max(s-t): s) is always TRUE

  RULE InSetLeavesXY.22
	goal (min(s): s) is always TRUE

  RULE InSetLeavesXY.23
	goal (min(s-t): s) is always TRUE

  RULE InSetLeavesXY.24
	if goal is (k|>a-{n}: POW(l))
		if (k|>a: POW(l)) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.25
	if goal is (a-{n}<|k: POW(l))
		if (a<|k: POW(l)) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.26
	if goal is (c: d[{l}])
		if (d(l) = c) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.27
	goal (first(s): ran(s)) is always TRUE

  RULE InSetLeavesXY.28
	goal (last(s): ran(s)) is always TRUE

  RULE InSetLeavesXY.29
	if goal is (x|->y: f)
		if (f(x) = y) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.30
	goal (x|->f(x): f) is always TRUE

  RULE InSetLeavesXY.31
	if goal is (x: dom(f|>{a}))
		if (f(x) = a) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.32
	if goal is ((f\/g)(x): P)
		if (ran(f): POW(P)) is in hypothesis
		if (ran(g): POW(P)) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.33
	if goal is (x: a)
		if (x: a\/b) is in hypothesis
		if (b: POW(a)) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.34
	goal (f~(a): dom(f)) is always TRUE

  RULE InSetLeavesXY.35
	if goal is (f~(a): A)
		if (dom(f): POW(A)) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.36
	goal (f(a): f[{a}]) is always TRUE

  RULE InSetLeavesXY.37
	if goal is (prj1(A,B)(x): A)
		if (x: A*B) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.38
	if goal is (prj2(A,B)(x): B)
		if (x: A*B) is in hypothesis
		then initial goal is proved

  RULE InSetLeavesXY.39
	if goal is (s: STRING)
		if (s) is a litteral string
		then initial goal is proved

  RULE InSetLeavesXY.40
	goal (a: b\/{a}) is always TRUE

  RULE InSetLeavesXY.41
	goal (a: {a}) is always TRUE

  RULE InSetLeavesXY.42
	goal (TRUE: BOOL) is always TRUE

  RULE InSetLeavesXY.43
	goal (FALSE: BOOL) is always TRUE

  RULE InSetLeavesXY.44
	goal (bool(C): BOOL) is always TRUE


-------------------------------------------------------------------
THEORY InStructXY IS

  RULE InStructXY.1
	if goal is (rec(a,b): struct(d,e>>f))
		not if (b) matches on (g>>h)
		prove (b: f)
		prove (rec(a): struct(d))
		then initial goal is proved

  RULE InStructXY.2
	if goal is (rec(a,b>>c): struct(d,b>>e))
		prove (c: e)
		prove (rec(a): struct(d))
		then initial goal is proved

  RULE InStructXY.3
	if goal is (rec(b): struct(e>>f))
		not if (b) matches on (g>>h)
		prove (b: f)
		then initial goal is proved

  RULE InStructXY.4
	if goal is (rec(b>>c): struct(b>>e))
		prove (c: e)
		then initial goal is proved


-------------------------------------------------------------------
THEORY NegationXY IS

  RULE NegationXY.1
	if goal is (not(!x.P))
		prove (#x.not(P))
		then initial goal is proved

  RULE NegationXY.2
	if goal is (not(#x.P))
		prove (!x.not(P))
		then initial goal is proved

  RULE NegationXY.3
	if goal is (not(a => b))
		prove (a)
		prove (not(b))
		then initial goal is proved

  RULE NegationXY.4
	if goal is (not(p & q))
		prove (not(p) or not(q))
		then initial goal is proved

  RULE NegationXY.5
	if goal is (not(p or q))
		prove (not(p))
		prove (not(q))
		then initial goal is proved

  RULE NegationXY.6
	if goal is (not(not(p)))
		prove (p)
		then initial goal is proved

  RULE NegationXY.7
	if goal is (not(x<=y))
		prove (y+1<=x)
		then initial goal is proved

  RULE NegationXY.8
	if goal is (not(btrue))
		prove (bfalse)
		then initial goal is proved

  RULE NegationXY.9
	if goal is (not(a: INTEGER & 0<=a))
		prove (a: INTEGER)
		prove (a+1<=0)
		then initial goal is proved

  RULE NegationXY.10
	if goal is (not(x = y))
		if (y+1<=x) is in hypothesis
		then initial goal is proved

  RULE NegationXY.11
	if goal is (not(x = y))
		if (x+1<=y) is in hypothesis
		then initial goal is proved

  RULE NegationXY.12
	goal (not(bfalse)) is always TRUE


-------------------------------------------------------------------
THEORY NotInSetTryXY IS

  RULE NotInSetTryXY.1
	if goal is (not(f(x): s))
		if (f: a +-> b) is in hypothesis
		if (x: dom(f)) is in hypothesis
		if we make a successfull attempt to prove (ran(f)/\s = {}) with current prover force
		then initial goal is proved


-------------------------------------------------------------------
THEORY NotInSetXY IS

  RULE NotInSetXY.1
	if goal is (not(a: b\/c))
		prove (not(a: b))
		prove (not(a: c))
		then initial goal is proved

  RULE NotInSetXY.2
	if goal is (not(A: POW({a})))
		prove (not(A = {}))
		prove (not(A = {a}))
		then initial goal is proved

  RULE NotInSetXY.3
	if goal is (not(a: r[u]))
		if (not(a: r[v])) is in hypothesis
		if (v: POW(u)) is in hypothesis
		prove (not(a: r[u-v]))
		then initial goal is proved

  RULE NotInSetXY.4
	if goal is (not(a: A))
		if (a: A\/B) is in hypothesis
		if (A/\B = {}) is in hypothesis
		prove (a: B)
		then initial goal is proved

  RULE NotInSetXY.5
	if goal is (not(a: B))
		if (a: A\/B) is in hypothesis
		if (A/\B = {}) is in hypothesis
		prove (a: A)
		then initial goal is proved

  RULE NotInSetXY.6
	if goal is (not(a: f~[{b}]))
		if (f: s +-> t) is in hypothesis
		if (c = f(a)) is in hypothesis
		if (a: dom(f)) is in hypothesis
		prove (not(b = c))
		then initial goal is proved

  RULE NotInSetXY.7
	if goal is (not(a: f~[{b}]))
		if (f: s +-> t) is in hypothesis
		if (f(a) = c) is in hypothesis
		if (a: dom(f)) is in hypothesis
		prove (not(b = c))
		then initial goal is proved

  RULE NotInSetXY.8
	if goal is (not(a: ran(b<<|f)))
		if (not(a: ran(f))) is in hypothesis
		then initial goal is proved

  RULE NotInSetXY.9
	if goal is (not(a: f[b]))
		if (not(a: ran(f))) is in hypothesis
		then initial goal is proved

  RULE NotInSetXY.10
	if goal is (not(a: dom(f|>>b)))
		if (not(a: dom(f))) is in hypothesis
		then initial goal is proved

  RULE NotInSetXY.11
	if goal is (not(a: f~[b]))
		if (not(a: dom(f))) is in hypothesis
		then initial goal is proved

  RULE NotInSetXY.12
	if goal is (not(0: ran(s)))
		if (s: a +-> NATURAL-{0}) is in hypothesis
		then initial goal is proved

  RULE NotInSetXY.13
	if goal is (not(0: ran(s~)))
		if (s: seq(a)) is in hypothesis
		then initial goal is proved

  RULE NotInSetXY.14
	goal (not(0: 1..size(s))) is always TRUE

  RULE NotInSetXY.15
	if goal is (not(c: a))
		if (c: b) is in hypothesis
		if (a/\b = {}) is in hypothesis
		then initial goal is proved

  RULE NotInSetXY.16
	if goal is (not(a: c))
		if (not(a: b)) is in hypothesis
		if (c: POW(b)) is in hypothesis
		then initial goal is proved

  RULE NotInSetXY.17
	if goal is (not(a: r[u]))
		if (not(a: r[v])) is in hypothesis
		if (u: POW(v)) is in hypothesis
		then initial goal is proved

  RULE NotInSetXY.18
	if goal is (not(c: A))
		if (A: POW(a..b)) is in hypothesis
		if (b+1<=c) is in hypothesis
		then initial goal is proved

  RULE NotInSetXY.19
	if goal is (not(c: A))
		if (A: POW(a..b)) is in hypothesis
		if (c+1<=a) is in hypothesis
		then initial goal is proved

  RULE NotInSetXY.20
	if goal is (not(a: f~[{b}]))
		if (f: s +-> t) is in hypothesis
		if (not(b = f(a))) is in hypothesis
		then initial goal is proved

  RULE NotInSetXY.21
	if goal is (not(a: f~[{b}]))
		if (f: s +-> t) is in hypothesis
		if (not(f(a) = b)) is in hypothesis
		then initial goal is proved

  RULE NotInSetXY.22
	if goal is (not(a: ran(b<<|f)))
		if (not(a: ran(f))) is in hypothesis
		then initial goal is proved

  RULE NotInSetXY.23
	if goal is (not(a: ran(b<|f)))
		if (not(a: ran(f))) is in hypothesis
		then initial goal is proved

  RULE NotInSetXY.24
	if goal is (not(a: ran(f|>>b)))
		if (not(a: ran(f))) is in hypothesis
		then initial goal is proved

  RULE NotInSetXY.25
	if goal is (not(a: ran(f|>b)))
		if (not(a: ran(f))) is in hypothesis
		then initial goal is proved

  RULE NotInSetXY.26
	if goal is (not(a: dom(f|>>b)))
		if (not(a: dom(f))) is in hypothesis
		then initial goal is proved

  RULE NotInSetXY.27
	if goal is (not(a: dom(f|>b)))
		if (not(a: dom(f))) is in hypothesis
		then initial goal is proved

  RULE NotInSetXY.28
	if goal is (not(a: dom(b<<|f)))
		if (not(a: dom(f))) is in hypothesis
		then initial goal is proved

  RULE NotInSetXY.29
	if goal is (not(a: dom(b<|f)))
		if (not(a: dom(f))) is in hypothesis
		then initial goal is proved


-------------------------------------------------------------------
THEORY OrderTryXY IS

  RULE OrderTryXY.1
	if goal is (card(a\/b)<=card(a\/c))
		if we make a successfull attempt to prove (b: POW(c)) with current prover force
		then initial goal is proved

  RULE OrderTryXY.2
	if goal is (card(a\/b)<=card(c\/b))
		if we make a successfull attempt to prove (a: POW(c)) with current prover force
		then initial goal is proved

  RULE OrderTryXY.3
	if goal is (card(a\/b\/c)<=card(d\/b\/e))
		if we make a successfull attempt to prove (a: POW(d)) with current prover force
		if we make a successfull attempt to prove (c: POW(e)) with current prover force
		then initial goal is proved

  RULE OrderTryXY.4
	if goal is (a<=b+c)
		if (p<=b) is in hypothesis
		if tactic (Fast_Prove_Order) proves (a<=p)
		if we make a successfull attempt to prove (c: INTEGER & 0<=c) with current prover force
		then initial goal is proved

  RULE OrderTryXY.5
	if goal is (x<=max(s))
		if we make a successfull attempt to prove (x: s) with current prover force
		then initial goal is proved

  RULE OrderTryXY.6
	if goal is (min(s)<=x)
		if we make a successfull attempt to prove (x: s) with current prover force
		then initial goal is proved

  RULE OrderTryXY.7
	if goal is (n<=q)
		if (n<=p) is in hypothesis
		not if (p) matches on (n)
		if we make a successfull attempt to prove (p<=q) with current prover force
		then initial goal is proved

  RULE OrderTryXY.8
	if goal is (n<=q)
		if (p<=q) is in hypothesis
		not if (p) matches on (q)
		if we make a successfull attempt to prove (n<=p) with current prover force
		then initial goal is proved


-------------------------------------------------------------------
THEORY OrderXY IS

  RULE OrderXY.1
	if goal is (1<=a*b)
		if (a: INTEGER) is in hypothesis
		if (0<=a) is in hypothesis
		if (b: INTEGER) is in hypothesis
		if (0<=b) is in hypothesis
		prove (1<=a)
		prove (1<=b)
		then initial goal is proved

  RULE OrderXY.2
	if goal is (x<=0)
		if tactic (Fast_Prove_Positif) proves (x)
		prove (x = 0)
		then initial goal is proved

  RULE OrderXY.3
	if goal is (1<=card(a))
		prove (not(a = {}))
		then initial goal is proved

  RULE OrderXY.4
	if goal is (0<=X*Y)
		prove (not(X<=0 & Y<=0) =>
			0<=X
		&	0<=Y)
		then initial goal is proved

  RULE OrderXY.5
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE OrderXY.6
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE OrderXY.7
	if goal is (max(SET(x).p)<=n)
		if (x) is a variable list whith no free occurences in (n)
		prove (!x.(p => x<=n))
		then initial goal is proved

  RULE OrderXY.8
	if goal is (n<=min(SET(x).p))
		if (x) is a variable list whith no free occurences in (n)
		prove (!x.(p => n<=x))
		then initial goal is proved

  RULE OrderXY.9
	if goal is (n<=a)
		if (a<=m) is in hypothesis
		if (m<n) is litteraly true
		prove (bfalse)
		then initial goal is proved

  RULE OrderXY.10
	if goal is (a<=n)
		if (m<=a) is in hypothesis
		if (n<m) is litteraly true
		prove (bfalse)
		then initial goal is proved

  RULE OrderXY.11
	if goal is (a+1<=b)
		if (b<=a) is in hypothesis
		prove (bfalse)
		then initial goal is proved

  RULE OrderXY.12
	if goal is (n<=m)
		if tactic (Fast_Prove_Order) proves (m+1<=n)
		prove (bfalse)
		then initial goal is proved

  RULE OrderXY.13
	if goal is (card(A/\B)<=N)
		if (1<=N) is litteraly true
		if list (A/\B) contains ({e})
		then initial goal is proved

  RULE OrderXY.14
	if goal is (card(a)<=n)
		if (a: POW(b)) is in hypothesis
		if (card(b)<=n) is in hypothesis
		then initial goal is proved

  RULE OrderXY.15
	if goal is (card(a\/{b})<=n)
		if (card(a)+1<=n) is in hypothesis
		then initial goal is proved

  RULE OrderXY.16
	if goal is (n<=size(s))
		if (n: dom(s)) is in hypothesis
		then initial goal is proved

  RULE OrderXY.17
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE OrderXY.18
	if goal is (n<=p)
		if (m+n<=p) is in hypothesis
		if tactic (Fast_Prove_Positif) proves (m)
		then initial goal is proved

  RULE OrderXY.19
	if goal is (n<=p)
		if (n+m<=p) is in hypothesis
		if tactic (Fast_Prove_Positif) proves (m)
		then initial goal is proved

  RULE OrderXY.20
	if goal is (n+1<=min(a))
		if (n<=min(a)) is in hypothesis
		if (not(n: a)) is in hypothesis
		then initial goal is proved

  RULE OrderXY.21
	goal (n<=min(n..p/\a)) is always TRUE

  RULE OrderXY.22
	goal (n<=min((n..p)-a)) is always TRUE

  RULE OrderXY.23
	if goal is (n<=min(a)+p)
		if (n<=min(a)) is in hypothesis
		if (p: INTEGER) is in hypothesis
		if (0<=p) is in hypothesis
		then initial goal is proved

  RULE OrderXY.24
	goal (n<=max(n..p/\a)) is always TRUE

  RULE OrderXY.25
	goal (n<=max((n..p)-a)) is always TRUE

  RULE OrderXY.26
	goal (f(x)<=max(ran(f))) is always TRUE

  RULE OrderXY.27
	if goal is (f(x)<=max(f[a]))
		if (x: a) is in hypothesis
		then initial goal is proved

  RULE OrderXY.28
	if goal is (r(x)<=max(A))
		if (ran(r): POW(A)) is in hypothesis
		then initial goal is proved

  RULE OrderXY.29
	if goal is (n<=max(s))
		if (n: s) is in hypothesis
		then initial goal is proved

  RULE OrderXY.30
	if goal is (min(ran(f))<=f(x))
		if (f: s +-> t) is in hypothesis
		then initial goal is proved

  RULE OrderXY.31
	if goal is (min(f[a])<=f(x))
		if (f: s +-> t) is in hypothesis
		if (x: a) is in hypothesis
		then initial goal is proved

  RULE OrderXY.32
	goal (min(n..p/\a)<=p) is always TRUE

  RULE OrderXY.33
	goal (min((n..p)-a)<=p) is always TRUE

  RULE OrderXY.34
	goal (max(n..p/\a)<=p) is always TRUE

  RULE OrderXY.35
	goal (max((n..p)-a)<=p) is always TRUE

  RULE OrderXY.36
	if goal is (min(b)<=min(a))
		if (a: POW(b)) is in hypothesis
		then initial goal is proved

  RULE OrderXY.37
	if goal is (min(s)<=n)
		if (n: s) is in hypothesis
		then initial goal is proved

  RULE OrderXY.38
	if goal is (max(a)<=max(b))
		if (a: POW(b)) is in hypothesis
		then initial goal is proved

  RULE OrderXY.39
	goal (max(b)<=max(a\/b)) is always TRUE

  RULE OrderXY.40
	goal (max(a)<=max(a\/b)) is always TRUE

  RULE OrderXY.41
	goal (max(a-b)<=max(a)) is always TRUE

  RULE OrderXY.42
	goal (max(a/\b)<=max(b)) is always TRUE

  RULE OrderXY.43
	goal (max(a/\b)<=max(a)) is always TRUE

  RULE OrderXY.44
	goal (min(a)<=min(a/\b)) is always TRUE

  RULE OrderXY.45
	goal (min(b)<=min(a/\b)) is always TRUE

  RULE OrderXY.46
	goal (min(a)<=min(a-b)) is always TRUE

  RULE OrderXY.47
	goal (min(a\/b)<=min(a)) is always TRUE

  RULE OrderXY.48
	goal (min(a\/b)<=min(b)) is always TRUE

  RULE OrderXY.49
	if goal is (max(a)+1<=p)
		if (max(a)<=p) is in hypothesis
		if (not(p: a)) is in hypothesis
		then initial goal is proved

  RULE OrderXY.50
	if goal is (card(SET(x).(x: S & P))<=n)
		if (card(S)<=n) is in hypothesis
		if (x) is a variable list whith no free occurences in (S)
		then initial goal is proved

  RULE OrderXY.51
	if goal is (card(a)<=card(b))
		if (a: POW(b)) is in hypothesis
		then initial goal is proved

  RULE OrderXY.52
	if goal is (card(a-b)<=n)
		if (card(a)<=n) is in hypothesis
		then initial goal is proved

  RULE OrderXY.53
	goal (card(a/\b)<=card(b)) is always TRUE

  RULE OrderXY.54
	goal (card(a-b)<=card(a)) is always TRUE

  RULE OrderXY.55
	if goal is (n<=p)
		if (n<=q) is in hypothesis
		if (m<=p) is in hypothesis
		if (q<=m) is litteraly true
		then initial goal is proved

  RULE OrderXY.56
	if goal is (n<=p)
		if (n<=q) is in hypothesis
		if (q<=p) is in hypothesis
		then initial goal is proved

  RULE OrderXY.57
	if goal is (n<=p)
		if (n<=q) is in hypothesis
		if (q<=r) is in hypothesis
		if (r<=p) is in hypothesis
		then initial goal is proved

  RULE OrderXY.58
	if goal is (n<=p+q)
		if (r<=p) is in hypothesis
		if tactic (Fast_Prove_Order) proves (n<=r)
		if tactic (Fast_Prove_Positif) proves (q)
		then initial goal is proved

  RULE OrderXY.59
	if goal is (n<=p+q)
		if (n<=p) is in hypothesis
		if tactic (Fast_Prove_Positif) proves (q)
		then initial goal is proved

  RULE OrderXY.60
	if goal is (n<=p+q)
		if (r<=q) is in hypothesis
		if tactic (Fast_Prove_Order) proves (n<=r)
		if tactic (Fast_Prove_Positif) proves (p)
		then initial goal is proved

  RULE OrderXY.61
	if goal is (n<=p+q)
		if (n<=q) is in hypothesis
		if tactic (Fast_Prove_Positif) proves (p)
		then initial goal is proved

  RULE OrderXY.62
	if goal is (n+p<=q)
		if (n+m<=q) is in hypothesis
		if tactic (Fast_Prove_Order) proves (p<=m)
		then initial goal is proved

  RULE OrderXY.63
	if goal is (n+p<=m+q)
		if (n<=m) is in hypothesis
		if (p<=q) is in hypothesis
		then initial goal is proved

  RULE OrderXY.64
	if goal is (n+p<=m+q)
		if (n<=q) is in hypothesis
		if (p<=m) is in hypothesis
		then initial goal is proved

  RULE OrderXY.65
	if goal is (a+1<=b)
		if (a<=b) is in hypothesis
		if (not(a = b)) is in hypothesis
		then initial goal is proved

  RULE OrderXY.66
	if goal is (1<=n)
		if tactic (Fast_Prove_Positif) proves (n)
		if (not(n = 0)) is in hypothesis
		then initial goal is proved

  RULE OrderXY.67
	if goal is (n<=n+m)
		if tactic (Fast_Prove_Positif) proves (m)
		then initial goal is proved

  RULE OrderXY.68
	if goal is (a<=n)
		if (a<=m) is in hypothesis
		if tactic (Fast_Prove_All_Order) proves (m<=n)
		then initial goal is proved

  RULE OrderXY.69
	if goal is (n<=q)
		if (p<=q) is in hypothesis
		if tactic (Fast_Prove_All_Order) proves (n<=p)
		then initial goal is proved

  RULE OrderXY.70
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE OrderXY.71
	if goal is (a<=b)
		if (a<=b) is litteraly true
		then initial goal is proved

  RULE OrderXY.72
	goal (x<=x) is always TRUE

  RULE OrderXY.73
	if goal is (0<=c-a-b)
		if (a+b<=c) is in hypothesis
		then initial goal is proved

  RULE OrderXY.74
	if goal is (0<= -a+b+c)
		if (0<=b) is in hypothesis
		if (a<=c) is in hypothesis
		then initial goal is proved

  RULE OrderXY.75
	if goal is (0<= -a+b+c)
		if (0<=c) is in hypothesis
		if (a<=b) is in hypothesis
		then initial goal is proved

  RULE OrderXY.76
	if goal is (0<=a+b-c)
		if (0<=b) is in hypothesis
		if (c<=a) is in hypothesis
		then initial goal is proved

  RULE OrderXY.77
	if goal is (0<=a+b-c)
		if (0<=a) is in hypothesis
		if (c<=b) is in hypothesis
		then initial goal is proved

  RULE OrderXY.78
	if goal is (0<=a-b+c)
		if (0<=a) is in hypothesis
		if (b<=c) is in hypothesis
		then initial goal is proved

  RULE OrderXY.79
	if goal is (0<=a-b)
		if (b<=a) is in hypothesis
		then initial goal is proved

  RULE OrderXY.80
	if goal is (a<=b)
		if (0<=b-a) is in hypothesis
		then initial goal is proved

  RULE OrderXY.81
	if goal is (0<=succ(n))
		prove (-1<=n)
		then initial goal is proved

  RULE OrderXY.82
	if goal is (0<=pred(n))
		prove (1<=n)
		then initial goal is proved

  RULE OrderXY.83
	if goal is (0<=n/p)
		prove (not(0<=n & (0<= -p => n+1<= -p)) =>
			n<=0
		&	0<=p => 1-n<=p)
		then initial goal is proved

  RULE OrderXY.84
	if goal is (0<=PI(x).(P | E))
		prove (!x.(P => not(E = 0)) => card(SET(x).(P & E<= -1)) mod 2 = 0)
		then initial goal is proved

  RULE OrderXY.85
	if goal is (0<=PI(x).(x: S | E))
		if (S: FIN(T)) is in hypothesis
		if (x) is a variable list whith no free occurences in (S)
		prove (not(0: ran(%x.(x: S | E))) => card(SET(x).(x: S & E<= -1)) mod 2 = 0)
		then initial goal is proved

  RULE OrderXY.86
	if goal is (0<=PI(x).(x: p..q | E))
		prove (!x.(x: p..q => not(E = 0)) => card(SET(x).(x: p..q & E<= -1)) mod 2 = 0)
		then initial goal is proved

  RULE OrderXY.87
	if goal is (0<=SIGMA(x).(P | E))
		if list (P) contains (x: p..q)
		prove (SIGMA(x).(P & 0<= -E | -E)<=SIGMA(x).(P & 0<=E | E))
		then initial goal is proved

  RULE OrderXY.88
	if goal is (0<=SIGMA(x).(P | E))
		if (P) matches on (u & v)
		if list (P) contains (x<=q)
		if list (P) contains (p<=x)
		prove (SIGMA(x).(P & 0<= -E | -E)<=SIGMA(x).(P & 0<=E | E))
		then initial goal is proved

  RULE OrderXY.89
	if goal is (0<=SIGMA(x).(x: p..q | E))
		prove (SIGMA(x).(x: p..q & 0<= -E | -E)<=SIGMA(x).(x: p..q & 0<=E | E))
		then initial goal is proved

  RULE OrderXY.90
	if goal is (0<=max(S))
		prove (not(S/\NATURAL = {}))
		then initial goal is proved

  RULE OrderXY.91
	if goal is (0<=min(S))
		prove (S: POW(NATURAL))
		then initial goal is proved

  RULE OrderXY.92
	if goal is (0<=n**p)
		if tactic (Fast_Prove_Positif) proves (n)
		then initial goal is proved

  RULE OrderXY.93
	if goal is (__blankrule)
		if (2<1) is litteraly true
		then initial goal is proved

  RULE OrderXY.94
	if goal is (0<=n+p)
		if (n: INTEGER) is in hypothesis
		if (0<=n) is in hypothesis
		if (p) is a numerical constant
		then initial goal is proved

  RULE OrderXY.95
	goal (0<=card(S)) is always TRUE

  RULE OrderXY.96
	goal (0<=size(s)) is always TRUE

  RULE OrderXY.97
	goal (0<=card(n..p)) is always TRUE

  RULE OrderXY.98
	if goal is (0<=n)
		if (a<=n) is in hypothesis
		if (a>=0) is litteraly true
		then initial goal is proved

  RULE OrderXY.99
	if goal is (0<=n)
		if (a<=n) is in hypothesis
		if (0<=a) is in hypothesis
		then initial goal is proved

  RULE OrderXY.100
	if goal is (0<=n)
		if (n>=0) is litteraly true
		then initial goal is proved

  RULE OrderXY.101
	if goal is (0<=s(a))
		if (s: seq(T)) is in hypothesis
		if (T: POW(NATURAL)) is in hypothesis
		then initial goal is proved

  RULE OrderXY.102
	if goal is (0<=s(a))
		if (s: S +-> T) is in hypothesis
		if (T: POW(NATURAL)) is in hypothesis
		then initial goal is proved

  RULE OrderXY.103
	goal (0<=a*a) is always TRUE

  RULE OrderXY.104
	if goal is (a rle b)
		if (a rle b) is litteraly true
		then initial goal is proved

  RULE OrderXY.105
	if goal is (a rge b)
		if (a rge b) is litteraly true
		then initial goal is proved

  RULE OrderXY.106
	if goal is (a rlt b)
		if (a rlt b) is litteraly true
		then initial goal is proved

  RULE OrderXY.107
	if goal is (a rgt b)
		if (a rgt b) is litteraly true
		then initial goal is proved


-------------------------------------------------------------------
THEORY DisjonctionTryXY IS

  RULE DisjonctionTryXY.1
	if goal is (a or b)
		if we make a successfull attempt to prove (not(b) => a) with current prover force
		then initial goal is proved

  RULE DisjonctionTryXY.2
	if goal is (a or b)
		if we make a successfull attempt to prove (not(a) => b) with current prover force
		then initial goal is proved

  RULE DisjonctionTryXY.3
	if goal is (not(a) or b)
		if we make a successfull attempt to prove (a => b) with current prover force
		then initial goal is proved

  RULE DisjonctionTryXY.4
	if goal is (a or not(b))
		if we make a successfull attempt to prove (b => a) with current prover force
		then initial goal is proved


-------------------------------------------------------------------
THEORY DisjonctionXY IS

  RULE DisjonctionXY.1
	if goal is (a or b)
		if (a) is in hypothesis
		then initial goal is proved

  RULE DisjonctionXY.2
	if goal is (a or b)
		if (b) is in hypothesis
		then initial goal is proved

  RULE DisjonctionXY.3
	if goal is (a or b)
		if (not(a) => b) is in hypothesis
		then initial goal is proved

  RULE DisjonctionXY.4
	if goal is (a or b)
		if (not(b) => a) is in hypothesis
		then initial goal is proved

  RULE DisjonctionXY.5
	if goal is (not(a) or b)
		if (a => b) is in hypothesis
		then initial goal is proved

  RULE DisjonctionXY.6
	if goal is (a or not(b))
		if (b => a) is in hypothesis
		then initial goal is proved


-------------------------------------------------------------------
THEORY SplitOr IS

  RULE SplitOr.1
	if goal is (a or b)
		prove (not(b) => a)
		then initial goal is proved

  RULE SplitOr.2
	if goal is (a or b)
		prove (not(a) => b)
		then initial goal is proved


-------------------------------------------------------------------
THEORY TryRulesXY IS

  RULE TryRulesXY.1
	if goal is (B)
		if (a = b) is in hypothesis
		if pattern (b) found in (B), replaced by toto becomes R, non free vars ?
		if tactic (SubFrmX) proves (SubFrmG(b,a,B)) and gives result (C)
		if we make a successfull attempt to prove (C) with current prover force
		then initial goal is proved

  RULE TryRulesXY.2
	if goal is (B)
		if (a = b) is in hypothesis
		if pattern (a) found in (B), replaced by toto becomes R, non free vars ?
		if tactic (SubFrmX) proves (SubFrmG(b,a,B)) and gives result (C)
		if we make a successfull attempt to prove (C) with current prover force
		then initial goal is proved

  RULE TryRulesXY.3
	if goal is (B)
		if (!x.(P => Q)) is in hypothesis
		prove (bmatch(x,Q,B,e))
		if tactic (SUB;RES) proves (bresult([x:=e]P)) and gives result (C)
		if we make a successfull attempt to prove ([x:=e]P) with current prover force
		prove (WD(expr(e),Z))
		then initial goal is proved





-------------------------------------------------------------------
FORWARD THEORY GenDirectContradictionX IS

  RULE GenDirectContradictionX.1
	if incoming hypothesis is (1<=size({}))
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.2
	if incoming hypothesis is (2<=card(ran(first(s)->s/|\2)))
		if (not(s = {})) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.3
	if incoming hypothesis is (!x.(x: y => x<=n))
		if (a: y) is in hypothesis
		if (n+1<=a) is in hypothesis
		if (x) is a variable list whith no free occurences in (y,n)
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.4
	if incoming hypothesis is (a/\b = {})
		if (c: a) is in hypothesis
		if (c: b) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.5
	if incoming hypothesis is (c: a)
		if (a/\b = {}) is in hypothesis
		if (c: b) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.6
	if incoming hypothesis is (c: b)
		if (a/\b = {}) is in hypothesis
		if (c: a) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.7
	if incoming hypothesis is (a => not(b))
		if (a => b) is in hypothesis
		if (a) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.8
	if incoming hypothesis is (a => b)
		if (a => not(b)) is in hypothesis
		if (a) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.9
	if incoming hypothesis is (a)
		if (a => not(b)) is in hypothesis
		if (a => b) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.10
	if incoming hypothesis is (not(a))
		if (a) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.11
	if incoming hypothesis is (a)
		if (not(a)) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.12
	if incoming hypothesis is (b+1<=a)
		if (a = b) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.13
	if incoming hypothesis is (a = b)
		if (b+1<=a) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.14
	if incoming hypothesis is (a+1<=b)
		if (b+1<=a) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.15
	if incoming hypothesis is (b+1<=a)
		if (a+1<=b) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.16
	if incoming hypothesis is (a+1<=b)
		if (b<=a) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.17
	if incoming hypothesis is (b<=a)
		if (a+1<=b) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.18
	if incoming hypothesis is (not(b = a))
		if (a = b) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.19
	if incoming hypothesis is (a = b)
		if (not(b = a)) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.20
	if incoming hypothesis is (a+n = n)
		if (1<=a) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.21
	if incoming hypothesis is (1<=a)
		if (a+n = n) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.22
	if incoming hypothesis is (a+n = a)
		if (1<=n) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.23
	if incoming hypothesis is (1<=n)
		if (a+n = a) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.24
	if incoming hypothesis is (a+1<=a)
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.25
	if incoming hypothesis is (a<=a-1)
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.26
	if incoming hypothesis is (m = n+p)
		if (m+1<=p) is in hypothesis
		if (n: INTEGER) is in hypothesis
		if (0<=n) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.27
	if incoming hypothesis is (m+1<=p)
		if (m = n+p) is in hypothesis
		if (n: INTEGER) is in hypothesis
		if (0<=n) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.28
	if incoming hypothesis is (n: INTEGER)
		if (0<=n) is in hypothesis
		if (m+1<=p) is in hypothesis
		if (m = n+p) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.29
	if incoming hypothesis is (m = n+p)
		if (m+1<=p) is in hypothesis
		if (n: a..b) is in hypothesis
		if (0<=a) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.30
	if incoming hypothesis is (m = n+p)
		if (m+1<=p) is in hypothesis
		if (n: a..b) is in hypothesis
		if (a: INTEGER) is in hypothesis
		if (0<=a) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.31
	if incoming hypothesis is (m+1<=p)
		if (m = n+p) is in hypothesis
		if (n: a..b) is in hypothesis
		if (0<=a) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.32
	if incoming hypothesis is (m+1<=p)
		if (m = n+p) is in hypothesis
		if (n: a..b) is in hypothesis
		if (a: INTEGER) is in hypothesis
		if (0<=a) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.33
	if incoming hypothesis is (n: a..b)
		if (m = n+p) is in hypothesis
		if (m+1<=p) is in hypothesis
		if (0<=a) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.34
	if incoming hypothesis is (not(a = a))
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.35
	if incoming hypothesis is (TRUE = FALSE)
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.36
	if incoming hypothesis is (FALSE = TRUE)
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.37
	if incoming hypothesis is (a = FALSE)
		if (a = TRUE) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.38
	if incoming hypothesis is (a = TRUE)
		if (a = FALSE) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.39
	if incoming hypothesis is (not(a: {a}))
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.40
	if incoming hypothesis is (a: ran({}))
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.41
	if incoming hypothesis is (a: dom({}))
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.42
	if incoming hypothesis is (a: {})
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.43
	if incoming hypothesis is ({a} = {})
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.44
	if incoming hypothesis is (a\/{b} = {})
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.45
	if incoming hypothesis is ({b}\/a = {})
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.46
	if incoming hypothesis is (not(e|->r(e): r))
		if (e: dom(r)) is in hypothesis
		if (r: s +-> t) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.47
	if incoming hypothesis is (a = b)
		if (b: s) is in hypothesis
		if (not(a: s)) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.48
	if incoming hypothesis is (a = b)
		if (not(b: s)) is in hypothesis
		if (a: s) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.49
	if incoming hypothesis is (a<=b)
		if (b<a) is litteraly true
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.50
	if incoming hypothesis is (a = b)
		if (c<=a) is in hypothesis
		if (b<c) is litteraly true
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.51
	if incoming hypothesis is (c<=a)
		if (a = b) is in hypothesis
		if (b<c) is litteraly true
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.52
	if incoming hypothesis is (k: f)
		if (f: POW(l)) is in hypothesis
		if (not(k: l)) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.53
	if incoming hypothesis is (not(r(e)|->e: r~))
		if (e: dom(r)) is in hypothesis
		if (r: s +-> t) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenDirectContradictionX.54
	if incoming hypothesis is (not(a: INTEGER))
		then generate derived hypothesis (bfalse)


-------------------------------------------------------------------
FORWARD THEORY GenTryContradictionX IS

  RULE GenTryContradictionX.1
	if incoming hypothesis is (not(c: d[{l}]))
		if (d(l) = c) is in hypothesis
		if (d: s +-> t) is in hypothesis
		then generate derived hypothesis (bfalse)

  RULE GenTryContradictionX.2
	if incoming hypothesis is (n: a)
		if (not(n: b)) is in hypothesis
		if we make a successfull attempt to prove (a: POW(b)) with current prover force
		then generate derived hypothesis (bfalse)


-------------------------------------------------------------------
FORWARD THEORY GenEqualityX IS

  RULE GenEqualityX.1
	if incoming hypothesis is (a<=b)
		if (b<=a) is in hypothesis
		then generate derived hypothesis (a = b)

  RULE GenEqualityX.2
	if incoming hypothesis is (a-n = b)
		if (n<=a) is in hypothesis
		then generate derived hypothesis (a = b+n)

  RULE GenEqualityX.3
	if incoming hypothesis is (n<=a)
		if (a-n = b) is in hypothesis
		then generate derived hypothesis (a = b+n)

  RULE GenEqualityX.4
	if incoming hypothesis is (x: dom({a|->b}))
		then generate derived hypothesis (x = a)

  RULE GenEqualityX.5
	if incoming hypothesis is (a: POW(b))
		if (b: POW(a)) is in hypothesis
		then generate derived hypothesis (a = b)

  RULE GenEqualityX.6
	if incoming hypothesis is (b/\c = {})
		if (a: POW(b)) is in hypothesis
		then generate derived hypothesis (a/\c = {})

  RULE GenEqualityX.7
	if incoming hypothesis is (a: POW(b))
		if (b/\c = {}) is in hypothesis
		then generate derived hypothesis (a/\c = {})

  RULE GenEqualityX.8
	if incoming hypothesis is (b/\c = {})
		if (a: POW(c)) is in hypothesis
		then generate derived hypothesis (a/\b = {})

  RULE GenEqualityX.9
	if incoming hypothesis is (a: POW(c))
		if (b/\c = {}) is in hypothesis
		then generate derived hypothesis (a/\b = {})

  RULE GenEqualityX.10
	if incoming hypothesis is (a/\b = {})
		if (a: POW(b)) is in hypothesis
		then generate derived hypothesis (a = {})

  RULE GenEqualityX.11
	if incoming hypothesis is (a: POW(b))
		if (a/\b = {}) is in hypothesis
		then generate derived hypothesis (a = {})

  RULE GenEqualityX.12
	if incoming hypothesis is (a/\b = c)
		then generate derived hypothesis (b/\a = c)

  RULE GenEqualityX.13
	if incoming hypothesis is (a\/b = c)
		then generate derived hypothesis (b\/a = c)

  RULE GenEqualityX.14
	if incoming hypothesis is (dom(f) = {})
		then generate derived hypothesis (f = {})

  RULE GenEqualityX.15
	if incoming hypothesis is (ran(f) = {})
		then generate derived hypothesis (f = {})

  RULE GenEqualityX.16
	if incoming hypothesis is (not(a: {b|->c}[{b}]))
		then generate derived hypothesis (not(a = c) & not(c = a))

  RULE GenEqualityX.17
	if incoming hypothesis is (not(a = TRUE))
		then generate derived hypothesis (a = FALSE)

  RULE GenEqualityX.18
	if incoming hypothesis is (not(a = FALSE))
		then generate derived hypothesis (a = TRUE)

  RULE GenEqualityX.19
	if incoming hypothesis is (a|->b = c|->d)
		then generate derived hypothesis (a = c & b = d)


-------------------------------------------------------------------
FORWARD THEORY GenFromRelationX IS

  RULE GenFromRelationX.1
	if incoming hypothesis is (f: s +-> t)
		then generate derived hypothesis (f: s <-> t)

  RULE GenFromRelationX.2
	if incoming hypothesis is (r: s <-> t)
		then generate derived hypothesis (dom(r): POW(s) & ran(r): POW(t))

  RULE GenFromRelationX.3
	if incoming hypothesis is (r~: s <-> t)
		then generate derived hypothesis (r: t <-> s)

  RULE GenFromRelationX.4
	if incoming hypothesis is (s: seq(a))
		then generate derived hypothesis (s: 1..size(s) +-> a
		 & dom(s) = 1..size(s)
		 & size(s): INTEGER
		 & 0<=size(s))


-------------------------------------------------------------------
FORWARD THEORY GenAllInPOWX IS

  RULE GenAllInPOWX.1
	if incoming hypothesis is (a: POW(c))
		if (a = b) is in hypothesis
		not if (b) matches on (c)
		then generate derived hypothesis (b: POW(c))

  RULE GenAllInPOWX.2
	if incoming hypothesis is (a = b)
		if (a: POW(c)) is in hypothesis
		not if (b) matches on (c)
		then generate derived hypothesis (b: POW(c))

  RULE GenAllInPOWX.3
	if incoming hypothesis is (a: POW(c))
		if (b = a) is in hypothesis
		not if (b) matches on (c)
		then generate derived hypothesis (b: POW(c))

  RULE GenAllInPOWX.4
	if incoming hypothesis is (b = a)
		if (a: POW(c)) is in hypothesis
		not if (b) matches on (c)
		then generate derived hypothesis (b: POW(c))


-------------------------------------------------------------------
FORWARD THEORY GenInPOWX IS

  RULE GenInPOWX.1
	if incoming hypothesis is (a: POW(b))
		if (b: POW(c)) is in hypothesis
		then generate derived hypothesis (a: POW(c))

  RULE GenInPOWX.2
	if incoming hypothesis is (b: POW(c))
		if (a: POW(b)) is in hypothesis
		then generate derived hypothesis (a: POW(c))

  RULE GenInPOWX.3
	if incoming hypothesis is (a\/b: POW(c))
		then generate derived hypothesis (a: POW(c) & b: POW(c))

  RULE GenInPOWX.4
	if incoming hypothesis is (c/\a = {})
		if (a: POW(b\/c)) is in hypothesis
		then generate derived hypothesis (a: POW(b))

  RULE GenInPOWX.5
	if incoming hypothesis is (a: POW(b\/c))
		if (c/\a = {}) is in hypothesis
		then generate derived hypothesis (a: POW(b))

  RULE GenInPOWX.6
	if incoming hypothesis is (b/\a = {})
		if (a: POW(b\/c)) is in hypothesis
		then generate derived hypothesis (a: POW(c))

  RULE GenInPOWX.7
	if incoming hypothesis is (a: POW(b\/c))
		if (b/\a = {}) is in hypothesis
		then generate derived hypothesis (a: POW(c))

  RULE GenInPOWX.8
	if incoming hypothesis is (a/\c = {})
		if (a: POW(b\/c)) is in hypothesis
		then generate derived hypothesis (a: POW(b))

  RULE GenInPOWX.9
	if incoming hypothesis is (a: POW(b\/c))
		if (a/\c = {}) is in hypothesis
		then generate derived hypothesis (a: POW(b))

  RULE GenInPOWX.10
	if incoming hypothesis is (a/\b = {})
		if (a: POW(b\/c)) is in hypothesis
		then generate derived hypothesis (a: POW(c))

  RULE GenInPOWX.11
	if incoming hypothesis is (a: POW(a/\b))
		then generate derived hypothesis (a: POW(b))

  RULE GenInPOWX.12
	if incoming hypothesis is (a: POW(b/\a))
		then generate derived hypothesis (a: POW(b))

  RULE GenInPOWX.13
	if incoming hypothesis is (r: a <-> b)
		if (r: POW(s)) is in hypothesis
		then generate derived hypothesis (dom(r): POW(dom(s)))

  RULE GenInPOWX.14
	if incoming hypothesis is (r: POW(s))
		if (r: a <-> b) is in hypothesis
		then generate derived hypothesis (dom(r): POW(dom(s)))

  RULE GenInPOWX.15
	if incoming hypothesis is (r: a <-> b)
		if (r: POW(s)) is in hypothesis
		then generate derived hypothesis (ran(r): POW(ran(s)))

  RULE GenInPOWX.16
	if incoming hypothesis is (r: POW(s))
		if (r: a <-> b) is in hypothesis
		then generate derived hypothesis (ran(r): POW(ran(s)))

  RULE GenInPOWX.17
	if incoming hypothesis is (a: POW(dom(r~)))
		then generate derived hypothesis (a: POW(ran(r)))

  RULE GenInPOWX.18
	if incoming hypothesis is (a: POW(ran(r~)))
		then generate derived hypothesis (a: POW(dom(r)))

  RULE GenInPOWX.19
	if incoming hypothesis is (a: POW(f[u]))
		then generate derived hypothesis (a: POW(ran(f)))

  RULE GenInPOWX.20
	if incoming hypothesis is (a: POW(f~[u]))
		then generate derived hypothesis (a: POW(dom(f)))

  RULE GenInPOWX.21
	if incoming hypothesis is (a: POW(SET(x).(x: b)))
		if (x) is a variable list whith no free occurences in (b)
		then generate derived hypothesis (a: POW(b))

  RULE GenInPOWX.22
	if incoming hypothesis is (p: POW(SET(x).(x: f~[b])))
		if (x) is a variable list whith no free occurences in (f,b)
		then generate derived hypothesis (p: POW(dom(f)))

  RULE GenInPOWX.23
	if incoming hypothesis is (r[u\/v]: POW(w))
		then generate derived hypothesis (r[u]: POW(w) & r[v]: POW(w))

  RULE GenInPOWX.24
	if incoming hypothesis is (u\/v = w)
		then generate derived hypothesis (u: POW(w) & v: POW(w))

  RULE GenInPOWX.25
	if incoming hypothesis is (a: POW(b/\c))
		then generate derived hypothesis (a: POW(b) & a: POW(c))

  RULE GenInPOWX.26
	if incoming hypothesis is (a: POW(dom(b)))
		not if (b) found in (a) and give (Q) when replaced by (btrue)
		then generate derived hypothesis (dom(a<|b) = a)


-------------------------------------------------------------------
FORWARD THEORY GenAllInSetX IS

  RULE GenAllInSetX.1
	if incoming hypothesis is (a: dom(f))
		if (f: A +-> B) is in hypothesis
		not if (dom(f) = B) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(f(a): B))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenAllInSetX.2
	if incoming hypothesis is (f: A +-> B)
		if (a: dom(f)) is in hypothesis
		not if (dom(f) = B) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(f(a): B))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenAllInSetX.3
	if incoming hypothesis is (a: b)
		not if (b) matches on ((1..j)*{E})
		if (b: POW(c)) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: c))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenAllInSetX.4
	if incoming hypothesis is (b: POW(c))
		if (a: b) is in hypothesis
		not if (b) matches on ((1..j)*{E})
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: c))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenAllInSetX.5
	if incoming hypothesis is (f: s +-> t)
		if (s: FIN(a)) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(f: FIN(s*t)))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenAllInSetX.6
	if incoming hypothesis is (s: FIN(a))
		if (f: s +-> t) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(f: FIN(s*t)))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenAllInSetX.7
	if incoming hypothesis is (f: s <-> t)
		if (s: FIN(a)) is in hypothesis
		if (t: FIN(b)) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(f: FIN(s*t)))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenAllInSetX.8
	if incoming hypothesis is (s: FIN(a))
		if (f: s <-> t) is in hypothesis
		if (t: FIN(b)) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(f: FIN(s*t)))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenAllInSetX.9
	if incoming hypothesis is (t: FIN(b))
		if (s: FIN(a)) is in hypothesis
		if (f: s <-> t) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(f: FIN(s*t)))) and gives result (O)
		then generate derived hypothesis (O)


-------------------------------------------------------------------
FORWARD THEORY GenInSetX IS

  RULE GenInSetX.1
	if incoming hypothesis is (s: seq(a)-{{}})
		then generate derived hypothesis (s: seq(a) & not(s = {}))

  RULE GenInSetX.2
	if incoming hypothesis is (s: iseq(a)-{{}})
		then generate derived hypothesis (s: seq(a)
		 & s~: a +-> NATURAL-{0}
		 & not(s = {}))

  RULE GenInSetX.3
	if incoming hypothesis is (s: iseq(a))
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(s: seq(a) & s~: a +-> NATURAL-{0}))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.4
	if incoming hypothesis is (a: FIN(b)-{{}})
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: FIN(b) & not(a = {}) & card(a): INTEGER & 0<=card(a) & 1<=card(a)))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.5
	if incoming hypothesis is (a: POW(b)-{{}})
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: POW(b) & not(a = {})))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.6
	if incoming hypothesis is (btest(2<1))
		then generate derived hypothesis (__blankrule)

  RULE GenInSetX.7
	if incoming hypothesis is (not(f(x) = a))
		if (f: s +-> {a}\/{b}) is in hypothesis
		if (f~[{b}] = t) is in hypothesis
		if (x: dom(f)) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(x: t))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.8
	if incoming hypothesis is (f: s +-> {a}\/{b})
		if (not(f(x) = a)) is in hypothesis
		if (f~[{b}] = t) is in hypothesis
		if (x: dom(f)) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(x: t))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.9
	if incoming hypothesis is (f~[{b}] = t)
		if (f: s +-> {a}\/{b}) is in hypothesis
		if (not(f(x) = a)) is in hypothesis
		if (x: dom(f)) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(x: t))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.10
	if incoming hypothesis is (not(f(x) = b))
		if (f: s +-> a\/{b}) is in hypothesis
		if (f~[a] = t) is in hypothesis
		if (x: dom(f)) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(x: t))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.11
	if incoming hypothesis is (f: s +-> a\/{b})
		if (not(f(x) = b)) is in hypothesis
		if (f~[a] = t) is in hypothesis
		if (x: dom(f)) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(x: t))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.12
	if incoming hypothesis is (f~[a] = t)
		if (f: s +-> a\/{b}) is in hypothesis
		if (not(f(x) = b)) is in hypothesis
		if (x: dom(f)) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(x: t))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.13
	if incoming hypothesis is (x<=b)
		if (a<=x) is in hypothesis
		if (dom(f) = a..b) is in hypothesis
		then generate derived hypothesis (x: dom(f))

  RULE GenInSetX.14
	if incoming hypothesis is (a<=x)
		if (x<=b) is in hypothesis
		if (dom(f) = a..b) is in hypothesis
		then generate derived hypothesis (x: dom(f))

  RULE GenInSetX.15
	if incoming hypothesis is (dom(f) = a..b)
		if (a<=x) is in hypothesis
		if (x<=b) is in hypothesis
		then generate derived hypothesis (x: dom(f))

  RULE GenInSetX.16
	if incoming hypothesis is (1<=size(s))
		if (s: seq(a)) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(first(s): a & last(s): a))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.17
	if incoming hypothesis is (s: seq(a))
		if (1<=size(s)) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(first(s): a & last(s): a))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.18
	if incoming hypothesis is (n: dom(s))
		if (s: seq(a)) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(n: INTEGER & 0<=n & s(n): a & 1<=n & n<=size(s)))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.19
	if incoming hypothesis is (s: seq(a))
		if (n: dom(s)) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(n: INTEGER & 0<=n & s(n): a & 1<=n & n<=size(s)))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.20
	if incoming hypothesis is (a: dom(r))
		if (r: s <-> t) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: s))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.21
	if incoming hypothesis is (r: s <-> t)
		if (a: dom(r)) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: s))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.22
	if incoming hypothesis is (a: ran(r))
		if (r: s <-> t) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: t))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.23
	if incoming hypothesis is (r: s <-> t)
		if (a: ran(r)) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: t))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.24
	if incoming hypothesis is (a: dom(r))
		if (r: s +-> t) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: s))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.25
	if incoming hypothesis is (r: s +-> t)
		if (a: dom(r)) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: s))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.26
	if incoming hypothesis is (a: ran(r))
		if (r~: t +-> s) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: t))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.27
	if incoming hypothesis is (r~: t +-> s)
		if (a: ran(r)) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: t))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.28
	if incoming hypothesis is (a: f[b])
		if (f: s <-> t) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: t & a: ran(f)))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.29
	if incoming hypothesis is (f: s <-> t)
		if (a: f[b]) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: t & a: ran(f)))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.30
	if incoming hypothesis is (a: f~[b])
		if (f: s <-> t) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: s & a: dom(f)))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.31
	if incoming hypothesis is (f: s <-> t)
		if (a: f~[b]) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: s & a: dom(f)))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.32
	if incoming hypothesis is (not(a = c))
		if (a: b\/{c}) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: b))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.33
	if incoming hypothesis is (a: b\/{c})
		if (not(a = c)) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: b))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.34
	if incoming hypothesis is (a: b\/c)
		if (not(a: c)) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: b))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.35
	if incoming hypothesis is (not(a: c))
		if (a: b\/c) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: b))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.36
	if incoming hypothesis is (a: b\/c)
		if (not(a: b)) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: c))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.37
	if incoming hypothesis is (not(a: b))
		if (a: b\/c) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: c))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.38
	if incoming hypothesis is (a: b)
		if (b: POW(c)) is in hypothesis
		not if (c) matches on (INTEGER)
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: c))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.39
	if incoming hypothesis is (b: POW(c))
		if (a: b) is in hypothesis
		not if (c) matches on (INTEGER)
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: c))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.40
	if incoming hypothesis is (a: b)
		if (c = b) is in hypothesis
		not if (b) matches on ((1..j)*{E})
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: c))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.41
	if incoming hypothesis is (c = b)
		if (a: b) is in hypothesis
		not if (b) matches on ((1..j)*{E})
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: c))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.42
	if incoming hypothesis is (a: b)
		if (b = c) is in hypothesis
		not if (b) matches on ((1..j)*{E})
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: c))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.43
	if incoming hypothesis is (b = c)
		if (a: b) is in hypothesis
		not if (b) matches on ((1..j)*{E})
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: c))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.44
	if incoming hypothesis is (n: r..s)
		if (r+1<=s) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(n: INTEGER & r<=n & n<=s))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.45
	if incoming hypothesis is (r+1<=s)
		if (n: r..s) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(n: INTEGER & r<=n & n<=s))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.46
	if incoming hypothesis is (a: dom(b<<|f))
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: dom(f) & not(a: b)))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.47
	if incoming hypothesis is (a: dom(b<|f))
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: dom(f) & a: b))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.48
	if incoming hypothesis is (a: ran(f|>>b))
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: ran(f) & not(a: b)))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.49
	if incoming hypothesis is (a: ran(f|>b))
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: ran(f) & a: b))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.50
	if incoming hypothesis is (a: FIN(b))
		then generate derived hypothesis (a: POW(b))

  RULE GenInSetX.51
	if incoming hypothesis is (a<=b)
		if (c: a..b) is in hypothesis
		if (a: INTEGER) is in hypothesis
		if (0<=a) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(c: INTEGER & 0<=c))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.52
	if incoming hypothesis is (c: a..b)
		if (a<=b) is in hypothesis
		if (a: INTEGER) is in hypothesis
		if (0<=a) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(c: INTEGER & 0<=c))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.53
	if incoming hypothesis is (a: INTEGER)
		if (0<=a) is in hypothesis
		if (c: a..b) is in hypothesis
		if (a<=b) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(c: INTEGER & 0<=c))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.54
	if incoming hypothesis is (a<=b)
		if (c: a..b) is in hypothesis
		if (a) is a numerical constant
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(c: INTEGER & 0<=c))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.55
	if incoming hypothesis is (c: a..b)
		if (a<=b) is in hypothesis
		if (a) is a numerical constant
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(c: INTEGER & 0<=c))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.56
	if incoming hypothesis is (a<=b)
		if (c: a..b) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(c: INTEGER))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.57
	if incoming hypothesis is (c: a..b)
		if (a<=b) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(c: INTEGER))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.58
	if incoming hypothesis is (i|->E: b\/{j|->E})
		if (i/=j) is litteraly true
		if (i) is a numerical constant
		if (j) is a numerical constant
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(i|->E: b))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenInSetX.59
	if incoming hypothesis is (a: b-c)
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(a: b & not(a: c)))) and gives result (O)
		then generate derived hypothesis (O)


-------------------------------------------------------------------
FORWARD THEORY GenAllNotEqualX IS

  RULE GenAllNotEqualX.1
	if incoming hypothesis is (not(a = b))
		then generate derived hypothesis (not(b = a))


-------------------------------------------------------------------
FORWARD THEORY GenNotEqualX IS

  RULE GenNotEqualX.1
	if incoming hypothesis is (not(a = b))
		if (a = c) is in hypothesis
		then generate derived hypothesis (not(b = c))

  RULE GenNotEqualX.2
	if incoming hypothesis is (a = c)
		if (not(a = b)) is in hypothesis
		then generate derived hypothesis (not(b = c))

  RULE GenNotEqualX.3
	if incoming hypothesis is (1<=size(s))
		if (s: seq(e)) is in hypothesis
		then generate derived hypothesis (not(s = {}))

  RULE GenNotEqualX.4
	if incoming hypothesis is (s: seq(e))
		if (1<=size(s)) is in hypothesis
		then generate derived hypothesis (not(s = {}))

  RULE GenNotEqualX.5
	if incoming hypothesis is (a: b)
		if (not(c: b)) is in hypothesis
		then generate derived hypothesis (not(a = c))

  RULE GenNotEqualX.6
	if incoming hypothesis is (not(c: b))
		if (a: b) is in hypothesis
		then generate derived hypothesis (not(a = c))

  RULE GenNotEqualX.7
	if incoming hypothesis is (not(card(a) = 0))
		if (a: FIN(b)) is in hypothesis
		then generate derived hypothesis (not(a = {}))

  RULE GenNotEqualX.8
	if incoming hypothesis is (a: FIN(b))
		if (not(card(a) = 0)) is in hypothesis
		then generate derived hypothesis (not(a = {}))

  RULE GenNotEqualX.9
	if incoming hypothesis is (not(1<=card(a)))
		if (a: FIN(b)) is in hypothesis
		then generate derived hypothesis (a = {})

  RULE GenNotEqualX.10
	if incoming hypothesis is (a: FIN(b))
		if (not(1<=card(a))) is in hypothesis
		then generate derived hypothesis (a = {})

  RULE GenNotEqualX.11
	if incoming hypothesis is (not(b: a))
		if (not(b..c/\a = {})) is in hypothesis
		then generate derived hypothesis (not(b+1..c/\a = {}))

  RULE GenNotEqualX.12
	if incoming hypothesis is (not(b..c/\a = {}))
		if (not(b: a)) is in hypothesis
		then generate derived hypothesis (not(b+1..c/\a = {}))

  RULE GenNotEqualX.13
	if incoming hypothesis is (not(c: a))
		if (not(b..c/\a = {})) is in hypothesis
		then generate derived hypothesis (not(b..c-1/\a = {}))

  RULE GenNotEqualX.14
	if incoming hypothesis is (not(b..c/\a = {}))
		if (not(c: a)) is in hypothesis
		then generate derived hypothesis (not(b..c-1/\a = {}))

  RULE GenNotEqualX.15
	if incoming hypothesis is (not(a/\b = {}))
		then generate derived hypothesis (not(a = {}) & not(b = {}))

  RULE GenNotEqualX.16
	if incoming hypothesis is (3<=size(a->s))
		then generate derived hypothesis (not(s = {}))

  RULE GenNotEqualX.17
	if incoming hypothesis is (2<=size(a->s))
		then generate derived hypothesis (not(s = {}))

  RULE GenNotEqualX.18
	if incoming hypothesis is (not(first(a->s) = b))
		then generate derived hypothesis (not(a = b))

  RULE GenNotEqualX.19
	if incoming hypothesis is (a+1<=b)
		then generate derived hypothesis (not(a = b))

  RULE GenNotEqualX.20
	if incoming hypothesis is (not(a-b = {}))
		then generate derived hypothesis (not(a = {}) & not(a = b))


-------------------------------------------------------------------
FORWARD THEORY GenNotInSetX IS

  RULE GenNotInSetX.1
	if incoming hypothesis is (not(a = c))
		if (not(a: b-{c})) is in hypothesis
		then generate derived hypothesis (not(a: b))

  RULE GenNotInSetX.2
	if incoming hypothesis is (not(a: b-{c}))
		if (not(a = c)) is in hypothesis
		then generate derived hypothesis (not(a: b))

  RULE GenNotInSetX.3
	if incoming hypothesis is (not(a: b))
		if (b = c) is in hypothesis
		then generate derived hypothesis (not(a: c))

  RULE GenNotInSetX.4
	if incoming hypothesis is (b = c)
		if (not(a: b)) is in hypothesis
		then generate derived hypothesis (not(a: c))

  RULE GenNotInSetX.5
	if incoming hypothesis is (not(a: b))
		if (c = b) is in hypothesis
		then generate derived hypothesis (not(a: c))

  RULE GenNotInSetX.6
	if incoming hypothesis is (c = b)
		if (not(a: b)) is in hypothesis
		then generate derived hypothesis (not(a: c))

  RULE GenNotInSetX.7
	if incoming hypothesis is (c: b)
		if (a/\b = {}) is in hypothesis
		then generate derived hypothesis (not(c: a))

  RULE GenNotInSetX.8
	if incoming hypothesis is (a/\b = {})
		if (c: b) is in hypothesis
		then generate derived hypothesis (not(c: a))

  RULE GenNotInSetX.9
	if incoming hypothesis is (c: a)
		if (a/\b = {}) is in hypothesis
		then generate derived hypothesis (not(c: b))

  RULE GenNotInSetX.10
	if incoming hypothesis is (a/\b = {})
		if (c: a) is in hypothesis
		then generate derived hypothesis (not(c: b))

  RULE GenNotInSetX.11
	if incoming hypothesis is (b: POW(c))
		if (not(a: c)) is in hypothesis
		then generate derived hypothesis (not(a: b))

  RULE GenNotInSetX.12
	if incoming hypothesis is (not(a: c))
		if (b: POW(c)) is in hypothesis
		then generate derived hypothesis (not(a: b))

  RULE GenNotInSetX.13
	if incoming hypothesis is (a<=b)
		if (a..b/\c = {}) is in hypothesis
		then generate derived hypothesis (not(b: c))

  RULE GenNotInSetX.14
	if incoming hypothesis is (a..b/\c = {})
		if (a<=b) is in hypothesis
		then generate derived hypothesis (not(b: c))

  RULE GenNotInSetX.15
	if incoming hypothesis is (a<=b)
		if (a..b/\c = {}) is in hypothesis
		then generate derived hypothesis (not(a: c))

  RULE GenNotInSetX.16
	if incoming hypothesis is (a..b/\c = {})
		if (a<=b) is in hypothesis
		then generate derived hypothesis (not(a: c))

  RULE GenNotInSetX.17
	if incoming hypothesis is (not(a: b\/c))
		then generate derived hypothesis (not(a: b) & not(a: c))

  RULE GenNotInSetX.18
	if incoming hypothesis is (not(f(a) = b))
		then generate derived hypothesis (not(a: f~[{b}]))


-------------------------------------------------------------------
FORWARD THEORY GenAllOrderX IS

  RULE GenAllOrderX.1
	if incoming hypothesis is (a: FIN(b))
		then generate derived hypothesis (0<=card(a))

  RULE GenAllOrderX.2
	if incoming hypothesis is (a: FIN(b))
		if (not(a = {})) is in hypothesis
		then generate derived hypothesis (1<=card(a))

  RULE GenAllOrderX.3
	if incoming hypothesis is (not(a = {}))
		if (a: FIN(b)) is in hypothesis
		then generate derived hypothesis (1<=card(a))


-------------------------------------------------------------------
FORWARD THEORY GenOrderX IS

  RULE GenOrderX.1
	if incoming hypothesis is (s: seq(a))
		if (n: dom(s)) is in hypothesis
		then generate derived hypothesis (1<=n & n<=size(s))

  RULE GenOrderX.2
	if incoming hypothesis is (n: dom(s))
		if (s: seq(a)) is in hypothesis
		then generate derived hypothesis (1<=n & n<=size(s))

  RULE GenOrderX.3
	if incoming hypothesis is (s: seq(a))
		if (not(s = {})) is in hypothesis
		then generate derived hypothesis (1<=size(s))

  RULE GenOrderX.4
	if incoming hypothesis is (not(s = {}))
		if (s: seq(a)) is in hypothesis
		then generate derived hypothesis (1<=size(s))

  RULE GenOrderX.5
	if incoming hypothesis is (s: seq(a))
		if (1<=b) is in hypothesis
		if (b<=size(s)) is in hypothesis
		then generate derived hypothesis (s(b): a)

  RULE GenOrderX.6
	if incoming hypothesis is (b<=size(s))
		if (1<=b) is in hypothesis
		if (s: seq(a)) is in hypothesis
		then generate derived hypothesis (s(b): a)

  RULE GenOrderX.7
	if incoming hypothesis is (1<=b)
		if (b<=size(s)) is in hypothesis
		if (s: seq(a)) is in hypothesis
		then generate derived hypothesis (s(b): a)

  RULE GenOrderX.8
	if incoming hypothesis is (2<=size(tail(s)))
		then generate derived hypothesis (3<=size(s))

  RULE GenOrderX.9
	if incoming hypothesis is (a<=b)
		if (b<=c) is in hypothesis
		not if (band(bnum(a),bnum(c))) is in hypothesis
		then generate derived hypothesis (a<=c)

  RULE GenOrderX.10
	if incoming hypothesis is (b<=c)
		if (a<=b) is in hypothesis
		not if (band(bnum(a),bnum(c))) is in hypothesis
		then generate derived hypothesis (a<=c)

  RULE GenOrderX.11
	if incoming hypothesis is (a<=b)
		if (b+1<=c) is in hypothesis
		if (b/=c) is litteraly true
		then generate derived hypothesis (a+1<=c)

  RULE GenOrderX.12
	if incoming hypothesis is (b+1<=c)
		if (b/=c) is litteraly true
		if (a<=b) is in hypothesis
		then generate derived hypothesis (a+1<=c)

  RULE GenOrderX.13
	if incoming hypothesis is (a<=b)
		if (c+1<=a) is in hypothesis
		then generate derived hypothesis (c+1<=b)

  RULE GenOrderX.14
	if incoming hypothesis is (c+1<=a)
		if (a<=b) is in hypothesis
		then generate derived hypothesis (c+1<=b)

  RULE GenOrderX.15
	if incoming hypothesis is (a+1<=b)
		if (b+1<=c) is in hypothesis
		then generate derived hypothesis (a+1<=c)

  RULE GenOrderX.16
	if incoming hypothesis is (b+1<=c)
		if (a+1<=b) is in hypothesis
		then generate derived hypothesis (a+1<=c)

  RULE GenOrderX.17
	if incoming hypothesis is (not(n = 0))
		if (n: INTEGER) is in hypothesis
		if (0<=n) is in hypothesis
		then generate derived hypothesis (1<=n)

  RULE GenOrderX.18
	if incoming hypothesis is (n: INTEGER)
		if (0<=n) is in hypothesis
		if (not(n = 0)) is in hypothesis
		then generate derived hypothesis (1<=n)

  RULE GenOrderX.19
	if incoming hypothesis is (not(a = {}))
		if (a: POW(x..y)) is in hypothesis
		then generate derived hypothesis (x<=min(a))

  RULE GenOrderX.20
	if incoming hypothesis is (a: POW(x..y))
		if (not(a = {})) is in hypothesis
		then generate derived hypothesis (x<=min(a))

  RULE GenOrderX.21
	if incoming hypothesis is (not(a = {}))
		if (a: POW(x..y)) is in hypothesis
		then generate derived hypothesis (max(a)<=y)

  RULE GenOrderX.22
	if incoming hypothesis is (a: POW(x..y))
		if (not(a = {})) is in hypothesis
		then generate derived hypothesis (max(a)<=y)

  RULE GenOrderX.23
	if incoming hypothesis is (a<=min(b))
		if (b: FIN(s)) is in hypothesis
		if (not(b = {})) is in hypothesis
		then generate derived hypothesis (a<=max(b))

  RULE GenOrderX.24
	if incoming hypothesis is (a+1<=b)
		then generate derived hypothesis (a<=b)

  RULE GenOrderX.25
	if incoming hypothesis is (btest(2<1))
		then generate derived hypothesis (__blankrule)

  RULE GenOrderX.26
	if incoming hypothesis is (a: INTEGER)
		if (0<=a) is in hypothesis
		if (not(a = 0)) is in hypothesis
		then generate derived hypothesis (1<=a)

  RULE GenOrderX.27
	if incoming hypothesis is (not(a..b = {}))
		then generate derived hypothesis (a<=b)

  RULE GenOrderX.28
	if incoming hypothesis is (n+p+1<=m+p)
		then generate derived hypothesis (n+1<=m)

  RULE GenOrderX.29
	if incoming hypothesis is (a-b+1<=c)
		if (b<=a) is in hypothesis
		then generate derived hypothesis (a+1<=c+b)

  RULE GenOrderX.30
	if incoming hypothesis is (a+1<=b-c)
		if (c<=b) is in hypothesis
		then generate derived hypothesis (a+c+1<=b)

  RULE GenOrderX.31
	if incoming hypothesis is (a+b<=c)
		if (a: INTEGER) is in hypothesis
		if (0<=a) is in hypothesis
		if (b: INTEGER) is in hypothesis
		if (0<=b) is in hypothesis
		then generate derived hypothesis (a<=c & b<=c)

  RULE GenOrderX.32
	if incoming hypothesis is (a: INTEGER)
		if (0<=a) is in hypothesis
		if (a+b<=c) is in hypothesis
		if (b: INTEGER) is in hypothesis
		if (0<=b) is in hypothesis
		then generate derived hypothesis (a<=c & b<=c)

  RULE GenOrderX.33
	if incoming hypothesis is (b: INTEGER)
		if (0<=b) is in hypothesis
		if (a+b<=c) is in hypothesis
		if (a: INTEGER) is in hypothesis
		if (0<=a) is in hypothesis
		then generate derived hypothesis (a<=c & b<=c)


-------------------------------------------------------------------
FORWARD THEORY GenObvPredicateX IS

  RULE GenObvPredicateX.1
	if incoming hypothesis is (a)
		if (a => b) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(b))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenObvPredicateX.2
	if incoming hypothesis is (a => b)
		if (a) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(b))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenObvPredicateX.3
	if incoming hypothesis is (a = a => b)
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(b))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenObvPredicateX.4
	if incoming hypothesis is (a = b)
		if (b = a => p) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(p))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenObvPredicateX.5
	if incoming hypothesis is (b = a => p)
		if (a = b) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(p))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenObvPredicateX.6
	if incoming hypothesis is (not(a = b))
		if (not(b = a) => p) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(p))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenObvPredicateX.7
	if incoming hypothesis is (not(b = a) => p)
		if (not(a = b)) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(p))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenObvPredicateX.8
	if incoming hypothesis is (not(b))
		if (a => b) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(not(a)))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenObvPredicateX.9
	if incoming hypothesis is (a => b)
		if (not(b)) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(not(a)))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenObvPredicateX.10
	if incoming hypothesis is (not(b))
		if (a => X & x) is in hypothesis
		if list (X & x) contains (b)
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(not(a)))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenObvPredicateX.11
	if incoming hypothesis is (a => X & x)
		if (not(b)) is in hypothesis
		if list (X & x) contains (b)
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(not(a)))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenObvPredicateX.12
	if incoming hypothesis is (!x.(a => b))
		if (c) is in hypothesis
		if (bmatch(x,a,c,e)) is in hypothesis
		if tactic (SUB;RES) proves (bresult([x:=e]b)) and gives result (B)
		not if (band(bsubfrm(P,btrue,B,Q),bmatch(x,a,P,E))) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(B))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenObvPredicateX.13
	if incoming hypothesis is (c)
		if (!x.(a => b)) is in hypothesis
		if (bmatch(x,a,c,e)) is in hypothesis
		if tactic (SUB;RES) proves (bresult([x:=e]b)) and gives result (B)
		not if (band(bsubfrm(P,btrue,B,Q),bmatch(x,a,P,E))) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(B))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenObvPredicateX.14
	if incoming hypothesis is (!x.(a => b))
		if (not(c)) is in hypothesis
		if (bmatch(x,b,c,e)) is in hypothesis
		if tactic (SUB;RES) proves (bresult([x:=e]not(a))) and gives result (not(A))
		not if (band(bsubfrm(P,btrue,A,Q),bmatch(x,b,P,E))) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(not(A)))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenObvPredicateX.15
	if incoming hypothesis is (not(c))
		if (!x.(a => b)) is in hypothesis
		if (bmatch(x,b,c,e)) is in hypothesis
		if tactic (SUB;RES) proves (bresult([x:=e]not(a))) and gives result (not(A))
		not if (band(bsubfrm(P,btrue,A,Q),bmatch(x,b,P,E))) is in hypothesis
		if tactic (SimplifyX~;FLAT;RES) proves (bresult(bflat(not(A)))) and gives result (O)
		then generate derived hypothesis (O)

  RULE GenObvPredicateX.16
	if incoming hypothesis is (not(a+1<=b))
		then generate derived hypothesis (b<=a)

  RULE GenObvPredicateX.17
	if incoming hypothesis is (not(a<=b))
		then generate derived hypothesis (b+1<=a)

  RULE GenObvPredicateX.18
	if incoming hypothesis is (not(a: {x}))
		then generate derived hypothesis (not(a = x))

  RULE GenObvPredicateX.19
	if incoming hypothesis is (not(a: SET(x).P))
		if tactic (SUB;RES) proves (bresult([x:=a]not(P))) and gives result (R)
		not if (R) matches on ([y:=z]S)
		then generate derived hypothesis (R)

  RULE GenObvPredicateX.20
	if incoming hypothesis is (not(a: x\/{y}))
		then generate derived hypothesis (not(a: x) & not(a: {y}))

  RULE GenObvPredicateX.21
	if incoming hypothesis is (c: a..b)
		not if (band(bnum(c),bnum(b))) is in hypothesis
		if (SOLVEPRED(c<=b,C<=B,H,0)) is in hypothesis
		then generate derived hypothesis (__spe(H)
		 & C<=B
		 & c<=b)

  RULE GenObvPredicateX.22
	if incoming hypothesis is (c: a..b)
		not if (band(bnum(c),bnum(a))) is in hypothesis
		if (SOLVEPRED(a<=c,A<=C,H,0)) is in hypothesis
		then generate derived hypothesis (__spe(H)
		 & A<=C
		 & a<=c)

  RULE GenObvPredicateX.23
	if incoming hypothesis is (0+a<=b)
		then generate derived hypothesis (a<=b)

  RULE GenObvPredicateX.24
	if incoming hypothesis is (a+0<=b)
		then generate derived hypothesis (a<=b)

  RULE GenObvPredicateX.25
	if incoming hypothesis is (0+a = b)
		then generate derived hypothesis (a = b)

  RULE GenObvPredicateX.26
	if incoming hypothesis is (a+0 = b)
		then generate derived hypothesis (a = b)

  RULE GenObvPredicateX.27
	if incoming hypothesis is (not(b = a))
		if (a<=b) is in hypothesis
		if tactic (RaiseOrderX) proves (RaiseOrderG(a,b)) and gives result (H)
		then generate derived hypothesis (H)

  RULE GenObvPredicateX.28
	if incoming hypothesis is (a<=b)
		if (not(b = a)) is in hypothesis
		if tactic (RaiseOrderX) proves (RaiseOrderG(a,b)) and gives result (H)
		then generate derived hypothesis (H)

  RULE GenObvPredicateX.29
	if incoming hypothesis is (not(a = b))
		if (a<=b) is in hypothesis
		if tactic (RaiseOrderX) proves (RaiseOrderG(a,b)) and gives result (H)
		then generate derived hypothesis (H)

  RULE GenObvPredicateX.30
	if incoming hypothesis is (a<=b)
		if (not(a = b)) is in hypothesis
		if tactic (RaiseOrderX) proves (RaiseOrderG(a,b)) and gives result (H)
		then generate derived hypothesis (H)

  RULE GenObvPredicateX.31
	if incoming hypothesis is (1<=n)
		if (not(n = 1)) is in hypothesis
		then generate derived hypothesis (2<=n)

  RULE GenObvPredicateX.32
	if incoming hypothesis is (not(n = 1))
		if (1<=n) is in hypothesis
		then generate derived hypothesis (2<=n)

  RULE GenObvPredicateX.33
	if incoming hypothesis is (a: {x})
		then generate derived hypothesis (a = x)

  RULE GenObvPredicateX.34
	if incoming hypothesis is (a: SET(x).P)
		if (x) is a variable list whith no free occurences in (a)
		then generate derived hypothesis ([x:=a]P)

  RULE GenObvPredicateX.35
	if incoming hypothesis is (btrue => b)
		then generate derived hypothesis (b)

  RULE GenObvPredicateX.36
	if incoming hypothesis is (a = bool(b))
		if (a = FALSE) is in hypothesis
		then generate derived hypothesis (not(b))

  RULE GenObvPredicateX.37
	if incoming hypothesis is (a = FALSE)
		if (a = bool(b)) is in hypothesis
		then generate derived hypothesis (not(b))

  RULE GenObvPredicateX.38
	if incoming hypothesis is (a = bool(b))
		if (a = TRUE) is in hypothesis
		then generate derived hypothesis (b)

  RULE GenObvPredicateX.39
	if incoming hypothesis is (a = TRUE)
		if (a = bool(b)) is in hypothesis
		then generate derived hypothesis (b)

  RULE GenObvPredicateX.40
	if incoming hypothesis is (TRUE = bool(b))
		then generate derived hypothesis (b)

  RULE GenObvPredicateX.41
	if incoming hypothesis is (bool(b) = TRUE)
		then generate derived hypothesis (b)

  RULE GenObvPredicateX.42
	if incoming hypothesis is (FALSE = bool(b))
		then generate derived hypothesis (not(b))

  RULE GenObvPredicateX.43
	if incoming hypothesis is (bool(b) = FALSE)
		then generate derived hypothesis (not(b))

  RULE GenObvPredicateX.44
	if incoming hypothesis is (btest(2<1))
		then generate derived hypothesis (__blankrule)

  RULE GenObvPredicateX.45
	if incoming hypothesis is (not(a: INTEGER & 0<=a))
		then generate derived hypothesis (a: INTEGER & a+1<=0)

  RULE GenObvPredicateX.46
	if incoming hypothesis is (not(-(-a): INTEGER & 0<= -(-a)))
		then generate derived hypothesis (a: INTEGER & a+1<=0)

  RULE GenObvPredicateX.47
	if incoming hypothesis is (not(a: {x}) => c)
		then generate derived hypothesis (not(a = x) => c)

  RULE GenObvPredicateX.48
	if incoming hypothesis is (a<=b)
		if (b<=a) is in hypothesis
		then generate derived hypothesis (a = b)

  RULE GenObvPredicateX.49
	if incoming hypothesis is (s: iseq(a))
		then generate derived hypothesis (s: seq(a) & s~: a +-> NATURAL-{0})

  RULE GenObvPredicateX.50
	if incoming hypothesis is (f: a >->> b)
		then generate derived hypothesis (f: a >+> b
		 & dom(f) = a
		 & ran(f) = b)

  RULE GenObvPredicateX.51
	if incoming hypothesis is (f: a>+>>b)
		then generate derived hypothesis (f: a >+> b & ran(f) = b)

  RULE GenObvPredicateX.52
	if incoming hypothesis is (f: a >-> b)
		then generate derived hypothesis (f: a >+> b & dom(f) = a)

  RULE GenObvPredicateX.53
	if incoming hypothesis is (f: a -->> b)
		then generate derived hypothesis (f: a +-> b
		 & dom(f) = a
		 & ran(f) = b)

  RULE GenObvPredicateX.54
	if incoming hypothesis is (f: a +->> b)
		then generate derived hypothesis (f: a +-> b & ran(f) = b)

  RULE GenObvPredicateX.55
	if incoming hypothesis is (f: a --> b)
		then generate derived hypothesis (f: a +-> b & dom(f) = a)

  RULE GenObvPredicateX.56
	if incoming hypothesis is (f: a >+> b)
		then generate derived hypothesis (f: a +-> b & f~: b +-> a)

  RULE GenObvPredicateX.57
	if incoming hypothesis is (a: b/\c)
		then generate derived hypothesis (a: b & a: c)

  RULE GenObvPredicateX.58
	if incoming hypothesis is (not(a: b\/c))
		then generate derived hypothesis (not(a: b) & not(a: c))

  RULE GenObvPredicateX.59
	if incoming hypothesis is (a: b-c)
		then generate derived hypothesis (a: b & not(a: c))

  RULE GenObvPredicateX.60
	if incoming hypothesis is (a: POW({x}))
		then generate derived hypothesis (not(a = {}) => a = {x})

  RULE GenObvPredicateX.61
	if incoming hypothesis is (a: INT)
		then generate derived hypothesis (a: INTEGER
		 & a<=maxint
		 & minint<=a)

  RULE GenObvPredicateX.62
	if incoming hypothesis is (a: NAT)
		then generate derived hypothesis (a: INTEGER
		 & 0<=a
		 & a<=maxint)

  RULE GenObvPredicateX.63
	if incoming hypothesis is (not(not(a)))
		then generate derived hypothesis (a)


-------------------------------------------------------------------
FORWARD THEORY GenPredicateX IS

  RULE GenPredicateX.1
	if incoming hypothesis is (not(a & b))
		then generate derived hypothesis ((a => not(b)) & (b => not(a)))

  RULE GenPredicateX.2
	if incoming hypothesis is (not(a & x: {b}))
		then generate derived hypothesis ((a => not(x = b)) & (x = b => not(a)))

  RULE GenPredicateX.3
	if incoming hypothesis is (not(a & x: {b}\/{c}))
		then generate derived hypothesis ((a => not(x: {b}\/{c})) & (x: {b}\/{c} => not(a)))

  RULE GenPredicateX.4
	if incoming hypothesis is (not(a & x: SET(y).P))
		then generate derived hypothesis ((a => not(x: SET(y).P)) & (x: SET(y).P => not(a)))

  RULE GenPredicateX.5
	if incoming hypothesis is (not(x: n..p))
		then generate derived hypothesis (n<=x => p+1<=x)

  RULE GenPredicateX.6
	if incoming hypothesis is (not(x: a\/b))
		then generate derived hypothesis (not(x: a) & not(x: b))

  RULE GenPredicateX.7
	if incoming hypothesis is (not(a: POW({x})))
		if (bgetallhyp(H)) is in hypothesis
		if (z) is a fresh variable in (H)
		then generate derived hypothesis (#z.(z: a & not(z = x)))

  RULE GenPredicateX.8
	if incoming hypothesis is (not(a: POW(x)\/{y}))
		if (bgetallhyp(H)) is in hypothesis
		if (z) is a fresh variable in (H)
		then generate derived hypothesis (#z.(z: a & not(z: x) & not(z = y)))

  RULE GenPredicateX.9
	if incoming hypothesis is (not(a: POW(SET(x).P)))
		if (y) is a fresh variable in (not(a: POW(SET(x).P)))
		then generate derived hypothesis (#y.(y: a & [x:=y]not(P)))

  RULE GenPredicateX.10
	if incoming hypothesis is (s: seq(a))
		if (not(s = {})) is in hypothesis
		then generate derived hypothesis (1<=size(s))

  RULE GenPredicateX.11
	if incoming hypothesis is (not(s = {}))
		if (s: seq(a)) is in hypothesis
		then generate derived hypothesis (1<=size(s))

  RULE GenPredicateX.12
	if incoming hypothesis is (a: x\/{y})
		then generate derived hypothesis ((not(a: x) => a = y) & (not(a = y) => a: x))

  RULE GenPredicateX.13
	if incoming hypothesis is (not(a: x\/{y}) => c)
		then generate derived hypothesis (not(a: x) => (not(a = y) => c))

  RULE GenPredicateX.14
	if incoming hypothesis is (!x.(a => b & c))
		then generate derived hypothesis (!x.(a => b) & !x.(a => c))

  RULE GenPredicateX.15
	if incoming hypothesis is (a => b & c)
		then generate derived hypothesis ((a => b) & (a => c))

  RULE GenPredicateX.16
	if incoming hypothesis is (a => (not(b) => c))
		then generate derived hypothesis (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
	if incoming hypothesis is (a => (b => c) & (c => b))
		then generate derived hypothesis (a => (b => c)
		 & b => (a => c)
		 & a => (c => b)
		 & c => (a => c))

  RULE GenPredicateX.18
	if incoming hypothesis is (not(a) => b => c)
		then generate derived hypothesis ((a => c) & (b => c))

  RULE GenPredicateX.19
	if incoming hypothesis is (a => b => c)
		then generate derived hypothesis ((not(a) => c) & (b => c))

  RULE GenPredicateX.20
	if incoming hypothesis is ((a => b) & (b => a) => c)
		then generate derived hypothesis (not(a) => (b => a => c)
		 & not(b) => (not(a) => c)
		 & b => (b => a => c)
		 & a => (b => c))

  RULE GenPredicateX.21
	if incoming hypothesis is (not(not(a) => b) => c)
		then generate derived hypothesis ((not(a) => (not(b) => c)) & (not(b) => (not(a) => c)))

  RULE GenPredicateX.22
	if incoming hypothesis is (not(a & b) => c)
		then generate derived hypothesis ((not(a) => c) & (not(b) => c))

  RULE GenPredicateX.23
	if incoming hypothesis is (not(a => b) => c)
		then generate derived hypothesis ((a => (not(b) => c)) & (not(b) => (a => c)))

  RULE GenPredicateX.24
	if incoming hypothesis is ((not(a) => b) & (b => not(a)) => c)
		then generate derived hypothesis (a => (not(b) => c)
		 & not(a) => (b => c)
		 & b => (not(a) => c)
		 & not(b) => (a => c))

  RULE GenPredicateX.25
	if incoming hypothesis is (not(a = b))
		then generate derived hypothesis (not(b = a))

  RULE GenPredicateX.26
	if incoming hypothesis is (not(x: s))
		if (f: s <-> t) is in hypothesis
		then generate derived hypothesis (not(x: dom(f)))

  RULE GenPredicateX.27
	if incoming hypothesis is (f: s +-> t)
		then generate derived hypothesis (f: s <-> t)

  RULE GenPredicateX.28
	if incoming hypothesis is (r: s <-> t)
		then generate derived hypothesis (dom(r): POW(s) & ran(r): POW(t))

  RULE GenPredicateX.29
	if incoming hypothesis is (r~: s <-> t)
		then generate derived hypothesis (r: t <-> s)

  RULE GenPredicateX.30
	if incoming hypothesis is (s: seq(a))
		then generate derived hypothesis (s: 1..size(s) --> a & size(s): NATURAL)

  RULE GenPredicateX.31
	if incoming hypothesis is (s: 1..n +-> a)
		if (dom(s) = 1..n) is in hypothesis
		if (0<=n) is in hypothesis
		then generate derived hypothesis (s: seq(a) & size(s) = n)

  RULE GenPredicateX.32
	if incoming hypothesis is (f<|m: POW(l))
		if (x: m) is in hypothesis
		then generate derived hypothesis (f<|{x}: POW(l))

  RULE GenPredicateX.33
	if incoming hypothesis is (x: m)
		if (f<|m: POW(l)) is in hypothesis
		then generate derived hypothesis (f<|{x}: POW(l))

  RULE GenPredicateX.34
	if incoming hypothesis is (x: m)
		if (m|>f: POW(l)) is in hypothesis
		then generate derived hypothesis ({x}|>f: POW(l))

  RULE GenPredicateX.35
	if incoming hypothesis is (m|>f: POW(l))
		if (x: m) is in hypothesis
		then generate derived hypothesis ({x}|>f: POW(l))

  RULE GenPredicateX.36
	if incoming hypothesis is (x: s~[{p}])
		if (s: a +-> b) is in hypothesis
		then generate derived hypothesis (s(x) = p)


-------------------------------------------------------------------
FORWARD THEORY OptimGenAnyX IS

  RULE OptimGenAnyX.1
	if incoming hypothesis is (bguard((CalculTailleX;ARI;RES): CalculTailleG(GenAnyX),T))
		if tactic (SUB~;RES) proves (bresult([S]Q)) and gives result (R)
		if tactic (FLAT~;RULE) proves (bcrelr(GenAnyX,(bflat(H & !X.(U & V => Q) & A) => R & bcall1(ForwardRule(GenAny.T)))))
		if (bcall1(GenAny(([S](u & v) => [S]Q),GenAny.T))) is in hypothesis
		then generate derived hypothesis (OptimGenAnyGSimple(A,X,U,V,u,v,Q,S,H))

  RULE OptimGenAnyX.2
	if incoming hypothesis is (bguard((CalculTailleX;ARI;RES): CalculTailleG(GenAnyX),T))
		if tactic (FLAT~;RULE) proves (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)))))
		if (bcall1(GenAny(([S](u & v) => [S]Q),GenAny.T))) is in hypothesis
		then generate derived hypothesis (OptimGenAnyG(A,X,U,V,u,v,Q,S,H))


-------------------------------------------------------------------
FORWARD THEORY _Empty IS

  RULE _Empty.1
	if incoming hypothesis is (binhyp(p))
		then generate derived hypothesis (p)





