Article LFUZZY_0, MML version 4.99.1005

:: LFUZZY_0:attrnot 1 => LFUZZY_0:attr 1
definition
  let a1 be RelStr;
  attr a1 is real means
    the carrier of a1 c= REAL &
     (for b1, b2 being real set
           st b1 in the carrier of a1 & b2 in the carrier of a1
        holds    [b1,b2] in the InternalRel of a1
        iff
           b1 <= b2);
end;

:: LFUZZY_0:dfs 1
definiens
  let a1 be RelStr;
To prove
     a1 is real
it is sufficient to prove
  thus the carrier of a1 c= REAL &
     (for b1, b2 being real set
           st b1 in the carrier of a1 & b2 in the carrier of a1
        holds    [b1,b2] in the InternalRel of a1
        iff
           b1 <= b2);

:: LFUZZY_0:def 1
theorem
for b1 being RelStr holds
      b1 is real
   iff
      the carrier of b1 c= REAL &
       (for b2, b3 being real set
             st b2 in the carrier of b1 & b3 in the carrier of b1
          holds    [b2,b3] in the InternalRel of b1
          iff
             b2 <= b3);

:: LFUZZY_0:attrnot 2 => LFUZZY_0:attr 2
definition
  let a1 be RelStr;
  attr a1 is interval means
    a1 is real &
     (ex b1, b2 being real set st
        b1 <= b2 & the carrier of a1 = [.b1,b2.]);
end;

:: LFUZZY_0:dfs 2
definiens
  let a1 be RelStr;
To prove
     a1 is interval
it is sufficient to prove
  thus a1 is real &
     (ex b1, b2 being real set st
        b1 <= b2 & the carrier of a1 = [.b1,b2.]);

:: LFUZZY_0:def 2
theorem
for b1 being RelStr holds
      b1 is interval
   iff
      b1 is real &
       (ex b2, b3 being real set st
          b2 <= b3 & the carrier of b1 = [.b2,b3.]);

:: LFUZZY_0:condreg 1
registration
  cluster interval -> non empty real (RelStr);
end;

:: LFUZZY_0:condreg 2
registration
  cluster empty -> real (RelStr);
end;

:: LFUZZY_0:th 1
theorem
for b1 being Element of bool REAL holds
   ex b2 being strict RelStr st
      the carrier of b2 = b1 & b2 is real;

:: LFUZZY_0:exreg 1
registration
  cluster strict interval RelStr;
end;

:: LFUZZY_0:th 2
theorem
for b1, b2 being real RelStr
      st the carrier of b1 = the carrier of b2
   holds RelStr(#the carrier of b1,the InternalRel of b1#) = RelStr(#the carrier of b2,the InternalRel of b2#);

:: LFUZZY_0:condreg 3
registration
  let a1 be non empty real RelStr;
  cluster -> real (Element of the carrier of a1);
end;

:: LFUZZY_0:funcnot 1 => LFUZZY_0:func 1
definition
  let a1 be Element of bool REAL;
  func RealPoset A1 -> strict real RelStr means
    the carrier of it = a1;
end;

:: LFUZZY_0:def 3
theorem
for b1 being Element of bool REAL
for b2 being strict real RelStr holds
      b2 = RealPoset b1
   iff
      the carrier of b2 = b1;

:: LFUZZY_0:funcreg 1
registration
  let a1 be non empty Element of bool REAL;
  cluster RealPoset a1 -> non empty strict real;
end;

:: LFUZZY_0:prednot 1 => ORDERS_2:pred 1
notation
  let a1 be RelStr;
  let a2, a3 be Element of the carrier of a1;
  synonym a2 <<= a3 for a2 <= a3;
end;

:: LFUZZY_0:prednot 2 => ORDERS_2:pred 1
notation
  let a1 be RelStr;
  let a2, a3 be Element of the carrier of a1;
  synonym a3 >>= a2 for a2 <= a3;
end;

:: LFUZZY_0:prednot 3 => not ORDERS_2:pred 1
notation
  let a1 be RelStr;
  let a2, a3 be Element of the carrier of a1;
  antonym a2 ~<= a3 for a2 <= a3;
end;

:: LFUZZY_0:prednot 4 => not ORDERS_2:pred 1
notation
  let a1 be RelStr;
  let a2, a3 be Element of the carrier of a1;
  antonym a3 ~>= a2 for a2 <= a3;
end;

:: LFUZZY_0:th 3
theorem
for b1 being non empty real RelStr
for b2, b3 being Element of the carrier of b1 holds
   b2 <= b3
iff
   b2 <= b3;

:: LFUZZY_0:condreg 4
registration
  cluster real -> reflexive transitive antisymmetric (RelStr);
end;

:: LFUZZY_0:condreg 5
registration
  cluster non empty real -> connected (RelStr);
end;

:: LFUZZY_0:funcnot 2 => LFUZZY_0:func 2
definition
  let a1 be non empty real RelStr;
  let a2, a3 be Element of the carrier of a1;
  redefine func max(a2,a3) -> Element of the carrier of a1;
  commutativity;
::  for a1 being non empty real RelStr
::  for a2, a3 being Element of the carrier of a1 holds
::  max(a2,a3) = max(a3,a2);
  idempotence;
::  for a1 being non empty real RelStr
::  for a2 being Element of the carrier of a1 holds
::     max(a2,a2) = a2;
end;

:: LFUZZY_0:funcnot 3 => LFUZZY_0:func 3
definition
  let a1 be non empty real RelStr;
  let a2, a3 be Element of the carrier of a1;
  redefine func min(a2,a3) -> Element of the carrier of a1;
  commutativity;
::  for a1 being non empty real RelStr
::  for a2, a3 being Element of the carrier of a1 holds
::  min(a2,a3) = min(a3,a2);
  idempotence;
::  for a1 being non empty real RelStr
::  for a2 being Element of the carrier of a1 holds
::     min(a2,a2) = a2;
end;

:: LFUZZY_0:condreg 6
registration
  cluster non empty real -> with_suprema with_infima (RelStr);
end;

:: LFUZZY_0:th 4
theorem
for b1 being non empty real RelStr
for b2, b3 being Element of the carrier of b1 holds
b2 "\/" b3 = max(b2,b3);

:: LFUZZY_0:th 5
theorem
for b1 being non empty real RelStr
for b2, b3 being Element of the carrier of b1 holds
b2 "/\" b3 = min(b2,b3);

:: LFUZZY_0:th 6
theorem
for b1 being non empty real RelStr holds
      ex b2 being real set st
         b2 in the carrier of b1 &
          (for b3 being real set
                st b3 in the carrier of b1
             holds b2 <= b3)
   iff
      b1 is lower-bounded;

:: LFUZZY_0:th 7
theorem
for b1 being non empty real RelStr holds
      ex b2 being real set st
         b2 in the carrier of b1 &
          (for b3 being real set
                st b3 in the carrier of b1
             holds b3 <= b2)
   iff
      b1 is upper-bounded;

:: LFUZZY_0:condreg 7
registration
  cluster non empty interval -> bounded (RelStr);
end;

:: LFUZZY_0:th 8
theorem
for b1 being non empty interval RelStr
for b2 being set holds
   ex_sup_of b2,b1;

:: LFUZZY_0:condreg 8
registration
  cluster non empty interval -> complete (RelStr);
end;

:: LFUZZY_0:condreg 9
registration
  cluster non empty reflexive transitive antisymmetric connected -> distributive (RelStr);
end;

:: LFUZZY_0:condreg 10
registration
  cluster non empty interval -> Heyting (RelStr);
end;

:: LFUZZY_0:funcreg 2
registration
  cluster [.0,1.] -> non empty;
end;

:: LFUZZY_0:funcreg 3
registration
  cluster RealPoset [.0,1.] -> strict real interval;
end;

:: LFUZZY_0:th 9
theorem
for b1 being non empty set
for b2 being RelStr-yielding non-Empty reflexive-yielding ManySortedSet of b1
      st for b3 being Element of b1 holds
           b2 . b3 is reflexive transitive antisymmetric with_suprema RelStr
   holds product b2 is with_suprema;

:: LFUZZY_0:th 10
theorem
for b1 being non empty set
for b2 being RelStr-yielding non-Empty reflexive-yielding ManySortedSet of b1
      st for b3 being Element of b1 holds
           b2 . b3 is reflexive transitive antisymmetric with_infima RelStr
   holds product b2 is with_infima;

:: LFUZZY_0:th 11
theorem
for b1 being non empty set
for b2 being RelStr-yielding non-Empty reflexive-yielding ManySortedSet of b1
   st for b3 being Element of b1 holds
        b2 . b3 is reflexive transitive antisymmetric with_infima RelStr
for b3, b4 being Element of the carrier of product b2
for b5 being Element of b1 holds
   (b3 "/\" b4) . b5 = (b3 . b5) "/\" (b4 . b5);

:: LFUZZY_0:th 12
theorem
for b1 being non empty set
for b2 being RelStr-yielding non-Empty reflexive-yielding ManySortedSet of b1
   st for b3 being Element of b1 holds
        b2 . b3 is reflexive transitive antisymmetric with_suprema RelStr
for b3, b4 being Element of the carrier of product b2
for b5 being Element of b1 holds
   (b3 "\/" b4) . b5 = (b3 . b5) "\/" (b4 . b5);

:: LFUZZY_0:th 13
theorem
for b1 being non empty set
for b2 being RelStr-yielding non-Empty reflexive-yielding ManySortedSet of b1
      st for b3 being Element of b1 holds
           b2 . b3 is reflexive transitive antisymmetric with_suprema with_infima complete Heyting RelStr
   holds product b2 is complete & product b2 is Heyting;

:: LFUZZY_0:funcreg 4
registration
  let a1 be non empty set;
  let a2 be reflexive transitive antisymmetric with_suprema with_infima complete Heyting RelStr;
  cluster a2 |^ a1 -> strict Heyting;
end;

:: LFUZZY_0:funcnot 4 => LFUZZY_0:func 4
definition
  let a1 be non empty set;
  func FuzzyLattice A1 -> reflexive transitive antisymmetric with_suprema with_infima complete Heyting RelStr equals
    (RealPoset [.0,1.]) |^ a1;
end;

:: LFUZZY_0:def 4
theorem
for b1 being non empty set holds
   FuzzyLattice b1 = (RealPoset [.0,1.]) |^ b1;

:: LFUZZY_0:th 14
theorem
for b1 being non empty set holds
   the carrier of FuzzyLattice b1 = Funcs(b1,[.0,1.]);

:: LFUZZY_0:funcreg 5
registration
  let a1 be non empty set;
  cluster FuzzyLattice a1 -> reflexive transitive antisymmetric with_suprema with_infima complete constituted-Functions Heyting;
end;

:: LFUZZY_0:th 15
theorem
for b1 being reflexive transitive antisymmetric with_suprema with_infima complete Heyting RelStr
for b2 being Element of bool the carrier of b1
for b3 being Element of the carrier of b1 holds
   ("\/"(b2,b1)) "/\" b3 = "\/"({b4 "/\" b3 where b4 is Element of the carrier of b1: b4 in b2},b1);

:: LFUZZY_0:funcnot 5 => LFUZZY_0:func 5
definition
  let a1 be non empty set;
  let a2 be Element of the carrier of FuzzyLattice a1;
  func @ A2 -> Membership_Func of a1 equals
    a2;
end;

:: LFUZZY_0:def 5
theorem
for b1 being non empty set
for b2 being Element of the carrier of FuzzyLattice b1 holds
   @ b2 = b2;

:: LFUZZY_0:funcnot 6 => LFUZZY_0:func 6
definition
  let a1 be non empty set;
  let a2 be Membership_Func of a1;
  func (A1,A2)@ -> Element of the carrier of FuzzyLattice a1 equals
    a2;
end;

:: LFUZZY_0:def 6
theorem
for b1 being non empty set
for b2 being Membership_Func of b1 holds
   (b1,b2)@ = b2;

:: LFUZZY_0:funcnot 7 => LFUZZY_0:func 7
definition
  let a1 be non empty set;
  let a2 be Membership_Func of a1;
  let a3 be Element of a1;
  redefine func a2 . a3 -> Element of the carrier of RealPoset [.0,1.];
end;

:: LFUZZY_0:funcnot 8 => LFUZZY_0:func 8
definition
  let a1, a2 be non empty set;
  let a3 be Membership_Func of [:a1,a2:];
  let a4 be Element of a1;
  let a5 be Element of a2;
  redefine func a3 .(a4,a5) -> Element of the carrier of RealPoset [.0,1.];
end;

:: LFUZZY_0:funcnot 9 => LFUZZY_0:func 9
definition
  let a1 be non empty set;
  let a2 be Element of the carrier of FuzzyLattice a1;
  let a3 be Element of a1;
  redefine func a2 . a3 -> Element of the carrier of RealPoset [.0,1.];
end;

:: LFUZZY_0:th 16
theorem
for b1 being non empty set
for b2, b3 being Membership_Func of b1 holds
   for b4 being Element of b1 holds
      b2 . b4 <= b3 . b4
iff
   (b1,b2)@ <= (b1,b3)@;

:: LFUZZY_0:th 17
theorem
for b1 being non empty set
for b2, b3 being Element of the carrier of FuzzyLattice b1 holds
   b2 <= b3
iff
   for b4 being Element of b1 holds
      (@ b2) . b4 <= (@ b3) . b4;

:: LFUZZY_0:th 18
theorem
for b1 being non empty set
for b2, b3 being Membership_Func of b1 holds
max(b2,b3) = (b1,b2)@ "\/" ((b1,b3)@);

:: LFUZZY_0:th 19
theorem
for b1 being non empty set
for b2, b3 being Element of the carrier of FuzzyLattice b1 holds
b2 "\/" b3 = max(@ b2,@ b3);

:: LFUZZY_0:th 20
theorem
for b1 being non empty set
for b2, b3 being Membership_Func of b1 holds
min(b2,b3) = (b1,b2)@ "/\" ((b1,b3)@);

:: LFUZZY_0:th 21
theorem
for b1 being non empty set
for b2, b3 being Element of the carrier of FuzzyLattice b1 holds
b2 "/\" b3 = min(@ b2,@ b3);

:: LFUZZY_0:sch 1
scheme LFUZZY_0:sch 1
{F1 -> reflexive transitive antisymmetric with_suprema with_infima complete RelStr,
  F2 -> non empty set,
  F3 -> non empty set,
  F4 -> Element of the carrier of F1()}:
"\/"({"\/"({F4(b1, b2) where b2 is Element of F3(): P2[b2]},F1()) where b1 is Element of F2(): P1[b1]},F1()) = "\/"({F4(b1, b2) where b1 is Element of F2(), b2 is Element of F3(): P1[b1] & P2[b2]},F1())


:: LFUZZY_0:sch 2
scheme LFUZZY_0:sch 2
{F1 -> reflexive transitive antisymmetric with_suprema with_infima complete RelStr,
  F2 -> non empty set,
  F3 -> non empty set,
  F4 -> Element of the carrier of F1()}:
"\/"({"\/"({F4(b2, b1) where b2 is Element of F2(): P1[b2]},F1()) where b1 is Element of F3(): P2[b1]},F1()) = "\/"({F4(b1, b2) where b1 is Element of F2(), b2 is Element of F3(): P1[b1] & P2[b2]},F1())


:: LFUZZY_0:sch 3
scheme LFUZZY_0:sch 3
{F1 -> non empty set,
  F2 -> non empty set,
  F3 -> set,
  F4 -> set}:
{F3(b1, b2) where b1 is Element of F1(), b2 is Element of F2(): P1[b1, b2]} = {F4(b1, b2) where b1 is Element of F1(), b2 is Element of F2(): P1[b1, b2]}
provided
   for b1 being Element of F1()
   for b2 being Element of F2()
         st P1[b1, b2]
      holds F3(b1, b2) = F4(b1, b2);


:: LFUZZY_0:sch 4
scheme LFUZZY_0:sch 4
{F1 -> non empty set,
  F2 -> non empty set,
  F3 -> set,
  F4 -> set}:
{F3(b1, b2) where b1 is Element of F1(), b2 is Element of F2(): P1[b1, b2]} = {F4(b1, b2) where b1 is Element of F1(), b2 is Element of F2(): P2[b1, b2]}
provided
   for b1 being Element of F1()
   for b2 being Element of F2() holds
         P1[b1, b2]
      iff
         P2[b1, b2]
and
   for b1 being Element of F1()
   for b2 being Element of F2()
         st P1[b1, b2]
      holds F3(b1, b2) = F4(b1, b2);


:: LFUZZY_0:sch 5
scheme LFUZZY_0:sch 5
{F1 -> reflexive transitive antisymmetric with_suprema with_infima complete RelStr,
  F2 -> non empty set,
  F3 -> non empty set,
  F4 -> Element of the carrier of F1(),
  F5 -> Element of the carrier of F1()}:
"\/"({"\/"({F4(b1, b2) where b2 is Element of F3(): P2[b2]},F1()) where b1 is Element of F2(): P1[b1]},F1()) = "\/"({"\/"({F5(b2, b1) where b2 is Element of F2(): P1[b2]},F1()) where b1 is Element of F3(): P2[b1]},F1())
provided
   for b1 being Element of F2()
   for b2 being Element of F3()
         st P1[b1] & P2[b2]
      holds F4(b1, b2) = F5(b1, b2);


:: LFUZZY_0:th 22
theorem
for b1, b2, b3 being non empty set
for b4 being Membership_Func of [:b1,b2:]
for b5 being Membership_Func of [:b2,b3:]
for b6 being Element of b1
for b7 being Element of b3 holds
   (b4 (#) b5) .(b6,b7) = "\/"({(b4 .(b6,b8)) "/\" (b5 .(b8,b7)) where b8 is Element of b2: TRUE},RealPoset [.0,1.]);

:: LFUZZY_0:th 23
theorem
for b1, b2, b3, b4 being non empty set
for b5 being Membership_Func of [:b1,b2:]
for b6 being Membership_Func of [:b2,b3:]
for b7 being Membership_Func of [:b3,b4:] holds
   (b5 (#) b6) (#) b7 = b5 (#) (b6 (#) b7);