Article QUANTAL1, MML version 4.99.1005

:: QUANTAL1:sch 1
scheme QUANTAL1:sch 1
{F1 -> non empty set,
  F2 -> non empty set,
  F3 -> set,
  F4 -> Element of F2()}:
{F3(b1) where b1 is Element of F2(): b1 in {F4(b2) where b2 is Element of F1(): P1[b2]}} = {F3(F4(b1)) where b1 is Element of F1(): P1[b1]}


:: QUANTAL1:sch 2
scheme QUANTAL1:sch 2
{F1 -> non empty set,
  F2 -> set}:
{F2(b1) where b1 is Element of F1(): P1[b1]} = {}
provided
   for b1 being Element of F1() holds
      not (P1[b1]);


:: QUANTAL1:th 1
theorem
for b1, b2 being non empty LattStr
   st LattStr(#the carrier of b1,the L_join of b1,the L_meet of b1#) = LattStr(#the carrier of b2,the L_join of b2,the L_meet of b2#)
for b3, b4 being Element of the carrier of b1
for b5, b6 being Element of the carrier of b2
      st b3 = b5 & b4 = b6
   holds b3 "\/" b4 = b5 "\/" b6 & b3 "/\" b4 = b5 "/\" b6 & (b3 [= b4 implies b5 [= b6) & (b5 [= b6 implies b3 [= b4);

:: QUANTAL1:th 2
theorem
for b1, b2 being non empty LattStr
   st LattStr(#the carrier of b1,the L_join of b1,the L_meet of b1#) = LattStr(#the carrier of b2,the L_join of b2,the L_meet of b2#)
for b3 being Element of the carrier of b1
for b4 being Element of the carrier of b2
for b5 being set
      st b3 = b4
   holds (b3 is_less_than b5 implies b4 is_less_than b5) & (b4 is_less_than b5 implies b3 is_less_than b5) & (b5 is_less_than b3 implies b5 is_less_than b4) & (b5 is_less_than b4 implies b5 is_less_than b3);

:: QUANTAL1:modenot 1
definition
  let a1 be 1-sorted;
  mode UnOp of a1 is Function-like quasi_total Relation of the carrier of a1,the carrier of a1;
end;

:: QUANTAL1:attrnot 1 => QUANTAL1:attr 1
definition
  let a1 be non empty LattStr;
  let a2 be Element of bool the carrier of a1;
  attr a2 is directed means
    for b1 being finite Element of bool a2 holds
       ex b2 being Element of the carrier of a1 st
          "\/"(b1,a1) [= b2 & b2 in a2;
end;

:: QUANTAL1:dfs 1
definiens
  let a1 be non empty LattStr;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is directed
it is sufficient to prove
  thus for b1 being finite Element of bool a2 holds
       ex b2 being Element of the carrier of a1 st
          "\/"(b1,a1) [= b2 & b2 in a2;

:: QUANTAL1:def 1
theorem
for b1 being non empty LattStr
for b2 being Element of bool the carrier of b1 holds
      b2 is directed(b1)
   iff
      for b3 being finite Element of bool b2 holds
         ex b4 being Element of the carrier of b1 st
            "\/"(b3,b1) [= b4 & b4 in b2;

:: QUANTAL1:th 3
theorem
for b1 being non empty LattStr
for b2 being Element of bool the carrier of b1
      st b2 is directed(b1)
   holds b2 is not empty;

:: QUANTAL1:structnot 1 => QUANTAL1:struct 1
definition
  struct(LattStrmultMagma) QuantaleStr(#
    carrier -> set,
    L_join -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    L_meet -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    multF -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it
  #);
end;

:: QUANTAL1:attrnot 2 => QUANTAL1:attr 2
definition
  let a1 be QuantaleStr;
  attr a1 is strict;
end;

:: QUANTAL1:exreg 1
registration
  cluster strict QuantaleStr;
end;

:: QUANTAL1:aggrnot 1 => QUANTAL1:aggr 1
definition
  let a1 be set;
  let a2, a3, a4 be Function-like quasi_total Relation of [:a1,a1:],a1;
  aggr QuantaleStr(#a1,a2,a3,a4#) -> strict QuantaleStr;
end;

:: QUANTAL1:exreg 2
registration
  cluster non empty QuantaleStr;
end;

:: QUANTAL1:structnot 2 => QUANTAL1:struct 2
definition
  struct(QuantaleStrmultLoopStr) QuasiNetStr(#
    carrier -> set,
    L_join -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    L_meet -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    multF -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    OneF -> Element of the carrier of it
  #);
end;

:: QUANTAL1:attrnot 3 => QUANTAL1:attr 3
definition
  let a1 be QuasiNetStr;
  attr a1 is strict;
end;

:: QUANTAL1:exreg 3
registration
  cluster strict QuasiNetStr;
end;

:: QUANTAL1:aggrnot 2 => QUANTAL1:aggr 2
definition
  let a1 be set;
  let a2, a3, a4 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a5 be Element of a1;
  aggr QuasiNetStr(#a1,a2,a3,a4,a5#) -> strict QuasiNetStr;
end;

:: QUANTAL1:exreg 4
registration
  cluster non empty QuasiNetStr;
end;

:: QUANTAL1:attrnot 4 => QUANTAL1:attr 4
definition
  let a1 be non empty multMagma;
  attr a1 is with_left-zero means
    ex b1 being Element of the carrier of a1 st
       for b2 being Element of the carrier of a1 holds
          b1 * b2 = b1;
end;

:: QUANTAL1:dfs 2
definiens
  let a1 be non empty multMagma;
To prove
     a1 is with_left-zero
it is sufficient to prove
  thus ex b1 being Element of the carrier of a1 st
       for b2 being Element of the carrier of a1 holds
          b1 * b2 = b1;

:: QUANTAL1:def 2
theorem
for b1 being non empty multMagma holds
      b1 is with_left-zero
   iff
      ex b2 being Element of the carrier of b1 st
         for b3 being Element of the carrier of b1 holds
            b2 * b3 = b2;

:: QUANTAL1:attrnot 5 => QUANTAL1:attr 5
definition
  let a1 be non empty multMagma;
  attr a1 is with_right-zero means
    ex b1 being Element of the carrier of a1 st
       for b2 being Element of the carrier of a1 holds
          b2 * b1 = b1;
end;

:: QUANTAL1:dfs 3
definiens
  let a1 be non empty multMagma;
To prove
     a1 is with_right-zero
it is sufficient to prove
  thus ex b1 being Element of the carrier of a1 st
       for b2 being Element of the carrier of a1 holds
          b2 * b1 = b1;

:: QUANTAL1:def 3
theorem
for b1 being non empty multMagma holds
      b1 is with_right-zero
   iff
      ex b2 being Element of the carrier of b1 st
         for b3 being Element of the carrier of b1 holds
            b3 * b2 = b2;

:: QUANTAL1:attrnot 6 => QUANTAL1:attr 6
definition
  let a1 be non empty multMagma;
  attr a1 is with_zero means
    a1 is with_left-zero & a1 is with_right-zero;
end;

:: QUANTAL1:dfs 4
definiens
  let a1 be non empty multMagma;
To prove
     a1 is with_zero
it is sufficient to prove
  thus a1 is with_left-zero & a1 is with_right-zero;

:: QUANTAL1:def 4
theorem
for b1 being non empty multMagma holds
      b1 is with_zero
   iff
      b1 is with_left-zero & b1 is with_right-zero;

:: QUANTAL1:condreg 1
registration
  cluster non empty with_zero -> with_left-zero with_right-zero (multMagma);
end;

:: QUANTAL1:condreg 2
registration
  cluster non empty with_left-zero with_right-zero -> with_zero (multMagma);
end;

:: QUANTAL1:exreg 5
registration
  cluster non empty with_zero multMagma;
end;

:: QUANTAL1:attrnot 7 => QUANTAL1:attr 7
definition
  let a1 be non empty QuantaleStr;
  attr a1 is right-distributive means
    for b1 being Element of the carrier of a1
    for b2 being set holds
       b1 * "\/"(b2,a1) = "\/"({b1 * b3 where b3 is Element of the carrier of a1: b3 in b2},a1);
end;

:: QUANTAL1:dfs 5
definiens
  let a1 be non empty QuantaleStr;
To prove
     a1 is right-distributive
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
    for b2 being set holds
       b1 * "\/"(b2,a1) = "\/"({b1 * b3 where b3 is Element of the carrier of a1: b3 in b2},a1);

:: QUANTAL1:def 5
theorem
for b1 being non empty QuantaleStr holds
      b1 is right-distributive
   iff
      for b2 being Element of the carrier of b1
      for b3 being set holds
         b2 * "\/"(b3,b1) = "\/"({b2 * b4 where b4 is Element of the carrier of b1: b4 in b3},b1);

:: QUANTAL1:attrnot 8 => QUANTAL1:attr 8
definition
  let a1 be non empty QuantaleStr;
  attr a1 is left-distributive means
    for b1 being Element of the carrier of a1
    for b2 being set holds
       ("\/"(b2,a1)) * b1 = "\/"({b3 * b1 where b3 is Element of the carrier of a1: b3 in b2},a1);
end;

:: QUANTAL1:dfs 6
definiens
  let a1 be non empty QuantaleStr;
To prove
     a1 is left-distributive
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
    for b2 being set holds
       ("\/"(b2,a1)) * b1 = "\/"({b3 * b1 where b3 is Element of the carrier of a1: b3 in b2},a1);

:: QUANTAL1:def 6
theorem
for b1 being non empty QuantaleStr holds
      b1 is left-distributive
   iff
      for b2 being Element of the carrier of b1
      for b3 being set holds
         ("\/"(b3,b1)) * b2 = "\/"({b4 * b2 where b4 is Element of the carrier of b1: b4 in b3},b1);

:: QUANTAL1:attrnot 9 => QUANTAL1:attr 9
definition
  let a1 be non empty QuantaleStr;
  attr a1 is times-additive means
    for b1, b2, b3 being Element of the carrier of a1 holds
    (b1 "\/" b2) * b3 = (b1 * b3) "\/" (b2 * b3) &
     b3 * (b1 "\/" b2) = (b3 * b1) "\/" (b3 * b2);
end;

:: QUANTAL1:dfs 7
definiens
  let a1 be non empty QuantaleStr;
To prove
     a1 is times-additive
it is sufficient to prove
  thus for b1, b2, b3 being Element of the carrier of a1 holds
    (b1 "\/" b2) * b3 = (b1 * b3) "\/" (b2 * b3) &
     b3 * (b1 "\/" b2) = (b3 * b1) "\/" (b3 * b2);

:: QUANTAL1:def 7
theorem
for b1 being non empty QuantaleStr holds
      b1 is times-additive
   iff
      for b2, b3, b4 being Element of the carrier of b1 holds
      (b2 "\/" b3) * b4 = (b2 * b4) "\/" (b3 * b4) &
       b4 * (b2 "\/" b3) = (b4 * b2) "\/" (b4 * b3);

:: QUANTAL1:attrnot 10 => QUANTAL1:attr 10
definition
  let a1 be non empty QuantaleStr;
  attr a1 is times-continuous means
    for b1, b2 being Element of bool the carrier of a1
          st b1 is directed(a1) & b2 is directed(a1)
       holds ("\/"(b1,a1)) * "\/"(b2,a1) = "\/"({b3 * b4 where b3 is Element of the carrier of a1, b4 is Element of the carrier of a1: b3 in b1 & b4 in b2},a1);
end;

:: QUANTAL1:dfs 8
definiens
  let a1 be non empty QuantaleStr;
To prove
     a1 is times-continuous
it is sufficient to prove
  thus for b1, b2 being Element of bool the carrier of a1
          st b1 is directed(a1) & b2 is directed(a1)
       holds ("\/"(b1,a1)) * "\/"(b2,a1) = "\/"({b3 * b4 where b3 is Element of the carrier of a1, b4 is Element of the carrier of a1: b3 in b1 & b4 in b2},a1);

:: QUANTAL1:def 8
theorem
for b1 being non empty QuantaleStr holds
      b1 is times-continuous
   iff
      for b2, b3 being Element of bool the carrier of b1
            st b2 is directed(b1) & b3 is directed(b1)
         holds ("\/"(b2,b1)) * "\/"(b3,b1) = "\/"({b4 * b5 where b4 is Element of the carrier of b1, b5 is Element of the carrier of b1: b4 in b2 & b5 in b3},b1);

:: QUANTAL1:th 4
theorem
for b1 being non empty QuantaleStr
      st LattStr(#the carrier of b1,the L_join of b1,the L_meet of b1#) = BooleLatt {}
   holds b1 is associative & b1 is commutative & b1 is unital & b1 is with_zero & b1 is complete & b1 is right-distributive & b1 is left-distributive & b1 is Lattice-like;

:: QUANTAL1:funcreg 1
registration
  let a1 be non empty set;
  let a2, a3, a4 be Function-like quasi_total Relation of [:a1,a1:],a1;
  cluster QuantaleStr(#a1,a2,a3,a4#) -> non empty strict;
end;

:: QUANTAL1:exreg 6
registration
  cluster non empty unital associative commutative Lattice-like complete with_zero right-distributive left-distributive QuantaleStr;
end;

:: QUANTAL1:sch 3
scheme QUANTAL1:sch 3
{F1 -> non empty Lattice-like complete QuantaleStr,
  F2 -> Element of the carrier of F1(),
  F3 -> set,
  F4 -> set}:
"\/"({"\/"({F2(b1, b2) where b2 is Element of the carrier of F1(): b2 in F4()},F1()) where b1 is Element of the carrier of F1(): b1 in F3()},F1()) = "\/"({F2(b1, b2) where b1 is Element of the carrier of F1(), b2 is Element of the carrier of F1(): b1 in F3() & b2 in F4()},F1())


:: QUANTAL1:th 5
theorem
for b1 being non empty Lattice-like complete right-distributive left-distributive QuantaleStr
for b2, b3 being set holds
("\/"(b2,b1)) * "\/"(b3,b1) = "\/"({b4 * b5 where b4 is Element of the carrier of b1, b5 is Element of the carrier of b1: b4 in b2 & b5 in b3},b1);

:: QUANTAL1:th 6
theorem
for b1 being non empty Lattice-like complete right-distributive left-distributive QuantaleStr
for b2, b3, b4 being Element of the carrier of b1 holds
(b2 "\/" b3) * b4 = (b2 * b4) "\/" (b3 * b4) &
 b4 * (b2 "\/" b3) = (b4 * b2) "\/" (b4 * b3);

:: QUANTAL1:funcreg 2
registration
  let a1 be non empty set;
  let a2, a3, a4 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a5 be Element of a1;
  cluster QuasiNetStr(#a1,a2,a3,a4,a5#) -> non empty strict;
end;

:: QUANTAL1:exreg 7
registration
  cluster non empty Lattice-like complete QuasiNetStr;
end;

:: QUANTAL1:condreg 3
registration
  cluster non empty Lattice-like complete right-distributive left-distributive -> times-additive times-continuous (QuasiNetStr);
end;

:: QUANTAL1:exreg 8
registration
  cluster non empty unital associative commutative Lattice-like complete with_left-zero with_zero right-distributive left-distributive QuasiNetStr;
end;

:: QUANTAL1:modenot 2
definition
  mode Quantale is non empty associative Lattice-like complete right-distributive left-distributive QuantaleStr;
end;

:: QUANTAL1:modenot 3
definition
  mode QuasiNet is non empty unital associative Lattice-like complete with_left-zero times-additive times-continuous QuasiNetStr;
end;

:: QUANTAL1:modenot 4
definition
  mode BlikleNet is non empty unital associative Lattice-like complete with_left-zero with_zero times-additive times-continuous QuasiNetStr;
end;

:: QUANTAL1:th 7
theorem
for b1 being non empty unital QuasiNetStr
      st b1 is non empty associative Lattice-like complete right-distributive left-distributive QuantaleStr
   holds b1 is non empty unital associative Lattice-like complete with_left-zero with_zero times-additive times-continuous QuasiNetStr;

:: QUANTAL1:th 8
theorem
for b1 being non empty associative Lattice-like complete right-distributive left-distributive QuantaleStr
for b2, b3, b4 being Element of the carrier of b1
      st b2 [= b3
   holds b2 * b4 [= b3 * b4 & b4 * b2 [= b4 * b3;

:: QUANTAL1:th 9
theorem
for b1 being non empty associative Lattice-like complete right-distributive left-distributive QuantaleStr
for b2, b3, b4, b5 being Element of the carrier of b1
      st b2 [= b3 & b4 [= b5
   holds b2 * b4 [= b3 * b5;

:: QUANTAL1:attrnot 11 => QUANTAL1:attr 11
definition
  let a1 be Relation-like Function-like set;
  attr a1 is idempotent means
    a1 * a1 = a1;
end;

:: QUANTAL1:dfs 9
definiens
  let a1 be Relation-like Function-like set;
To prove
     a1 is idempotent
it is sufficient to prove
  thus a1 * a1 = a1;

:: QUANTAL1:def 9
theorem
for b1 being Relation-like Function-like set holds
      b1 is idempotent
   iff
      b1 * b1 = b1;

:: QUANTAL1:attrnot 12 => QUANTAL1:attr 12
definition
  let a1 be non empty LattStr;
  let a2 be Function-like quasi_total Relation of the carrier of a1,the carrier of a1;
  attr a2 is inflationary means
    for b1 being Element of the carrier of a1 holds
       b1 [= a2 . b1;
end;

:: QUANTAL1:dfs 10
definiens
  let a1 be non empty LattStr;
  let a2 be Function-like quasi_total Relation of the carrier of a1,the carrier of a1;
To prove
     a2 is inflationary
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       b1 [= a2 . b1;

:: QUANTAL1:def 10
theorem
for b1 being non empty LattStr
for b2 being Function-like quasi_total Relation of the carrier of b1,the carrier of b1 holds
      b2 is inflationary(b1)
   iff
      for b3 being Element of the carrier of b1 holds
         b3 [= b2 . b3;

:: QUANTAL1:attrnot 13 => QUANTAL1:attr 13
definition
  let a1 be non empty LattStr;
  let a2 be Function-like quasi_total Relation of the carrier of a1,the carrier of a1;
  attr a2 is deflationary means
    for b1 being Element of the carrier of a1 holds
       a2 . b1 [= b1;
end;

:: QUANTAL1:dfs 11
definiens
  let a1 be non empty LattStr;
  let a2 be Function-like quasi_total Relation of the carrier of a1,the carrier of a1;
To prove
     a2 is deflationary
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       a2 . b1 [= b1;

:: QUANTAL1:def 11
theorem
for b1 being non empty LattStr
for b2 being Function-like quasi_total Relation of the carrier of b1,the carrier of b1 holds
      b2 is deflationary(b1)
   iff
      for b3 being Element of the carrier of b1 holds
         b2 . b3 [= b3;

:: QUANTAL1:attrnot 14 => QUANTAL1:attr 14
definition
  let a1 be non empty LattStr;
  let a2 be Function-like quasi_total Relation of the carrier of a1,the carrier of a1;
  attr a2 is monotone means
    for b1, b2 being Element of the carrier of a1
          st b1 [= b2
       holds a2 . b1 [= a2 . b2;
end;

:: QUANTAL1:dfs 12
definiens
  let a1 be non empty LattStr;
  let a2 be Function-like quasi_total Relation of the carrier of a1,the carrier of a1;
To prove
     a2 is monotone
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st b1 [= b2
       holds a2 . b1 [= a2 . b2;

:: QUANTAL1:def 12
theorem
for b1 being non empty LattStr
for b2 being Function-like quasi_total Relation of the carrier of b1,the carrier of b1 holds
      b2 is monotone(b1)
   iff
      for b3, b4 being Element of the carrier of b1
            st b3 [= b4
         holds b2 . b3 [= b2 . b4;

:: QUANTAL1:attrnot 15 => QUANTAL1:attr 15
definition
  let a1 be non empty LattStr;
  let a2 be Function-like quasi_total Relation of the carrier of a1,the carrier of a1;
  attr a2 is \/-distributive means
    for b1 being Element of bool the carrier of a1 holds
       a2 . "\/"(b1,a1) [= "\/"({a2 . b2 where b2 is Element of the carrier of a1: b2 in b1},a1);
end;

:: QUANTAL1:dfs 13
definiens
  let a1 be non empty LattStr;
  let a2 be Function-like quasi_total Relation of the carrier of a1,the carrier of a1;
To prove
     a2 is \/-distributive
it is sufficient to prove
  thus for b1 being Element of bool the carrier of a1 holds
       a2 . "\/"(b1,a1) [= "\/"({a2 . b2 where b2 is Element of the carrier of a1: b2 in b1},a1);

:: QUANTAL1:def 13
theorem
for b1 being non empty LattStr
for b2 being Function-like quasi_total Relation of the carrier of b1,the carrier of b1 holds
      b2 is \/-distributive(b1)
   iff
      for b3 being Element of bool the carrier of b1 holds
         b2 . "\/"(b3,b1) [= "\/"({b2 . b4 where b4 is Element of the carrier of b1: b4 in b3},b1);

:: QUANTAL1:exreg 9
registration
  let a1 be non empty Lattice-like LattStr;
  cluster non empty Relation-like Function-like quasi_total total inflationary deflationary monotone Relation of the carrier of a1,the carrier of a1;
end;

:: QUANTAL1:th 10
theorem
for b1 being non empty Lattice-like complete LattStr
for b2 being Function-like quasi_total Relation of the carrier of b1,the carrier of b1
      st b2 is monotone(b1)
   holds    b2 is \/-distributive(b1)
   iff
      for b3 being Element of bool the carrier of b1 holds
         b2 . "\/"(b3,b1) = "\/"({b2 . b4 where b4 is Element of the carrier of b1: b4 in b3},b1);

:: QUANTAL1:attrnot 16 => QUANTAL1:attr 16
definition
  let a1 be non empty QuantaleStr;
  let a2 be Function-like quasi_total Relation of the carrier of a1,the carrier of a1;
  attr a2 is times-monotone means
    for b1, b2 being Element of the carrier of a1 holds
    (a2 . b1) * (a2 . b2) [= a2 . (b1 * b2);
end;

:: QUANTAL1:dfs 14
definiens
  let a1 be non empty QuantaleStr;
  let a2 be Function-like quasi_total Relation of the carrier of a1,the carrier of a1;
To prove
     a2 is times-monotone
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    (a2 . b1) * (a2 . b2) [= a2 . (b1 * b2);

:: QUANTAL1:def 14
theorem
for b1 being non empty QuantaleStr
for b2 being Function-like quasi_total Relation of the carrier of b1,the carrier of b1 holds
      b2 is times-monotone(b1)
   iff
      for b3, b4 being Element of the carrier of b1 holds
      (b2 . b3) * (b2 . b4) [= b2 . (b3 * b4);

:: QUANTAL1:funcnot 1 => QUANTAL1:func 1
definition
  let a1 be non empty QuantaleStr;
  let a2, a3 be Element of the carrier of a1;
  func A2 -r> A3 -> Element of the carrier of a1 equals
    "\/"({b1 where b1 is Element of the carrier of a1: b1 * a2 [= a3},a1);
end;

:: QUANTAL1:def 15
theorem
for b1 being non empty QuantaleStr
for b2, b3 being Element of the carrier of b1 holds
b2 -r> b3 = "\/"({b4 where b4 is Element of the carrier of b1: b4 * b2 [= b3},b1);

:: QUANTAL1:funcnot 2 => QUANTAL1:func 2
definition
  let a1 be non empty QuantaleStr;
  let a2, a3 be Element of the carrier of a1;
  func A2 -l> A3 -> Element of the carrier of a1 equals
    "\/"({b1 where b1 is Element of the carrier of a1: a2 * b1 [= a3},a1);
end;

:: QUANTAL1:def 16
theorem
for b1 being non empty QuantaleStr
for b2, b3 being Element of the carrier of b1 holds
b2 -l> b3 = "\/"({b4 where b4 is Element of the carrier of b1: b2 * b4 [= b3},b1);

:: QUANTAL1:th 11
theorem
for b1 being non empty associative Lattice-like complete right-distributive left-distributive QuantaleStr
for b2, b3, b4 being Element of the carrier of b1 holds
   b2 * b3 [= b4
iff
   b3 [= b2 -l> b4;

:: QUANTAL1:th 12
theorem
for b1 being non empty associative Lattice-like complete right-distributive left-distributive QuantaleStr
for b2, b3, b4 being Element of the carrier of b1 holds
   b2 * b3 [= b4
iff
   b2 [= b3 -r> b4;

:: QUANTAL1:th 13
theorem
for b1 being non empty associative Lattice-like complete right-distributive left-distributive QuantaleStr
for b2, b3, b4 being Element of the carrier of b1
      st b3 [= b4
   holds b4 -r> b2 [= b3 -r> b2 & b4 -l> b2 [= b3 -l> b2;

:: QUANTAL1:th 14
theorem
for b1 being non empty associative Lattice-like complete right-distributive left-distributive QuantaleStr
for b2 being Element of the carrier of b1
for b3 being Function-like quasi_total Relation of the carrier of b1,the carrier of b1
      st for b4 being Element of the carrier of b1 holds
           b3 . b4 = (b4 -r> b2) -r> b2
   holds b3 is monotone(b1);

:: QUANTAL1:attrnot 17 => QUANTAL1:attr 17
definition
  let a1 be non empty QuantaleStr;
  let a2 be Element of the carrier of a1;
  attr a2 is dualizing means
    for b1 being Element of the carrier of a1 holds
       (b1 -r> a2) -l> a2 = b1 & (b1 -l> a2) -r> a2 = b1;
end;

:: QUANTAL1:dfs 17
definiens
  let a1 be non empty QuantaleStr;
  let a2 be Element of the carrier of a1;
To prove
     a2 is dualizing
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       (b1 -r> a2) -l> a2 = b1 & (b1 -l> a2) -r> a2 = b1;

:: QUANTAL1:def 17
theorem
for b1 being non empty QuantaleStr
for b2 being Element of the carrier of b1 holds
      b2 is dualizing(b1)
   iff
      for b3 being Element of the carrier of b1 holds
         (b3 -r> b2) -l> b2 = b3 & (b3 -l> b2) -r> b2 = b3;

:: QUANTAL1:attrnot 18 => QUANTAL1:attr 18
definition
  let a1 be non empty QuantaleStr;
  let a2 be Element of the carrier of a1;
  attr a2 is cyclic means
    for b1 being Element of the carrier of a1 holds
       b1 -r> a2 = b1 -l> a2;
end;

:: QUANTAL1:dfs 18
definiens
  let a1 be non empty QuantaleStr;
  let a2 be Element of the carrier of a1;
To prove
     a2 is cyclic
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       b1 -r> a2 = b1 -l> a2;

:: QUANTAL1:def 18
theorem
for b1 being non empty QuantaleStr
for b2 being Element of the carrier of b1 holds
      b2 is cyclic(b1)
   iff
      for b3 being Element of the carrier of b1 holds
         b3 -r> b2 = b3 -l> b2;

:: QUANTAL1:th 15
theorem
for b1 being non empty associative Lattice-like complete right-distributive left-distributive QuantaleStr
for b2 being Element of the carrier of b1 holds
      b2 is cyclic(b1)
   iff
      for b3, b4 being Element of the carrier of b1
            st b3 * b4 [= b2
         holds b4 * b3 [= b2;

:: QUANTAL1:th 16
theorem
for b1 being non empty associative Lattice-like complete right-distributive left-distributive QuantaleStr
for b2, b3 being Element of the carrier of b1
      st b2 is cyclic(b1)
   holds b3 [= (b3 -r> b2) -r> b2 & b3 [= (b3 -l> b2) -l> b2;

:: QUANTAL1:th 17
theorem
for b1 being non empty associative Lattice-like complete right-distributive left-distributive QuantaleStr
for b2, b3 being Element of the carrier of b1
      st b2 is cyclic(b1)
   holds b3 -r> b2 = ((b3 -r> b2) -r> b2) -r> b2 &
    b3 -l> b2 = ((b3 -l> b2) -l> b2) -l> b2;

:: QUANTAL1:th 18
theorem
for b1 being non empty associative Lattice-like complete right-distributive left-distributive QuantaleStr
for b2, b3, b4 being Element of the carrier of b1
      st b2 is cyclic(b1)
   holds ((b3 -r> b2) -r> b2) * ((b4 -r> b2) -r> b2) [= ((b3 * b4) -r> b2) -r> b2;

:: QUANTAL1:th 19
theorem
for b1 being non empty associative Lattice-like complete right-distributive left-distributive QuantaleStr
for b2 being Element of the carrier of b1
      st b2 is dualizing(b1)
   holds b1 is unital & the_unity_wrt the multF of b1 = b2 -r> b2 & the_unity_wrt the multF of b1 = b2 -l> b2;

:: QUANTAL1:th 20
theorem
for b1 being non empty associative Lattice-like complete right-distributive left-distributive QuantaleStr
for b2, b3, b4 being Element of the carrier of b1
      st b2 is dualizing(b1)
   holds b3 -r> b4 = (b3 * (b4 -l> b2)) -r> b2 &
    b3 -l> b4 = ((b4 -r> b2) * b3) -l> b2;

:: QUANTAL1:structnot 3 => QUANTAL1:struct 3
definition
  struct(QuasiNetStr) Girard-QuantaleStr(#
    carrier -> set,
    L_join -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    L_meet -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    multF -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    OneF -> Element of the carrier of it,
    absurd -> Element of the carrier of it
  #);
end;

:: QUANTAL1:attrnot 19 => QUANTAL1:attr 19
definition
  let a1 be Girard-QuantaleStr;
  attr a1 is strict;
end;

:: QUANTAL1:exreg 10
registration
  cluster strict Girard-QuantaleStr;
end;

:: QUANTAL1:aggrnot 3 => QUANTAL1:aggr 3
definition
  let a1 be set;
  let a2, a3, a4 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a5, a6 be Element of a1;
  aggr Girard-QuantaleStr(#a1,a2,a3,a4,a5,a6#) -> strict Girard-QuantaleStr;
end;

:: QUANTAL1:selnot 1 => QUANTAL1:sel 1
definition
  let a1 be Girard-QuantaleStr;
  sel the absurd of a1 -> Element of the carrier of a1;
end;

:: QUANTAL1:exreg 11
registration
  cluster non empty Girard-QuantaleStr;
end;

:: QUANTAL1:attrnot 20 => QUANTAL1:attr 20
definition
  let a1 be non empty Girard-QuantaleStr;
  attr a1 is cyclic means
    the absurd of a1 is cyclic(a1);
end;

:: QUANTAL1:dfs 19
definiens
  let a1 be non empty Girard-QuantaleStr;
To prove
     a1 is cyclic
it is sufficient to prove
  thus the absurd of a1 is cyclic(a1);

:: QUANTAL1:def 19
theorem
for b1 being non empty Girard-QuantaleStr holds
      b1 is cyclic
   iff
      the absurd of b1 is cyclic(b1);

:: QUANTAL1:attrnot 21 => QUANTAL1:attr 21
definition
  let a1 be non empty Girard-QuantaleStr;
  attr a1 is dualized means
    the absurd of a1 is dualizing(a1);
end;

:: QUANTAL1:dfs 20
definiens
  let a1 be non empty Girard-QuantaleStr;
To prove
     a1 is dualized
it is sufficient to prove
  thus the absurd of a1 is dualizing(a1);

:: QUANTAL1:def 20
theorem
for b1 being non empty Girard-QuantaleStr holds
      b1 is dualized
   iff
      the absurd of b1 is dualizing(b1);

:: QUANTAL1:th 21
theorem
for b1 being non empty Girard-QuantaleStr
      st LattStr(#the carrier of b1,the L_join of b1,the L_meet of b1#) = BooleLatt {}
   holds b1 is cyclic & b1 is dualized;

:: QUANTAL1:funcreg 3
registration
  let a1 be non empty set;
  let a2, a3, a4 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a5, a6 be Element of a1;
  cluster Girard-QuantaleStr(#a1,a2,a3,a4,a5,a6#) -> non empty strict;
end;

:: QUANTAL1:exreg 12
registration
  cluster non empty unital associative commutative Lattice-like complete right-distributive left-distributive strict cyclic dualized Girard-QuantaleStr;
end;

:: QUANTAL1:modenot 5
definition
  mode Girard-Quantale is non empty unital associative Lattice-like complete right-distributive left-distributive cyclic dualized Girard-QuantaleStr;
end;

:: QUANTAL1:funcnot 3 => QUANTAL1:func 3
definition
  let a1 be Girard-QuantaleStr;
  func Bottom A1 -> Element of the carrier of a1 equals
    the absurd of a1;
end;

:: QUANTAL1:def 21
theorem
for b1 being Girard-QuantaleStr holds
   Bottom b1 = the absurd of b1;

:: QUANTAL1:funcnot 4 => QUANTAL1:func 4
definition
  let a1 be non empty Girard-QuantaleStr;
  func Top A1 -> Element of the carrier of a1 equals
    (Bottom a1) -r> Bottom a1;
end;

:: QUANTAL1:def 22
theorem
for b1 being non empty Girard-QuantaleStr holds
   Top b1 = (Bottom b1) -r> Bottom b1;

:: QUANTAL1:funcnot 5 => QUANTAL1:func 5
definition
  let a1 be non empty Girard-QuantaleStr;
  let a2 be Element of the carrier of a1;
  func Bottom A2 -> Element of the carrier of a1 equals
    a2 -r> Bottom a1;
end;

:: QUANTAL1:def 23
theorem
for b1 being non empty Girard-QuantaleStr
for b2 being Element of the carrier of b1 holds
   Bottom b2 = b2 -r> Bottom b1;

:: QUANTAL1:funcnot 6 => QUANTAL1:func 6
definition
  let a1 be non empty Girard-QuantaleStr;
  func Negation A1 -> Function-like quasi_total Relation of the carrier of a1,the carrier of a1 means
    for b1 being Element of the carrier of a1 holds
       it . b1 = Bottom b1;
end;

:: QUANTAL1:def 24
theorem
for b1 being non empty Girard-QuantaleStr
for b2 being Function-like quasi_total Relation of the carrier of b1,the carrier of b1 holds
      b2 = Negation b1
   iff
      for b3 being Element of the carrier of b1 holds
         b2 . b3 = Bottom b3;

:: QUANTAL1:funcnot 7 => QUANTAL1:func 7
definition
  let a1 be non empty Girard-QuantaleStr;
  let a2 be Function-like quasi_total Relation of the carrier of a1,the carrier of a1;
  func Bottom A2 -> Function-like quasi_total Relation of the carrier of a1,the carrier of a1 equals
    (Negation a1) * a2;
end;

:: QUANTAL1:def 25
theorem
for b1 being non empty Girard-QuantaleStr
for b2 being Function-like quasi_total Relation of the carrier of b1,the carrier of b1 holds
   Bottom b2 = (Negation b1) * b2;

:: QUANTAL1:funcnot 8 => QUANTAL1:func 8
definition
  let a1 be non empty Girard-QuantaleStr;
  let a2 be Function-like quasi_total Relation of [:the carrier of a1,the carrier of a1:],the carrier of a1;
  func Bottom A2 -> Function-like quasi_total Relation of [:the carrier of a1,the carrier of a1:],the carrier of a1 equals
    (Negation a1) * a2;
end;

:: QUANTAL1:def 26
theorem
for b1 being non empty Girard-QuantaleStr
for b2 being Function-like quasi_total Relation of [:the carrier of b1,the carrier of b1:],the carrier of b1 holds
   Bottom b2 = (Negation b1) * b2;

:: QUANTAL1:th 22
theorem
for b1 being non empty unital associative Lattice-like complete right-distributive left-distributive cyclic dualized Girard-QuantaleStr
for b2 being Element of the carrier of b1 holds
   Bottom Bottom b2 = b2;

:: QUANTAL1:th 23
theorem
for b1 being non empty unital associative Lattice-like complete right-distributive left-distributive cyclic dualized Girard-QuantaleStr
for b2, b3 being Element of the carrier of b1
      st b2 [= b3
   holds Bottom b3 [= Bottom b2;

:: QUANTAL1:th 24
theorem
for b1 being non empty unital associative Lattice-like complete right-distributive left-distributive cyclic dualized Girard-QuantaleStr
for b2 being set holds
   Bottom "\/"(b2,b1) = "/\"({Bottom b3 where b3 is Element of the carrier of b1: b3 in b2},b1);

:: QUANTAL1:th 25
theorem
for b1 being non empty unital associative Lattice-like complete right-distributive left-distributive cyclic dualized Girard-QuantaleStr
for b2 being set holds
   Bottom "/\"(b2,b1) = "\/"({Bottom b3 where b3 is Element of the carrier of b1: b3 in b2},b1);

:: QUANTAL1:th 26
theorem
for b1 being non empty unital associative Lattice-like complete right-distributive left-distributive cyclic dualized Girard-QuantaleStr
for b2, b3 being Element of the carrier of b1 holds
Bottom (b2 "\/" b3) = (Bottom b2) "/\" Bottom b3 &
 Bottom (b2 "/\" b3) = (Bottom b2) "\/" Bottom b3;

:: QUANTAL1:funcnot 9 => QUANTAL1:func 9
definition
  let a1 be non empty unital associative Lattice-like complete right-distributive left-distributive cyclic dualized Girard-QuantaleStr;
  let a2, a3 be Element of the carrier of a1;
  func A2 delta A3 -> Element of the carrier of a1 equals
    Bottom ((Bottom a2) * Bottom a3);
end;

:: QUANTAL1:def 27
theorem
for b1 being non empty unital associative Lattice-like complete right-distributive left-distributive cyclic dualized Girard-QuantaleStr
for b2, b3 being Element of the carrier of b1 holds
b2 delta b3 = Bottom ((Bottom b2) * Bottom b3);

:: QUANTAL1:th 27
theorem
for b1 being non empty unital associative Lattice-like complete right-distributive left-distributive cyclic dualized Girard-QuantaleStr
for b2 being Element of the carrier of b1
for b3 being set holds
   b2 * "\/"(b3,b1) = "\/"({b2 * b4 where b4 is Element of the carrier of b1: b4 in b3},b1) &
    b2 delta "/\"(b3,b1) = "/\"({b2 delta b4 where b4 is Element of the carrier of b1: b4 in b3},b1);

:: QUANTAL1:th 28
theorem
for b1 being non empty unital associative Lattice-like complete right-distributive left-distributive cyclic dualized Girard-QuantaleStr
for b2 being Element of the carrier of b1
for b3 being set holds
   ("\/"(b3,b1)) * b2 = "\/"({b4 * b2 where b4 is Element of the carrier of b1: b4 in b3},b1) &
    ("/\"(b3,b1)) delta b2 = "/\"({b4 delta b2 where b4 is Element of the carrier of b1: b4 in b3},b1);

:: QUANTAL1:th 29
theorem
for b1 being non empty unital associative Lattice-like complete right-distributive left-distributive cyclic dualized Girard-QuantaleStr
for b2, b3, b4 being Element of the carrier of b1 holds
b2 delta (b3 "/\" b4) = (b2 delta b3) "/\" (b2 delta b4) &
 (b3 "/\" b4) delta b2 = (b3 delta b2) "/\" (b4 delta b2);

:: QUANTAL1:th 30
theorem
for b1 being non empty unital associative Lattice-like complete right-distributive left-distributive cyclic dualized Girard-QuantaleStr
for b2, b3, b4, b5 being Element of the carrier of b1
      st b2 [= b3 & b4 [= b5
   holds b2 delta b4 [= b3 delta b5;

:: QUANTAL1:th 31
theorem
for b1 being non empty unital associative Lattice-like complete right-distributive left-distributive cyclic dualized Girard-QuantaleStr
for b2, b3, b4 being Element of the carrier of b1 holds
(b2 delta b3) delta b4 = b2 delta (b3 delta b4);

:: QUANTAL1:th 32
theorem
for b1 being non empty unital associative Lattice-like complete right-distributive left-distributive cyclic dualized Girard-QuantaleStr
for b2 being Element of the carrier of b1 holds
   b2 * Top b1 = b2 & (Top b1) * b2 = b2;

:: QUANTAL1:th 33
theorem
for b1 being non empty unital associative Lattice-like complete right-distributive left-distributive cyclic dualized Girard-QuantaleStr
for b2 being Element of the carrier of b1 holds
   b2 delta Bottom b1 = b2 & (Bottom b1) delta b2 = b2;

:: QUANTAL1:th 34
theorem
for b1 being non empty associative Lattice-like complete right-distributive left-distributive QuantaleStr
for b2 being Function-like quasi_total Relation of the carrier of b1,the carrier of b1
      st b2 is monotone(b1) & b2 is idempotent & b2 is \/-distributive(b1)
   holds ex b3 being non empty Lattice-like complete LattStr st
      the carrier of b3 = rng b2 &
       (for b4 being Element of bool the carrier of b3 holds
          "\/"(b4,b3) = b2 . "\/"(b4,b1));