Article BSPACE, MML version 4.99.1005

:: BSPACE:funcnot 1 => BSPACE:func 1
definition
  let a1 be 1-sorted;
  func <*> A1 -> FinSequence of the carrier of a1 equals
    <*> [#] a1;
end;

:: BSPACE:def 1
theorem
for b1 being 1-sorted holds
   <*> b1 = <*> [#] b1;

:: BSPACE:th 1
theorem
for b1 being 1-sorted
for b2 being Element of NAT
for b3 being FinSequence of the carrier of b1
      st b2 in dom b3
   holds b3 . b2 in b1;

:: BSPACE:th 2
theorem
for b1 being 1-sorted
for b2 being Relation-like Function-like FinSequence-like set
      st for b3 being natural set
              st b3 in dom b2
           holds b2 . b3 in b1
   holds b2 is FinSequence of the carrier of b1;

:: BSPACE:sch 1
scheme BSPACE:sch 1
{F1 -> 1-sorted}:
for b1 being FinSequence of the carrier of F1() holds
   P1[b1]
provided
   P1[<*> F1()]
and
   for b1 being FinSequence of the carrier of F1()
   for b2 being Element of the carrier of F1()
         st P1[b1]
      holds P1[b1 ^ <*b2*>];


:: BSPACE:funcnot 2 => BSPACE:func 2
definition
  func Z_2 -> non empty non degenerated right_complementable almost_left_invertible Abelian add-associative right_zeroed associative commutative well-unital distributive doubleLoopStr equals
    INT.Ring 2;
end;

:: BSPACE:def 2
theorem
Z_2 = INT.Ring 2;

:: BSPACE:th 3
theorem
[#] Z_2 = {{},1};

:: BSPACE:th 4
theorem
for b1 being Element of the carrier of Z_2
      st b1 <> {}
   holds b1 = 1;

:: BSPACE:th 5
theorem
0. Z_2 = {};

:: BSPACE:th 6
theorem
1. Z_2 = 1;

:: BSPACE:th 7
theorem
(1. Z_2) + 1. Z_2 = 0. Z_2;

:: BSPACE:th 8
theorem
for b1 being Element of the carrier of Z_2 holds
      b1 = 0. Z_2
   iff
      b1 <> 1. Z_2;

:: BSPACE:funcnot 3 => BSPACE:func 3
definition
  let a1, a2 be set;
  func A1 @ A2 -> Element of the carrier of Z_2 equals
    1. Z_2
    if a2 in a1
    otherwise 0. Z_2;
end;

:: BSPACE:def 3
theorem
for b1, b2 being set holds
(b2 in b1 implies b1 @ b2 = 1. Z_2) & (b2 in b1 or b1 @ b2 = 0. Z_2);

:: BSPACE:th 9
theorem
for b1, b2 being set holds
   b1 @ b2 = 1. Z_2
iff
   b2 in b1;

:: BSPACE:th 10
theorem
for b1, b2 being set holds
   b1 @ b2 = 0. Z_2
iff
   not b2 in b1;

:: BSPACE:th 11
theorem
for b1, b2 being set holds
   b1 @ b2 <> 0. Z_2
iff
   b1 @ b2 = 1. Z_2;

:: BSPACE:th 12
theorem
for b1, b2, b3 being set holds
   b1 @ b2 = b1 @ b3
iff
      b2 in b1
   iff
      b3 in b1;

:: BSPACE:th 13
theorem
for b1, b2, b3 being set holds
   b1 @ b3 = b2 @ b3
iff
      b3 in b1
   iff
      b3 in b2;

:: BSPACE:th 14
theorem
for b1 being set holds
   {} @ b1 = 0. Z_2;

:: BSPACE:th 15
theorem
for b1 being set
for b2, b3 being Element of bool b1
for b4 being Element of b1 holds
   (b2 \+\ b3) @ b4 = (b2 @ b4) + (b3 @ b4);

:: BSPACE:th 16
theorem
for b1, b2 being set holds
   b1 = b2
iff
   for b3 being set holds
      b1 @ b3 = b2 @ b3;

:: BSPACE:funcnot 4 => BSPACE:func 4
definition
  let a1 be set;
  let a2 be Element of the carrier of Z_2;
  let a3 be Element of bool a1;
  func A2 \*\ A3 -> Element of bool a1 equals
    a3
    if a2 = 1. Z_2
    otherwise   case a2 = 0. Z_2;
    thus {} a1;
  end;
;
end;

:: BSPACE:def 4
theorem
for b1 being set
for b2 being Element of the carrier of Z_2
for b3 being Element of bool b1 holds
   (b2 = 1. Z_2 implies b2 \*\ b3 = b3) &
    (b2 = 0. Z_2 implies b2 \*\ b3 = {} b1);

:: BSPACE:funcnot 5 => BSPACE:func 5
definition
  let a1 be set;
  func bspace-sum A1 -> Function-like quasi_total Relation of [:bool a1,bool a1:],bool a1 means
    for b1, b2 being Element of bool a1 holds
    it .(b1,b2) = b1 \+\ b2;
end;

:: BSPACE:def 5
theorem
for b1 being set
for b2 being Function-like quasi_total Relation of [:bool b1,bool b1:],bool b1 holds
      b2 = bspace-sum b1
   iff
      for b3, b4 being Element of bool b1 holds
      b2 .(b3,b4) = b3 \+\ b4;

:: BSPACE:th 17
theorem
for b1 being set
for b2 being Element of the carrier of Z_2
for b3, b4 being Element of bool b1 holds
b2 \*\ (b3 \+\ b4) = (b2 \*\ b3) \+\ (b2 \*\ b4);

:: BSPACE:th 18
theorem
for b1 being set
for b2, b3 being Element of the carrier of Z_2
for b4 being Element of bool b1 holds
   (b2 + b3) \*\ b4 = (b2 \*\ b4) \+\ (b3 \*\ b4);

:: BSPACE:th 19
theorem
for b1 being set
for b2 being Element of bool b1 holds
   (1. Z_2) \*\ b2 = b2;

:: BSPACE:th 20
theorem
for b1 being set
for b2, b3 being Element of the carrier of Z_2
for b4 being Element of bool b1 holds
   b2 \*\ (b3 \*\ b4) = (b2 * b3) \*\ b4;

:: BSPACE:funcnot 6 => BSPACE:func 6
definition
  let a1 be set;
  func bspace-scalar-mult A1 -> Function-like quasi_total Relation of [:the carrier of Z_2,bool a1:],bool a1 means
    for b1 being Element of the carrier of Z_2
    for b2 being Element of bool a1 holds
       it .(b1,b2) = b1 \*\ b2;
end;

:: BSPACE:def 6
theorem
for b1 being set
for b2 being Function-like quasi_total Relation of [:the carrier of Z_2,bool b1:],bool b1 holds
      b2 = bspace-scalar-mult b1
   iff
      for b3 being Element of the carrier of Z_2
      for b4 being Element of bool b1 holds
         b2 .(b3,b4) = b3 \*\ b4;

:: BSPACE:funcnot 7 => BSPACE:func 7
definition
  let a1 be set;
  func bspace A1 -> non empty VectSpStr over Z_2 equals
    VectSpStr(#bool a1,bspace-sum a1,{} a1,bspace-scalar-mult a1#);
end;

:: BSPACE:def 7
theorem
for b1 being set holds
   bspace b1 = VectSpStr(#bool b1,bspace-sum b1,{} b1,bspace-scalar-mult b1#);

:: BSPACE:th 21
theorem
for b1 being set holds
   bspace b1 is Abelian;

:: BSPACE:th 22
theorem
for b1 being set holds
   bspace b1 is add-associative;

:: BSPACE:th 23
theorem
for b1 being set holds
   bspace b1 is right_zeroed;

:: BSPACE:th 24
theorem
for b1 being set holds
   bspace b1 is right_complementable;

:: BSPACE:th 25
theorem
for b1 being set
for b2 being Element of the carrier of Z_2
for b3, b4 being Element of the carrier of bspace b1 holds
b2 * (b3 + b4) = (b2 * b3) + (b2 * b4);

:: BSPACE:th 26
theorem
for b1 being set
for b2, b3 being Element of the carrier of Z_2
for b4 being Element of the carrier of bspace b1 holds
   (b2 + b3) * b4 = (b2 * b4) + (b3 * b4);

:: BSPACE:th 27
theorem
for b1 being set
for b2, b3 being Element of the carrier of Z_2
for b4 being Element of the carrier of bspace b1 holds
   (b2 * b3) * b4 = b2 * (b3 * b4);

:: BSPACE:th 28
theorem
for b1 being set
for b2 being Element of the carrier of bspace b1 holds
   (1_ Z_2) * b2 = b2;

:: BSPACE:th 29
theorem
for b1 being set holds
   bspace b1 is VectSp-like(Z_2);

:: BSPACE:funcreg 1
registration
  let a1 be set;
  cluster bspace a1 -> non empty right_complementable Abelian add-associative right_zeroed VectSp-like;
end;

:: BSPACE:attrnot 1 => BSPACE:attr 1
definition
  let a1 be set;
  attr a1 is Singleton means
    a1 is not empty & a1 is trivial;
end;

:: BSPACE:dfs 8
definiens
  let a1 be set;
To prove
     a1 is Singleton
it is sufficient to prove
  thus a1 is not empty & a1 is trivial;

:: BSPACE:def 8
theorem
for b1 being set holds
      b1 is Singleton
   iff
      b1 is not empty & b1 is trivial;

:: BSPACE:condreg 1
registration
  cluster Singleton -> non empty trivial (set);
end;

:: BSPACE:condreg 2
registration
  cluster non empty trivial -> Singleton (set);
end;

:: BSPACE:attrnot 2 => BSPACE:attr 2
definition
  let a1 be set;
  let a2 be Element of bool a1;
  redefine attr a2 is Singleton means
    ex b1 being set st
       b1 in a1 & a2 = {b1};
end;

:: BSPACE:dfs 9
definiens
  let a1 be set;
  let a2 be Element of bool a1;
To prove
     a1 is Singleton
it is sufficient to prove
  thus ex b1 being set st
       b1 in a1 & a2 = {b1};

:: BSPACE:def 9
theorem
for b1 being set
for b2 being Element of bool b1 holds
      b2 is Singleton
   iff
      ex b3 being set st
         b3 in b1 & b2 = {b3};

:: BSPACE:funcnot 8 => BSPACE:func 8
definition
  let a1 be set;
  func singletons A1 -> set equals
    {b1 where b1 is Element of bool a1: b1 is Singleton};
end;

:: BSPACE:def 10
theorem
for b1 being set holds
   singletons b1 = {b2 where b2 is Element of bool b1: b2 is Singleton};

:: BSPACE:funcnot 9 => BSPACE:func 9
definition
  let a1 be set;
  redefine func singletons a1 -> Element of bool the carrier of bspace a1;
end;

:: BSPACE:funcreg 2
registration
  let a1 be non empty set;
  cluster singletons a1 -> non empty;
end;

:: BSPACE:th 30
theorem
for b1 being non empty set
for b2 being Element of bool b1
      st b2 is Element of singletons b1
   holds b2 is Singleton;

:: BSPACE:funcnot 10 => BSPACE:func 10
definition
  let a1 be non empty non degenerated right_complementable almost_left_invertible Abelian add-associative right_zeroed associative commutative well-unital distributive doubleLoopStr;
  let a2 be non empty right_complementable Abelian add-associative right_zeroed VectSp-like VectSpStr over a1;
  let a3 be Linear_Combination of a2;
  let a4 be Element of the carrier of a2;
  redefine func a3 . a4 -> Element of the carrier of a1;
end;

:: BSPACE:funcnot 11 => BSPACE:func 11
definition
  let a1 be non empty set;
  let a2 be FinSequence of the carrier of bspace a1;
  let a3 be Element of a1;
  func A2 @ A3 -> FinSequence of the carrier of Z_2 means
    len it = len a2 &
     (for b1 being natural set
           st 1 <= b1 & b1 <= len a2
        holds it . b1 = (a2 . b1) @ a3);
end;

:: BSPACE:def 11
theorem
for b1 being non empty set
for b2 being FinSequence of the carrier of bspace b1
for b3 being Element of b1
for b4 being FinSequence of the carrier of Z_2 holds
      b4 = b2 @ b3
   iff
      len b4 = len b2 &
       (for b5 being natural set
             st 1 <= b5 & b5 <= len b2
          holds b4 . b5 = (b2 . b5) @ b3);

:: BSPACE:th 31
theorem
for b1 being non empty set
for b2 being Element of b1 holds
   (<*> bspace b1) @ b2 = <*> Z_2;

:: BSPACE:th 32
theorem
for b1 being set
for b2, b3 being Element of the carrier of bspace b1
for b4 being Element of b1 holds
   (b2 + b3) @ b4 = (b2 @ b4) + (b3 @ b4);

:: BSPACE:th 33
theorem
for b1 being non empty set
for b2 being FinSequence of the carrier of bspace b1
for b3 being Element of the carrier of bspace b1
for b4 being Element of b1 holds
   (b2 ^ <*b3*>) @ b4 = (b2 @ b4) ^ <*b3 @ b4*>;

:: BSPACE:th 34
theorem
for b1 being non empty set
for b2 being FinSequence of the carrier of bspace b1
for b3 being Element of b1 holds
   (Sum b2) @ b3 = Sum (b2 @ b3);

:: BSPACE:th 35
theorem
for b1 being non empty set
for b2 being Linear_Combination of bspace b1
for b3 being Element of the carrier of bspace b1
      st b3 in Carrier b2
   holds b2 . b3 = 1_ Z_2;

:: BSPACE:th 36
theorem
singletons {} = {};

:: BSPACE:th 37
theorem
for b1 being set holds
   singletons b1 is linearly-independent(Z_2, bspace b1);

:: BSPACE:th 38
theorem
for b1 being set
for b2 being Element of the carrier of bspace b1
      st ex b3 being set st
           b3 in b1 & b2 = {b3}
   holds b2 in singletons b1;

:: BSPACE:th 39
theorem
for b1 being finite set
for b2 being Element of bool b1 holds
   ex b3 being Linear_Combination of singletons b1 st
      Sum b3 = b2;

:: BSPACE:th 40
theorem
for b1 being finite set holds
   Lin singletons b1 = bspace b1;

:: BSPACE:th 41
theorem
for b1 being finite set holds
   singletons b1 is Basis of bspace b1;

:: BSPACE:funcreg 3
registration
  let a1 be finite set;
  cluster singletons a1 -> finite;
end;

:: BSPACE:funcreg 4
registration
  let a1 be finite set;
  cluster bspace a1 -> non empty finite-dimensional;
end;

:: BSPACE:th 42
theorem
for b1 being set holds
   Card singletons b1 = Card b1;

:: BSPACE:th 43
theorem
for b1 being set holds
   Card [#] bspace b1 = exp(2,Card b1);

:: BSPACE:th 44
theorem
dim bspace {} = {};