:: TREES_9 semantic presentation

definition
let D be non empty set ;
let F be non empty DTree-set of D;
let Tset be non empty Subset of F;
redefine mode Element as Element of c3 -> Element of a2;
coherence
for b1 being Element of Tset holds b1 is Element of F
proof end;
end;

registration
cluster finite -> finite-order set ;
coherence
for b1 being Tree st b1 is finite holds
b1 is finite-order
proof end;
end;

Lemma38: for n being set
for p being FinSequence st n in dom p holds
ex k being Element of NAT st
( n = k + 1 & k < len p )
proof end;

E41: now
let p be FinSequence, q be FinSequence;
assume that
E22: len p = len q and
E25: for i being Element of NAT st i < len p holds
p . (i + 1) = q . (i + 1) ;
E27: dom p = dom q by , FINSEQ_3:31;
now
let i be Element of NAT ;
assume i in dom p ;
then consider k being Element of NAT such that
E28: ( i = k + 1 & k < len p ) by ;
thus p . i = q . i by , ;
end;
hence p = q by , FINSEQ_1:17;
end;

Lemma43: for n being Element of NAT
for p being FinSequence st n < len p holds
( n + 1 in dom p & p . (n + 1) in rng p )
proof end;

E44: now
let p be FinSequence;
let x be set ;
assume x in rng p ;
then consider y being set such that
E22: ( y in dom p & x = p . y ) by FUNCT_1:def 5;
ex k being Element of NAT st
( y = k + 1 & k < len p ) by , ;
hence ex k being Element of NAT st
( k < len p & x = p . (k + 1) ) by ;
end;

theorem Th1: :: TREES_9:1
for t being DecoratedTree holds t | (<*> NAT ) = t
proof end;

theorem Th2: :: TREES_9:2
for t being Tree
for p, q being FinSequence of NAT st p ^ q in t holds
t | (p ^ q) = (t | p) | q
proof end;

theorem Th3: :: TREES_9:3
for t being DecoratedTree
for p, q being FinSequence of NAT st p ^ q in dom t holds
t | (p ^ q) = (t | p) | q
proof end;

definition
let IT be DecoratedTree;
attr a1 is root means :Def1: :: TREES_9:def 1
dom IT = elementary_tree 0;
end;

:: deftheorem Def1 defines root TREES_9:def 1 :
for IT being DecoratedTree holds
( IT is root iff dom IT = elementary_tree 0 );

registration
cluster root -> finite set ;
coherence
for b1 being DecoratedTree st b1 is root holds
b1 is finite
proof end;
end;

theorem Th4: :: TREES_9:4
for t being DecoratedTree holds
( t is root iff {} in Leaves (dom t) )
proof end;

theorem Th5: :: TREES_9:5
for t being Tree
for p being Element of t holds
( t | p = elementary_tree 0 iff p in Leaves t )
proof end;

theorem Th6: :: TREES_9:6
for t being DecoratedTree
for p being Node of t holds
( t | p is root iff p in Leaves (dom t) )
proof end;

registration
cluster finite root set ;
existence
ex b1 being DecoratedTree st b1 is root
proof end;
cluster finite non root set ;
existence
ex b1 being DecoratedTree st
( b1 is finite & not b1 is root )
proof end;
end;

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

definition
let IT be Tree;
attr a1 is finite-branching means :Def2: :: TREES_9:def 2
for x being Element of IT holds succ x is finite;
end;

:: deftheorem Def2 defines finite-branching TREES_9:def 2 :
for IT being Tree holds
( IT is finite-branching iff for x being Element of IT holds succ x is finite );

registration
cluster finite-order -> finite-branching set ;
coherence
for b1 being Tree st b1 is finite-order holds
b1 is finite-branching
proof end;
end;

registration
cluster finite finite-order finite-branching set ;
existence
ex b1 being Tree st b1 is finite
proof end;
end;

definition
let IT be DecoratedTree;
attr a1 is finite-order means :Def3: :: TREES_9:def 3
dom IT is finite-order;
attr a1 is finite-branching means :Def4: :: TREES_9:def 4
dom IT is finite-branching;
end;

:: deftheorem Def3 defines finite-order TREES_9:def 3 :
for IT being DecoratedTree holds
( IT is finite-order iff dom IT is finite-order );

:: deftheorem Def4 defines finite-branching TREES_9:def 4 :
for IT being DecoratedTree holds
( IT is finite-branching iff dom IT is finite-branching );

registration
cluster finite -> finite-order set ;
coherence
for b1 being DecoratedTree st b1 is finite holds
b1 is finite-order
proof end;
cluster finite-order -> finite-branching set ;
coherence
for b1 being DecoratedTree st b1 is finite-order holds
b1 is finite-branching
proof end;
end;

registration
cluster finite finite-order finite-branching set ;
existence
ex b1 being DecoratedTree st b1 is finite
proof end;
end;

registration
let t be finite-order DecoratedTree;
cluster dom a1 -> finite-order finite-branching ;
coherence
dom t is finite-order
by ;
end;

registration
let t be finite-branching DecoratedTree;
cluster dom a1 -> finite-branching ;
coherence
dom t is finite-branching
by ;
end;

registration
let t be finite-branching Tree;
let p be Element of t;
cluster succ a2 -> finite ;
coherence
succ p is finite
by ;
end;

scheme :: TREES_9:sch 58
s58{ F1( set ) -> set , F2() -> finite set } :
for n being Element of NAT holds
( F1(n) in F2() iff n < card F2() )
provided
E22: for x being set st x in F2() holds
ex n being Element of NAT st x = F1(n) and
E25: for i, j being Element of NAT st i < j & F1(j) in F2() holds
F1(i) in F2() and
E27: for i, j being Element of NAT st F1(i) = F1(j) holds
i = j
proof end;

registration
let X be set ;
cluster one-to-one empty FinSequence of a1;
existence
ex b1 being FinSequence of X st
( b1 is one-to-one & b1 is empty )
proof end;
end;

theorem Th7: :: TREES_9:7
for t being finite-branching Tree
for p being Element of t
for n being Element of NAT holds
( p ^ <*n*> in succ p iff n < card (succ p) )
proof end;

definition
let t be finite-branching Tree;
let p be Element of t;
func c2 succ -> one-to-one FinSequence of a1 means :Def5: :: TREES_9:def 5
( len it = card (succ p) & rng it = succ p & ( for i being Element of NAT st i < len it holds
it . (i + 1) = p ^ <*i*> ) );
existence
ex b1 being one-to-one FinSequence of t st
( len b1 = card (succ p) & rng b1 = succ p & ( for i being Element of NAT st i < len b1 holds
b1 . (i + 1) = p ^ <*i*> ) )
proof end;
uniqueness
for b1, b2 being one-to-one FinSequence of t st len b1 = card (succ p) & rng b1 = succ p & ( for i being Element of NAT st i < len b1 holds
b1 . (i + 1) = p ^ <*i*> ) & len b2 = card (succ p) & rng b2 = succ p & ( for i being Element of NAT st i < len b2 holds
b2 . (i + 1) = p ^ <*i*> ) holds
b1 = b2
proof end;
end;

:: deftheorem Def5 defines succ TREES_9:def 5 :
for t being finite-branching Tree
for p being Element of t
for b3 being one-to-one FinSequence of t holds
( b3 = p succ iff ( len b3 = card (succ p) & rng b3 = succ p & ( for i being Element of NAT st i < len b3 holds
b3 . (i + 1) = p ^ <*i*> ) ) );

definition
let t be finite-branching DecoratedTree;
let p be FinSequence;
assume E22: p in dom t ;
func succ c1,c2 -> FinSequence means :Def6: :: TREES_9:def 6
ex q being Element of dom t st
( q = p & it = t * (q succ ) );
existence
ex b1 being FinSequence ex q being Element of dom t st
( q = p & b1 = t * (q succ ) )
proof end;
uniqueness
for b1, b2 being FinSequence st ex q being Element of dom t st
( q = p & b1 = t * (q succ ) ) & ex q being Element of dom t st
( q = p & b2 = t * (q succ ) ) holds
b1 = b2
;
end;

:: deftheorem Def6 defines succ TREES_9:def 6 :
for t being finite-branching DecoratedTree
for p being FinSequence st p in dom t holds
for b3 being FinSequence holds
( b3 = succ t,p iff ex q being Element of dom t st
( q = p & b3 = t * (q succ ) ) );

theorem Th8: :: TREES_9:8
for t being finite-branching DecoratedTree ex x being set ex p being DTree-yielding FinSequence st t = x -tree p
proof end;

Lemma94: for t being finite DecoratedTree
for p being Node of t holds t | p is finite
;

registration
let t be finite DecoratedTree;
let p be Node of t;
cluster a1 | a2 -> finite finite-order finite-branching ;
coherence
t | p is finite
;
end;

theorem Th9: :: TREES_9:9
canceled;

theorem Th10: :: TREES_9:10
for t being finite Tree
for p being Element of t st t = t | p holds
p = {}
proof end;

registration
let D be non empty set ;
let S be non empty Subset of (FinTrees D);
cluster -> finite Element of a2;
coherence
for b1 being Element of S holds b1 is finite
proof end;
end;

definition
let t be DecoratedTree;
func Subtrees c1 -> set equals :: TREES_9:def 7
{ (t | p) where p is Node of t : verum } ;
coherence
{ (t | p) where p is Node of t : verum } is set
;
end;

:: deftheorem Def7 defines Subtrees TREES_9:def 7 :
for t being DecoratedTree holds Subtrees t = { (t | p) where p is Node of t : verum } ;

registration
let t be DecoratedTree;
cluster Subtrees a1 -> non empty constituted-DTrees ;
coherence
( Subtrees t is constituted-DTrees & not Subtrees t is empty )
proof end;
end;

definition
let D be non empty set ;
let t be DecoratedTree of D;
redefine func Subtrees as Subtrees c2 -> non empty Subset of (Trees a1);
coherence
Subtrees t is non empty Subset of (Trees D)
proof end;
end;

definition
let D be non empty set ;
let t be finite DecoratedTree of D;
redefine func Subtrees as Subtrees c2 -> non empty Subset of (FinTrees a1);
coherence
Subtrees t is non empty Subset of (FinTrees D)
proof end;
end;

registration
let t be finite DecoratedTree;
cluster -> finite Element of Subtrees a1;
coherence
for b1 being Element of Subtrees t holds b1 is finite
proof end;
end;

theorem Th11: :: TREES_9:11
for x being set
for t being DecoratedTree holds
( x in Subtrees t iff ex n being Node of t st x = t | n ) ;

theorem Th12: :: TREES_9:12
for t being DecoratedTree holds t in Subtrees t
proof end;

theorem Th13: :: TREES_9:13
for t1, t2 being DecoratedTree st t1 is finite & Subtrees t1 = Subtrees t2 holds
t1 = t2
proof end;

theorem Th14: :: TREES_9:14
for t being DecoratedTree
for n being Node of t holds Subtrees (t | n) c= Subtrees t
proof end;

definition
let t be DecoratedTree;
func FixedSubtrees c1 -> Subset of [:(dom a1),(Subtrees a1):] equals :: TREES_9:def 8
{ [p,(t | p)] where p is Node of t : verum } ;
coherence
{ [p,(t | p)] where p is Node of t : verum } is Subset of [:(dom t),(Subtrees t):]
proof end;
end;

:: deftheorem Def8 defines FixedSubtrees TREES_9:def 8 :
for t being DecoratedTree holds FixedSubtrees t = { [p,(t | p)] where p is Node of t : verum } ;

registration
let t be DecoratedTree;
cluster FixedSubtrees a1 -> non empty ;
coherence
not FixedSubtrees t is empty
proof end;
end;

theorem Th15: :: TREES_9:15
for x being set
for t being DecoratedTree holds
( x in FixedSubtrees t iff ex n being Node of t st x = [n,(t | n)] ) ;

theorem Th16: :: TREES_9:16
for t being DecoratedTree holds [{} ,t] in FixedSubtrees t
proof end;

theorem Th17: :: TREES_9:17
for t1, t2 being DecoratedTree st FixedSubtrees t1 = FixedSubtrees t2 holds
t1 = t2
proof end;

definition
let t be DecoratedTree;
let C be set ;
func c2 -Subtrees c1 -> Subset of (Subtrees a1) equals :: TREES_9:def 9
{ (t | p) where p is Node of t : ( not p in Leaves (dom t) or t . p in C ) } ;
coherence
{ (t | p) where p is Node of t : ( not p in Leaves (dom t) or t . p in C ) } is Subset of (Subtrees t)
proof end;
end;

:: deftheorem Def9 defines -Subtrees TREES_9:def 9 :
for t being DecoratedTree
for C being set holds C -Subtrees t = { (t | p) where p is Node of t : ( not p in Leaves (dom t) or t . p in C ) } ;

theorem Th18: :: TREES_9:18
for x being set
for t being DecoratedTree
for C being set holds
( x in C -Subtrees t iff ex n being Node of t st
( x = t | n & ( not n in Leaves (dom t) or t . n in C ) ) ) ;

theorem Th19: :: TREES_9:19
for t being DecoratedTree
for C being set holds
( C -Subtrees t is empty iff ( t is root & not t . {} in C ) )
proof end;

definition
let t be finite DecoratedTree;
let C be set ;
func c2 -ImmediateSubtrees c1 -> Function of a2 -Subtrees a1,(Subtrees a1) * means :: TREES_9:def 10
for d being DecoratedTree st d in C -Subtrees t holds
for p being FinSequence of Subtrees t st p = it . d holds
d = (d . {} ) -tree p;
existence
ex b1 being Function of C -Subtrees t,(Subtrees t) * st
for d being DecoratedTree st d in C -Subtrees t holds
for p being FinSequence of Subtrees t st p = b1 . d holds
d = (d . {} ) -tree p
proof end;
uniqueness
for b1, b2 being Function of C -Subtrees t,(Subtrees t) * st ( for d being DecoratedTree st d in C -Subtrees t holds
for p being FinSequence of Subtrees t st p = b1 . d holds
d = (d . {} ) -tree p ) & ( for d being DecoratedTree st d in C -Subtrees t holds
for p being FinSequence of Subtrees t st p = b2 . d holds
d = (d . {} ) -tree p ) holds
b1 = b2
proof end;
end;

:: deftheorem Def10 defines -ImmediateSubtrees TREES_9:def 10 :
for t being finite DecoratedTree
for C being set
for b3 being Function of C -Subtrees t,(Subtrees t) * holds
( b3 = C -ImmediateSubtrees t iff for d being DecoratedTree st d in C -Subtrees t holds
for p being FinSequence of Subtrees t st p = b3 . d holds
d = (d . {} ) -tree p );

definition
let X be non empty constituted-DTrees set ;
func Subtrees c1 -> set equals :: TREES_9:def 11
{ (t | p) where t is Element of X, p is Node of t : verum } ;
coherence
{ (t | p) where t is Element of X, p is Node of t : verum } is set
;
end;

:: deftheorem Def11 defines Subtrees TREES_9:def 11 :
for X being non empty constituted-DTrees set holds Subtrees X = { (t | p) where t is Element of X, p is Node of t : verum } ;

registration
let X be non empty constituted-DTrees set ;
cluster Subtrees a1 -> non empty constituted-DTrees ;
coherence
( Subtrees X is constituted-DTrees & not Subtrees X is empty )
proof end;
end;

definition
let D be non empty set ;
let X be non empty Subset of (Trees D);
redefine func Subtrees as Subtrees c2 -> non empty Subset of (Trees a1);
coherence
Subtrees X is non empty Subset of (Trees D)
proof end;
end;

definition
let D be non empty set ;
let X be non empty Subset of (FinTrees D);
redefine func Subtrees as Subtrees c2 -> non empty Subset of (FinTrees a1);
coherence
Subtrees X is non empty Subset of (FinTrees D)
proof end;
end;

theorem Th20: :: TREES_9:20
for x being set
for X being non empty constituted-DTrees set holds
( x in Subtrees X iff ex t being Element of X ex n being Node of t st x = t | n ) ;

theorem Th21: :: TREES_9:21
for t being DecoratedTree
for X being non empty constituted-DTrees set st t in X holds
t in Subtrees X
proof end;

theorem Th22: :: TREES_9:22
for X, Y being non empty constituted-DTrees set st X c= Y holds
Subtrees X c= Subtrees Y
proof end;

registration
let t be DecoratedTree;
cluster {a1} -> constituted-DTrees ;
coherence
{t} is constituted-DTrees
by TREES_3:15;
end;

theorem Th23: :: TREES_9:23
for t being DecoratedTree holds Subtrees {t} = Subtrees t
proof end;

theorem Th24: :: TREES_9:24
for X being non empty constituted-DTrees set holds Subtrees X = union { (Subtrees t) where t is Element of X : verum }
proof end;

definition
let X be non empty constituted-DTrees set ;
let C be set ;
func c2 -Subtrees c1 -> Subset of (Subtrees a1) equals :: TREES_9:def 12
{ (t | p) where t is Element of X, p is Node of t : ( not p in Leaves (dom t) or t . p in C ) } ;
coherence
{ (t | p) where t is Element of X, p is Node of t : ( not p in Leaves (dom t) or t . p in C ) } is Subset of (Subtrees X)
proof end;
end;

:: deftheorem Def12 defines -Subtrees TREES_9:def 12 :
for X being non empty constituted-DTrees set
for C being set holds C -Subtrees X = { (t | p) where t is Element of X, p is Node of t : ( not p in Leaves (dom t) or t . p in C ) } ;

theorem Th25: :: TREES_9:25
for x, C being set
for X being non empty constituted-DTrees set holds
( x in C -Subtrees X iff ex t being Element of X ex n being Node of t st
( x = t | n & ( not n in Leaves (dom t) or t . n in C ) ) ) ;

theorem Th26: :: TREES_9:26
for C being set
for X being non empty constituted-DTrees set holds
( C -Subtrees X is empty iff for t being Element of X holds
( t is root & not t . {} in C ) )
proof end;

theorem Th27: :: TREES_9:27
for t being DecoratedTree
for C being set holds C -Subtrees {t} = C -Subtrees t
proof end;

theorem Th28: :: TREES_9:28
for C being set
for X being non empty constituted-DTrees set holds C -Subtrees X = union { (C -Subtrees t) where t is Element of X : verum }
proof end;

definition
let X be non empty constituted-DTrees set ;
assume E22: for t being Element of X holds t is finite ;
let C be set ;
func c2 -ImmediateSubtrees c1 -> Function of a2 -Subtrees a1,(Subtrees a1) * means :: TREES_9:def 13
for d being DecoratedTree st d in C -Subtrees X holds
for p being FinSequence of Subtrees X st p = it . d holds
d = (d . {} ) -tree p;
existence
ex b1 being Function of C -Subtrees X,(Subtrees X) * st
for d being DecoratedTree st d in C -Subtrees X holds
for p being FinSequence of Subtrees X st p = b1 . d holds
d = (d . {} ) -tree p
proof end;
uniqueness
for b1, b2 being Function of C -Subtrees X,(Subtrees X) * st ( for d being DecoratedTree st d in C -Subtrees X holds
for p being FinSequence of Subtrees X st p = b1 . d holds
d = (d . {} ) -tree p ) & ( for d being DecoratedTree st d in C -Subtrees X holds
for p being FinSequence of Subtrees X st p = b2 . d holds
d = (d . {} ) -tree p ) holds
b1 = b2
proof end;
end;

:: deftheorem Def13 defines -ImmediateSubtrees TREES_9:def 13 :
for X being non empty constituted-DTrees set st ( for t being Element of X holds t is finite ) holds
for C being set
for b3 being Function of C -Subtrees X,(Subtrees X) * holds
( b3 = C -ImmediateSubtrees X iff for d being DecoratedTree st d in C -Subtrees X holds
for p being FinSequence of Subtrees X st p = b3 . d holds
d = (d . {} ) -tree p );

registration
let t be Tree;
cluster empty Element of a1;
existence
ex b1 being Element of t st b1 is empty
proof end;
end;

theorem Th29: :: TREES_9:29
for t being finite DecoratedTree
for p being Element of dom t holds
( len (succ t,p) = len (p succ ) & dom (succ t,p) = dom (p succ ) )
proof end;

theorem Th30: :: TREES_9:30
for p being FinTree-yielding FinSequence
for n being empty Element of tree p holds card (succ n) = len p
proof end;

theorem Th31: :: TREES_9:31
for t being finite DecoratedTree
for x being set
for p being DTree-yielding FinSequence st t = x -tree p holds
for n being empty Element of dom t holds succ t,n = roots p
proof end;

theorem Th32: :: TREES_9:32
for t being finite DecoratedTree
for p being Node of t
for q being Node of (t | p) holds succ t,(p ^ q) = succ (t | p),q
proof end;