:: PRE_CIRC semantic presentation

scheme :: PRE_CIRC:sch 24
s24{ F1() -> non empty finite set , F2( set ) -> set , P1[ set ] } :
{ F2(x) where x is Element of F1() : P1[x] } is finite
proof end;

theorem Th1: :: PRE_CIRC:1
canceled;

theorem Th2: :: PRE_CIRC:2
for f being Function
for x, y being set st dom f = {x} & rng f = {y} holds
f = {[x,y]}
proof end;

theorem Th3: :: PRE_CIRC:3
for f, g, h being Function st f c= g holds
f +* h c= g +* h
proof end;

theorem Th4: :: PRE_CIRC:4
for f, g, h being Function st f c= g & dom f misses dom h holds
f c= g +* h
proof end;

registration
cluster non empty finite natural-membered set ;
existence
ex b1 being set st
( b1 is finite & not b1 is empty & b1 is natural-membered )
proof end;
end;

notation
let A be non empty finite real-membered set ;
synonym max c1 for upper_bound c1;
end;

definition
let A be non empty finite real-membered set ;
redefine func max as max c1 -> real number means :Def1: :: PRE_CIRC:def 1
( it in A & ( for k being real number st k in A holds
k <= it ) );
compatibility
for b1 being real number holds
( b1 = max A iff ( b1 in A & ( for k being real number st k in A holds
k <= b1 ) ) )
proof end;
coherence
max A is real number
;
end;

:: deftheorem Def1 defines max PRE_CIRC:def 1 :
for A being non empty finite real-membered set
for b2 being real number holds
( b2 = max A iff ( b2 in A & ( for k being real number st k in A holds
k <= b2 ) ) );

registration
let X be non empty finite natural-membered set ;
cluster max a1 -> natural ;
coherence
max X is natural
proof end;
end;

theorem Th5: :: PRE_CIRC:5
for I being set
for MSS being ManySortedSet of I holds (MSS # ) . (<*> I) = {{} }
proof end;

scheme :: PRE_CIRC:sch 68
s68{ F1() -> set , P1[ set ], F2( set ) -> set , F3( set ) -> set } :
ex f being ManySortedSet of F1() st
for i being Element of F1() st i in F1() holds
( ( P1[i] implies f . i = F2(i) ) & ( P1[i] implies f . i = F3(i) ) )
proof end;

notation
let I be set ;
let IT be ManySortedSet of I;
synonym locally-finite c2 for finite-yielding c1;
end;

definition
let I be set ;
let IT be ManySortedSet of I;
canceled;
redefine attr locally-finite as a2 is locally-finite means :: PRE_CIRC:def 3
for i being set st i in I holds
IT . i is finite;
compatibility
( IT is locally-finite iff for i being set st i in I holds
IT . i is finite )
proof end;
end;

:: deftheorem Def2 PRE_CIRC:def 2 :
canceled;

:: deftheorem Def3 defines locally-finite PRE_CIRC:def 3 :
for I being set
for IT being ManySortedSet of I holds
( IT is locally-finite iff for i being set st i in I holds
IT . i is finite );

registration
let I be set ;
cluster V2 V31 ManySortedSet of a1;
existence
ex b1 being ManySortedSet of I st
( b1 is non-empty & b1 is locally-finite )
proof end;
end;

definition
let I be set , A be set ;
redefine func --> as c1 --> c2 -> ManySortedSet of a1;
coherence
I --> A is ManySortedSet of I
proof end;
end;

definition
let I be set ;
let M be ManySortedSet of I;
let A be Subset of I;
redefine func | as c2 | c3 -> ManySortedSet of a3;
coherence
M | A is ManySortedSet of A
proof end;
end;

registration
let M be non-empty Function;
let A be set ;
cluster a1 | a2 -> non-empty ;
coherence
M | A is non-empty
proof end;
end;

theorem Th6: :: PRE_CIRC:6
for I being non empty set
for B being V2 ManySortedSet of I holds not union (rng B) is empty
proof end;

theorem Th7: :: PRE_CIRC:7
for I being set holds uncurry (I --> {} ) = {}
proof end;

theorem Th8: :: PRE_CIRC:8
for I being non empty set
for A being set
for B being V2 ManySortedSet of I
for F being ManySortedFunction of I --> A,B holds dom (commute F) = A
proof end;

scheme :: PRE_CIRC:sch 76
s76{ F1() -> non empty set , F2() -> Element of F1(), F3( Element of NAT , Element of F1()) -> Element of F1() } :
( ex f being Function of NAT ,F1() st
( f . 0 = F2() & ( for i being Element of NAT holds f . (i + 1) = F3(i,(f . i)) ) ) & ( for f1, f2 being Function of NAT ,F1() st f1 . 0 = F2() & ( for i being Element of NAT holds f1 . (i + 1) = F3(i,(f1 . i)) ) & f2 . 0 = F2() & ( for i being Element of NAT holds f2 . (i + 1) = F3(i,(f2 . i)) ) holds
f1 = f2 ) )
proof end;

scheme :: PRE_CIRC:sch 80
s80{ F1() -> non empty set , F2() -> Subset of F1(), F3() -> ManySortedSet of F2(), F4() -> ManySortedSet of F2(), F5( set ) -> set } :
ex f being ManySortedFunction of F3(),F4() st
for i being Element of F1() st i in F2() holds
f . i = F5(i)
provided
E29: for i being Element of F1() st i in F2() holds
F5(i) is Function of F3() . i,F4() . i
proof end;

theorem Th9: :: PRE_CIRC:9
for I being set
for f being V2 ManySortedSet of I
for g being Function
for s being Element of product f st dom g c= dom f & ( for x being set st x in dom g holds
g . x in f . x ) holds
s +* g is Element of product f
proof end;

theorem Th10: :: PRE_CIRC:10
for A, B being non empty set
for C being V2 ManySortedSet of A
for InpFs being ManySortedFunction of A --> B,C
for b being Element of B ex c being ManySortedSet of A st
( c = (commute InpFs) . b & c in C )
proof end;

theorem Th11: :: PRE_CIRC:11
for I being set
for M being ManySortedSet of I
for x, g being Function st x in product M holds
x * g in product (M * g)
proof end;

theorem Th12: :: PRE_CIRC:12
for n being Element of NAT
for a being set holds product (n |-> {a}) = {(n |-> a)}
proof end;

registration
let D be non empty set ;
cluster -> finite Element of FinTrees a1;
coherence
for b1 being Element of FinTrees D holds b1 is finite
proof end;
end;

registration
let T be finite DecoratedTree;
let t be Element of dom T;
cluster a1 | a2 -> finite ;
coherence
T | t is finite
proof end;
end;

theorem Th13: :: PRE_CIRC:13
for T being finite Tree
for p being Element of T holds T | p,{ t where t is Element of T : p is_a_prefix_of t } are_equipotent
proof end;

registration
let T be finite DecoratedTree;
let t be Element of dom T;
let T1 be finite DecoratedTree;
cluster a1 with-replacement a2,a3 -> finite ;
coherence
T with-replacement t,T1 is finite
proof end;
end;

theorem Th14: :: PRE_CIRC:14
for T, T1 being finite Tree
for p being Element of T holds T with-replacement p,T1 = { t where t is Element of T : not p is_a_prefix_of t } \/ { (p ^ t1) where t1 is Element of T1 : verum }
proof end;

theorem Th15: :: PRE_CIRC:15
for T, T1 being finite Tree
for p being Element of T
for f being FinSequence of NAT st f in T with-replacement p,T1 & p is_a_prefix_of f holds
ex t1 being Element of T1 st f = p ^ t1
proof end;

theorem Th16: :: PRE_CIRC:16
for p being Tree-yielding FinSequence
for k being Element of NAT st k + 1 in dom p holds
(tree p) | <*k*> = p . (k + 1)
proof end;

theorem Th17: :: PRE_CIRC:17
for q being DTree-yielding FinSequence
for k being Element of NAT st k + 1 in dom q holds
<*k*> in tree (doms q)
proof end;

theorem Th18: :: PRE_CIRC:18
for p, q being Tree-yielding FinSequence
for k being Element of NAT st len p = len q & k + 1 in dom p & ( for i being Element of NAT st i in dom p & i <> k + 1 holds
p . i = q . i ) holds
for t being Tree st q . (k + 1) = t holds
tree q = (tree p) with-replacement <*k*>,t
proof end;

theorem Th19: :: PRE_CIRC:19
for e1, e2 being finite DecoratedTree
for x being set
for k being Element of NAT
for p being DTree-yielding FinSequence st <*k*> in dom e1 & e1 = x -tree p holds
ex q being DTree-yielding FinSequence st
( e1 with-replacement <*k*>,e2 = x -tree q & len q = len p & q . (k + 1) = e2 & ( for i being Element of NAT st i in dom p & i <> k + 1 holds
q . i = p . i ) )
proof end;

theorem Th20: :: PRE_CIRC:20
for T being finite Tree
for p being Element of T st p <> {} holds
card (T | p) < card T
proof end;

theorem Th21: :: PRE_CIRC:21
for f being Function holds Card f = Card (dom f)
proof end;

theorem Th22: :: PRE_CIRC:22
for T, T1 being finite Tree
for p being Element of T holds (card (T with-replacement p,T1)) + (card (T | p)) = (card T) + (card T1)
proof end;

theorem Th23: :: PRE_CIRC:23
for T, T1 being finite DecoratedTree
for p being Element of dom T holds (card (T with-replacement p,T1)) + (card (T | p)) = (card T) + (card T1)
proof end;

registration
let x be set ;
cluster root-tree a1 -> finite ;
coherence
root-tree x is finite
proof end;
end;

theorem Th24: :: PRE_CIRC:24
for x being set holds card (root-tree x) = 1
proof end;

notation
let A be non empty finite real-membered set ;
synonym min c1 for lower_bound c1;
end;

definition
let A be non empty finite real-membered set ;
redefine func lower_bound c1 -> set means :: PRE_CIRC:def 4
( it in A & ( for k being real number st k in A holds
it <= k ) );
compatibility
for b1 being set holds
( b1 = min A iff ( b1 in A & ( for k being real number st k in A holds
b1 <= k ) ) )
proof end;
end;

:: deftheorem Def4 defines min PRE_CIRC:def 4 :
for A being non empty finite real-membered set
for b2 being set holds
( b2 = min A iff ( b2 in A & ( for k being real number st k in A holds
b2 <= k ) ) );

theorem Th25: :: PRE_CIRC:25
for F being non empty finite set holds (card F) - 1 = (card F) -' 1
proof end;

theorem Th26: :: PRE_CIRC:26
for f, g being Function holds
( dom f, dom g are_equipotent iff f,g are_equipotent )
proof end;

theorem Th27: :: PRE_CIRC:27
for f, g being finite Function st dom f misses dom g holds
card (f +* g) = (card f) + (card g)
proof end;