Article BINTREE1, MML version 4.99.1005

:: BINTREE1:funcnot 1 => BINTREE1:func 1
definition
  let a1 be non empty set;
  let a2 be Function-like DecoratedTree-like ParametrizedSubset of a1;
  func root-label A2 -> Element of a1 equals
    a2 . {};
end;

:: BINTREE1:def 1
theorem
for b1 being non empty set
for b2 being Function-like DecoratedTree-like ParametrizedSubset of b1 holds
   root-label b2 = b2 . {};

:: BINTREE1:th 1
theorem
for b1 being non empty set
for b2 being Function-like DecoratedTree-like ParametrizedSubset of b1 holds
   roots <*b2*> = <*root-label b2*>;

:: BINTREE1:th 2
theorem
for b1 being non empty set
for b2, b3 being Function-like DecoratedTree-like ParametrizedSubset of b1 holds
roots <*b2,b3*> = <*root-label b2,root-label b3*>;

:: BINTREE1:attrnot 1 => BINTREE1:attr 1
definition
  let a1 be non empty Tree-like set;
  attr a1 is binary means
    for b1 being Element of a1
          st not b1 in Leaves a1
       holds succ b1 = {b1 ^ <*0*>,b1 ^ <*1*>};
end;

:: BINTREE1:dfs 2
definiens
  let a1 be non empty Tree-like set;
To prove
     a1 is binary
it is sufficient to prove
  thus for b1 being Element of a1
          st not b1 in Leaves a1
       holds succ b1 = {b1 ^ <*0*>,b1 ^ <*1*>};

:: BINTREE1:def 2
theorem
for b1 being non empty Tree-like set holds
      b1 is binary
   iff
      for b2 being Element of b1
            st not b2 in Leaves b1
         holds succ b2 = {b2 ^ <*0*>,b2 ^ <*1*>};

:: BINTREE1:th 5
theorem
for b1 being non empty Tree-like set
for b2 being Element of b1 holds
      succ b2 = {}
   iff
      b2 in Leaves b1;

:: BINTREE1:th 6
theorem
elementary_tree 0 is binary;

:: BINTREE1:th 7
theorem
elementary_tree 2 is binary;

:: BINTREE1:exreg 1
registration
  cluster non empty finite Tree-like binary set;
end;

:: BINTREE1:attrnot 2 => BINTREE1:attr 2
definition
  let a1 be Relation-like Function-like DecoratedTree-like set;
  attr a1 is binary means
    proj1 a1 is binary;
end;

:: BINTREE1:dfs 3
definiens
  let a1 be Relation-like Function-like DecoratedTree-like set;
To prove
     a1 is binary
it is sufficient to prove
  thus proj1 a1 is binary;

:: BINTREE1:def 3
theorem
for b1 being Relation-like Function-like DecoratedTree-like set holds
      b1 is binary
   iff
      proj1 b1 is binary;

:: BINTREE1:exreg 2
registration
  let a1 be non empty set;
  cluster Relation-like Function-like finite DecoratedTree-like binary ParametrizedSubset of a1;
end;

:: BINTREE1:exreg 3
registration
  cluster Relation-like Function-like finite DecoratedTree-like binary set;
end;

:: BINTREE1:condreg 1
registration
  cluster non empty Tree-like binary -> finite-order (set);
end;

:: BINTREE1:th 8
theorem
for b1, b2 being non empty Tree-like set
for b3 being Element of tree(b1,b2) holds
   (for b4 being Element of b1
          st b3 = <*0*> ^ b4
       holds    b3 in Leaves tree(b1,b2)
       iff
          b4 in Leaves b1) &
    (for b4 being Element of b2
          st b3 = <*1*> ^ b4
       holds    b3 in Leaves tree(b1,b2)
       iff
          b4 in Leaves b2);

:: BINTREE1:th 9
theorem
for b1, b2 being non empty Tree-like set
for b3 being Element of tree(b1,b2) holds
   (b3 = {} implies succ b3 = {b3 ^ <*0*>,b3 ^ <*1*>}) &
    (for b4 being Element of b1
       st b3 = <*0*> ^ b4
    for b5 being Relation-like Function-like FinSequence-like set holds
          b5 in succ b4
       iff
          <*0*> ^ b5 in succ b3) &
    (for b4 being Element of b2
       st b3 = <*1*> ^ b4
    for b5 being Relation-like Function-like FinSequence-like set holds
          b5 in succ b4
       iff
          <*1*> ^ b5 in succ b3);

:: BINTREE1:th 10
theorem
for b1, b2 being non empty Tree-like set holds
   b1 is binary & b2 is binary
iff
   tree(b1,b2) is binary;

:: BINTREE1:th 11
theorem
for b1, b2 being Relation-like Function-like DecoratedTree-like set
for b3 being set holds
      b1 is binary & b2 is binary
   iff
      b3 -tree(b1,b2) is binary;

:: BINTREE1:funcnot 2 => BINTREE1:func 2
definition
  let a1 be non empty set;
  let a2 be Element of a1;
  let a3, a4 be Function-like finite DecoratedTree-like binary ParametrizedSubset of a1;
  redefine func a2 -tree(a3,a4) -> Function-like finite DecoratedTree-like binary ParametrizedSubset of a1;
end;

:: BINTREE1:attrnot 3 => BINTREE1:attr 3
definition
  let a1 be non empty DTConstrStr;
  attr a1 is binary means
    for b1 being Element of the carrier of a1
    for b2 being Relation-like Function-like FinSequence-like set
          st b1 ==> b2
       holds ex b3, b4 being Element of the carrier of a1 st
          b2 = <*b3,b4*>;
end;

:: BINTREE1:dfs 4
definiens
  let a1 be non empty DTConstrStr;
To prove
     a1 is binary
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
    for b2 being Relation-like Function-like FinSequence-like set
          st b1 ==> b2
       holds ex b3, b4 being Element of the carrier of a1 st
          b2 = <*b3,b4*>;

:: BINTREE1:def 4
theorem
for b1 being non empty DTConstrStr holds
      b1 is binary
   iff
      for b2 being Element of the carrier of b1
      for b3 being Relation-like Function-like FinSequence-like set
            st b2 ==> b3
         holds ex b4, b5 being Element of the carrier of b1 st
            b3 = <*b4,b5*>;

:: BINTREE1:exreg 4
registration
  cluster non empty strict with_terminals with_nonterminals with_useful_nonterminals binary DTConstrStr;
end;

:: BINTREE1:sch 1
scheme BINTREE1:sch 1
{F1 -> non empty set}:
ex b1 being non empty strict binary DTConstrStr st
   the carrier of b1 = F1() &
    (for b2, b3, b4 being Element of the carrier of b1 holds
       b2 ==> <*b3,b4*>
    iff
       P1[b2, b3, b4])


:: BINTREE1:th 12
theorem
for b1 being non empty with_terminals with_nonterminals binary DTConstrStr
for b2 being FinSequence of TS b1
for b3 being Element of the carrier of b1
      st b3 ==> roots b2
   holds b3 is Element of NonTerminals b1 &
    dom b2 = {1,2} &
    1 in dom b2 &
    2 in dom b2 &
    (ex b4, b5 being Element of TS b1 st
       roots b2 = <*root-label b4,root-label b5*> &
        b4 = b2 . 1 &
        b5 = b2 . 2 &
        b3 -tree b2 = b3 -tree(b4,b5) &
        b4 in rng b2 &
        b5 in rng b2);

:: BINTREE1:sch 2
scheme BINTREE1:sch 2
{F1 -> non empty with_terminals with_nonterminals binary DTConstrStr}:
for b1 being Element of TS F1() holds
   P1[b1]
provided
   for b1 being Element of Terminals F1() holds
      P1[root-tree b1]
and
   for b1 being Element of NonTerminals F1()
   for b2, b3 being Element of TS F1()
         st b1 ==> <*root-label b2,root-label b3*> & P1[b2] & P1[b3]
      holds P1[b1 -tree(b2,b3)];


:: BINTREE1:sch 3
scheme BINTREE1:sch 3
{F1 -> non empty with_terminals with_nonterminals with_useful_nonterminals binary DTConstrStr,
  F2 -> non empty set,
  F3 -> Element of F2(),
  F4 -> Element of F2()}:
ex b1 being Function-like quasi_total Relation of TS F1(),F2() st
   (for b2 being Element of Terminals F1() holds
       b1 . root-tree b2 = F3(b2)) &
    (for b2 being Element of NonTerminals F1()
    for b3, b4 being Element of TS F1()
    for b5, b6 being Element of the carrier of F1()
       st b5 = root-label b3 & b6 = root-label b4 & b2 ==> <*b5,b6*>
    for b7, b8 being Element of F2()
          st b7 = b1 . b3 & b8 = b1 . b4
       holds b1 . (b2 -tree(b3,b4)) = F4(b2, b5, b6, b7, b8))


:: BINTREE1:sch 4
scheme BINTREE1:sch 4
{F1 -> non empty with_terminals with_nonterminals with_useful_nonterminals binary DTConstrStr,
  F2 -> non empty set,
  F3 -> Function-like quasi_total Relation of TS F1(),F2(),
  F4 -> Function-like quasi_total Relation of TS F1(),F2(),
  F5 -> Element of F2(),
  F6 -> Element of F2()}:
F3() = F4()
provided
   (for b1 being Element of Terminals F1() holds
       F3() . root-tree b1 = F5(b1)) &
    (for b1 being Element of NonTerminals F1()
    for b2, b3 being Element of TS F1()
    for b4, b5 being Element of the carrier of F1()
       st b4 = root-label b2 & b5 = root-label b3 & b1 ==> <*b4,b5*>
    for b6, b7 being Element of F2()
          st b6 = F3() . b2 & b7 = F3() . b3
       holds F3() . (b1 -tree(b2,b3)) = F6(b1, b4, b5, b6, b7))
and
   (for b1 being Element of Terminals F1() holds
       F4() . root-tree b1 = F5(b1)) &
    (for b1 being Element of NonTerminals F1()
    for b2, b3 being Element of TS F1()
    for b4, b5 being Element of the carrier of F1()
       st b4 = root-label b2 & b5 = root-label b3 & b1 ==> <*b4,b5*>
    for b6, b7 being Element of F2()
          st b6 = F4() . b2 & b7 = F4() . b3
       holds F4() . (b1 -tree(b2,b3)) = F6(b1, b4, b5, b6, b7));


:: BINTREE1:funcnot 3 => BINTREE1:func 3
definition
  let a1, a2, a3 be non empty set;
  let a4 be Element of a1;
  let a5 be Element of a2;
  let a6 be Element of a3;
  redefine func [a4, a5, a6] -> Element of [:a1,a2,a3:];
end;

:: BINTREE1:sch 5
scheme BINTREE1:sch 5
{F1 -> non empty with_terminals with_nonterminals with_useful_nonterminals binary DTConstrStr,
  F2 -> non empty set,
  F3 -> non empty set,
  F4 -> Element of F3(),
  F5 -> Element of F3()}:
ex b1 being Function-like quasi_total Relation of TS F1(),Funcs(F2(),F3()) st
   (for b2 being Element of Terminals F1() holds
       ex b3 being Function-like quasi_total Relation of F2(),F3() st
          b3 = b1 . root-tree b2 &
           (for b4 being Element of F2() holds
              b3 . b4 = F4(b2, b4))) &
    (for b2 being Element of NonTerminals F1()
    for b3, b4 being Element of TS F1()
    for b5, b6 being Element of the carrier of F1()
          st b5 = root-label b3 & b6 = root-label b4 & b2 ==> <*b5,b6*>
       holds ex b7, b8, b9 being Function-like quasi_total Relation of F2(),F3() st
          b7 = b1 . (b2 -tree(b3,b4)) &
           b8 = b1 . b3 &
           b9 = b1 . b4 &
           (for b10 being Element of F2() holds
              b7 . b10 = F5(b2, b8, b9, b10)))


:: BINTREE1:sch 6
scheme BINTREE1:sch 6
{F1 -> non empty with_terminals with_nonterminals with_useful_nonterminals binary DTConstrStr,
  F2 -> non empty set,
  F3 -> non empty set,
  F4 -> Function-like quasi_total Relation of TS F1(),Funcs(F2(),F3()),
  F5 -> Function-like quasi_total Relation of TS F1(),Funcs(F2(),F3()),
  F6 -> Element of F3(),
  F7 -> Element of F3()}:
F4() = F5()
provided
   (for b1 being Element of Terminals F1() holds
       ex b2 being Function-like quasi_total Relation of F2(),F3() st
          b2 = F4() . root-tree b1 &
           (for b3 being Element of F2() holds
              b2 . b3 = F6(b1, b3))) &
    (for b1 being Element of NonTerminals F1()
    for b2, b3 being Element of TS F1()
    for b4, b5 being Element of the carrier of F1()
          st b4 = root-label b2 & b5 = root-label b3 & b1 ==> <*b4,b5*>
       holds ex b6, b7, b8 being Function-like quasi_total Relation of F2(),F3() st
          b6 = F4() . (b1 -tree(b2,b3)) &
           b7 = F4() . b2 &
           b8 = F4() . b3 &
           (for b9 being Element of F2() holds
              b6 . b9 = F7(b1, b7, b8, b9)))
and
   (for b1 being Element of Terminals F1() holds
       ex b2 being Function-like quasi_total Relation of F2(),F3() st
          b2 = F5() . root-tree b1 &
           (for b3 being Element of F2() holds
              b2 . b3 = F6(b1, b3))) &
    (for b1 being Element of NonTerminals F1()
    for b2, b3 being Element of TS F1()
    for b4, b5 being Element of the carrier of F1()
          st b4 = root-label b2 & b5 = root-label b3 & b1 ==> <*b4,b5*>
       holds ex b6, b7, b8 being Function-like quasi_total Relation of F2(),F3() st
          b6 = F5() . (b1 -tree(b2,b3)) &
           b7 = F5() . b2 &
           b8 = F5() . b3 &
           (for b9 being Element of F2() holds
              b6 . b9 = F7(b1, b7, b8, b9)));


:: BINTREE1:condreg 2
registration
  let a1 be non empty with_terminals with_nonterminals binary DTConstrStr;
  cluster -> binary (Element of TS a1);
end;