Article QMAX_1, MML version 4.99.1005

:: QMAX_1:funcnot 1 => QMAX_1:func 1
definition
  let a1 be non empty set;
  let a2 be non empty compl-closed sigma-multiplicative Element of bool bool a1;
  func Probabilities A2 -> set means
    for b1 being set holds
          b1 in it
       iff
          b1 is Probability of a2;
end;

:: QMAX_1:def 1
theorem
for b1 being non empty set
for b2 being non empty compl-closed sigma-multiplicative Element of bool bool b1
for b3 being set holds
      b3 = Probabilities b2
   iff
      for b4 being set holds
            b4 in b3
         iff
            b4 is Probability of b2;

:: QMAX_1:funcreg 1
registration
  let a1 be non empty set;
  let a2 be non empty compl-closed sigma-multiplicative Element of bool bool a1;
  cluster Probabilities a2 -> non empty;
end;

:: QMAX_1:structnot 1 => QMAX_1:struct 1
definition
  struct() QM_Str(#
    Observables -> non empty set,
    States -> non empty set,
    Quantum_Probability -> Function-like quasi_total Relation of [:the Observables of it,the States of it:],Probabilities Borel_Sets
  #);
end;

:: QMAX_1:attrnot 1 => QMAX_1:attr 1
definition
  let a1 be QM_Str;
  attr a1 is strict;
end;

:: QMAX_1:exreg 1
registration
  cluster strict QM_Str;
end;

:: QMAX_1:aggrnot 1 => QMAX_1:aggr 1
definition
  let a1, a2 be non empty set;
  let a3 be Function-like quasi_total Relation of [:a1,a2:],Probabilities Borel_Sets;
  aggr QM_Str(#a1,a2,a3#) -> strict QM_Str;
end;

:: QMAX_1:selnot 1 => QMAX_1:sel 1
definition
  let a1 be QM_Str;
  sel the Observables of a1 -> non empty set;
end;

:: QMAX_1:selnot 2 => QMAX_1:sel 2
definition
  let a1 be QM_Str;
  sel the States of a1 -> non empty set;
end;

:: QMAX_1:selnot 3 => QMAX_1:sel 3
definition
  let a1 be QM_Str;
  sel the Quantum_Probability of a1 -> Function-like quasi_total Relation of [:the Observables of a1,the States of a1:],Probabilities Borel_Sets;
end;

:: QMAX_1:funcnot 2 => QMAX_1:func 2
definition
  let a1 be QM_Str;
  func Obs A1 -> set equals
    the Observables of a1;
end;

:: QMAX_1:def 2
theorem
for b1 being QM_Str holds
   Obs b1 = the Observables of b1;

:: QMAX_1:funcnot 3 => QMAX_1:func 3
definition
  let a1 be QM_Str;
  func Sts A1 -> set equals
    the States of a1;
end;

:: QMAX_1:def 3
theorem
for b1 being QM_Str holds
   Sts b1 = the States of b1;

:: QMAX_1:funcreg 2
registration
  let a1 be QM_Str;
  cluster Obs a1 -> non empty;
end;

:: QMAX_1:funcreg 3
registration
  let a1 be QM_Str;
  cluster Sts a1 -> non empty;
end;

:: QMAX_1:funcnot 4 => QMAX_1:func 4
definition
  let a1 be QM_Str;
  let a2 be Element of Obs a1;
  let a3 be Element of Sts a1;
  func Meas(A2,A3) -> Probability of Borel_Sets equals
    (the Quantum_Probability of a1) . [a2,a3];
end;

:: QMAX_1:def 4
theorem
for b1 being QM_Str
for b2 being Element of Obs b1
for b3 being Element of Sts b1 holds
   Meas(b2,b3) = (the Quantum_Probability of b1) . [b2,b3];

:: QMAX_1:attrnot 2 => QMAX_1:attr 2
definition
  let a1 be QM_Str;
  attr a1 is Quantum_Mechanics-like means
    (for b1, b2 being Element of Obs a1
           st for b3 being Element of Sts a1 holds
                Meas(b1,b3) = Meas(b2,b3)
        holds b1 = b2) &
     (for b1, b2 being Element of Sts a1
           st for b3 being Element of Obs a1 holds
                Meas(b3,b1) = Meas(b3,b2)
        holds b1 = b2) &
     (for b1, b2 being Element of Sts a1
     for b3 being Element of REAL
           st 0 <= b3 & b3 <= 1
        holds ex b4 being Element of Sts a1 st
           for b5 being Element of Obs a1
           for b6 being Event of Borel_Sets holds
              (Meas(b5,b4)) . b6 = (b3 * ((Meas(b5,b1)) . b6)) + ((1 - b3) * ((Meas(b5,b2)) . b6)));
end;

:: QMAX_1:dfs 5
definiens
  let a1 be QM_Str;
To prove
     a1 is Quantum_Mechanics-like
it is sufficient to prove
  thus (for b1, b2 being Element of Obs a1
           st for b3 being Element of Sts a1 holds
                Meas(b1,b3) = Meas(b2,b3)
        holds b1 = b2) &
     (for b1, b2 being Element of Sts a1
           st for b3 being Element of Obs a1 holds
                Meas(b3,b1) = Meas(b3,b2)
        holds b1 = b2) &
     (for b1, b2 being Element of Sts a1
     for b3 being Element of REAL
           st 0 <= b3 & b3 <= 1
        holds ex b4 being Element of Sts a1 st
           for b5 being Element of Obs a1
           for b6 being Event of Borel_Sets holds
              (Meas(b5,b4)) . b6 = (b3 * ((Meas(b5,b1)) . b6)) + ((1 - b3) * ((Meas(b5,b2)) . b6)));

:: QMAX_1:def 5
theorem
for b1 being QM_Str holds
      b1 is Quantum_Mechanics-like
   iff
      (for b2, b3 being Element of Obs b1
             st for b4 being Element of Sts b1 holds
                  Meas(b2,b4) = Meas(b3,b4)
          holds b2 = b3) &
       (for b2, b3 being Element of Sts b1
             st for b4 being Element of Obs b1 holds
                  Meas(b4,b2) = Meas(b4,b3)
          holds b2 = b3) &
       (for b2, b3 being Element of Sts b1
       for b4 being Element of REAL
             st 0 <= b4 & b4 <= 1
          holds ex b5 being Element of Sts b1 st
             for b6 being Element of Obs b1
             for b7 being Event of Borel_Sets holds
                (Meas(b6,b5)) . b7 = (b4 * ((Meas(b6,b2)) . b7)) + ((1 - b4) * ((Meas(b6,b3)) . b7)));

:: QMAX_1:exreg 2
registration
  cluster strict Quantum_Mechanics-like QM_Str;
end;

:: QMAX_1:modenot 1
definition
  mode Quantum_Mechanics is Quantum_Mechanics-like QM_Str;
end;

:: QMAX_1:structnot 2 => QMAX_1:struct 2
definition
  struct(RelStrComplStr) OrthoRelStr(#
    carrier -> set,
    InternalRel -> Relation of the carrier of it,the carrier of it,
    Compl -> Function-like quasi_total Relation of the carrier of it,the carrier of it
  #);
end;

:: QMAX_1:attrnot 3 => QMAX_1:attr 3
definition
  let a1 be OrthoRelStr;
  attr a1 is strict;
end;

:: QMAX_1:exreg 3
registration
  cluster strict OrthoRelStr;
end;

:: QMAX_1:aggrnot 2 => QMAX_1:aggr 2
definition
  let a1 be set;
  let a2 be Relation of a1,a1;
  let a3 be Function-like quasi_total Relation of a1,a1;
  aggr OrthoRelStr(#a1,a2,a3#) -> strict OrthoRelStr;
end;

:: QMAX_1:prednot 1 => QMAX_1:pred 1
definition
  let a1 be set;
  let a2 be Function-like quasi_total Relation of a1,a1;
  pred A2 is_an_involution_in A1 means
    for b1 being Element of a1 holds
       a2 . (a2 . b1) = b1;
end;

:: QMAX_1:dfs 6
definiens
  let a1 be set;
  let a2 be Function-like quasi_total Relation of a1,a1;
To prove
     a2 is_an_involution_in a1
it is sufficient to prove
  thus for b1 being Element of a1 holds
       a2 . (a2 . b1) = b1;

:: QMAX_1:def 6
theorem
for b1 being set
for b2 being Function-like quasi_total Relation of b1,b1 holds
      b2 is_an_involution_in b1
   iff
      for b3 being Element of b1 holds
         b2 . (b2 . b3) = b3;

:: QMAX_1:prednot 2 => QMAX_1:pred 2
definition
  let a1 be OrthoRelStr;
  pred A1 is_a_Quantuum_Logic_on means
    the InternalRel of a1 partially_orders the carrier of a1 &
     the Compl of a1 is_an_involution_in the carrier of a1 &
     (for b1, b2 being Element of the carrier of a1
           st [b1,b2] in the InternalRel of a1
        holds [(the Compl of a1) . b2,(the Compl of a1) . b1] in the InternalRel of a1);
end;

:: QMAX_1:dfs 7
definiens
  let a1 be OrthoRelStr;
To prove
     a1 is_a_Quantuum_Logic_on
it is sufficient to prove
  thus the InternalRel of a1 partially_orders the carrier of a1 &
     the Compl of a1 is_an_involution_in the carrier of a1 &
     (for b1, b2 being Element of the carrier of a1
           st [b1,b2] in the InternalRel of a1
        holds [(the Compl of a1) . b2,(the Compl of a1) . b1] in the InternalRel of a1);

:: QMAX_1:def 7
theorem
for b1 being OrthoRelStr holds
      b1 is_a_Quantuum_Logic_on
   iff
      the InternalRel of b1 partially_orders the carrier of b1 &
       the Compl of b1 is_an_involution_in the carrier of b1 &
       (for b2, b3 being Element of the carrier of b1
             st [b2,b3] in the InternalRel of b1
          holds [(the Compl of b1) . b3,(the Compl of b1) . b2] in the InternalRel of b1);

:: QMAX_1:funcnot 5 => QMAX_1:func 5
definition
  let a1 be Quantum_Mechanics-like QM_Str;
  func Prop A1 -> set equals
    [:Obs a1,Borel_Sets:];
end;

:: QMAX_1:def 8
theorem
for b1 being Quantum_Mechanics-like QM_Str holds
   Prop b1 = [:Obs b1,Borel_Sets:];

:: QMAX_1:funcreg 4
registration
  let a1 be Quantum_Mechanics-like QM_Str;
  cluster Prop a1 -> non empty;
end;

:: QMAX_1:funcnot 6 => QMAX_1:func 6
definition
  let a1 be Quantum_Mechanics-like QM_Str;
  let a2 be Element of Prop a1;
  redefine func a2 `1 -> Element of Obs a1;
end;

:: QMAX_1:funcnot 7 => QMAX_1:func 7
definition
  let a1 be Quantum_Mechanics-like QM_Str;
  let a2 be Element of Prop a1;
  redefine func a2 `2 -> Event of Borel_Sets;
end;

:: QMAX_1:th 16
theorem
for b1 being Quantum_Mechanics-like QM_Str
for b2 being Element of Sts b1
for b3 being Element of Prop b1
for b4 being Event of Borel_Sets
      st b4 = b3 `2 `
   holds (Meas(b3 `1,b2)) . (b3 `2) = 1 - ((Meas(b3 `1,b2)) . b4);

:: QMAX_1:funcnot 8 => QMAX_1:func 8
definition
  let a1 be Quantum_Mechanics-like QM_Str;
  let a2 be Element of Prop a1;
  func 'not' A2 -> Element of Prop a1 equals
    [a2 `1,a2 `2 `];
end;

:: QMAX_1:def 9
theorem
for b1 being Quantum_Mechanics-like QM_Str
for b2 being Element of Prop b1 holds
   'not' b2 = [b2 `1,b2 `2 `];

:: QMAX_1:prednot 3 => QMAX_1:pred 3
definition
  let a1 be Quantum_Mechanics-like QM_Str;
  let a2, a3 be Element of Prop a1;
  pred A2 |- A3 means
    for b1 being Element of Sts a1 holds
       (Meas(a2 `1,b1)) . (a2 `2) <= (Meas(a3 `1,b1)) . (a3 `2);
end;

:: QMAX_1:dfs 10
definiens
  let a1 be Quantum_Mechanics-like QM_Str;
  let a2, a3 be Element of Prop a1;
To prove
     a2 |- a3
it is sufficient to prove
  thus for b1 being Element of Sts a1 holds
       (Meas(a2 `1,b1)) . (a2 `2) <= (Meas(a3 `1,b1)) . (a3 `2);

:: QMAX_1:def 10
theorem
for b1 being Quantum_Mechanics-like QM_Str
for b2, b3 being Element of Prop b1 holds
   b2 |- b3
iff
   for b4 being Element of Sts b1 holds
      (Meas(b2 `1,b4)) . (b2 `2) <= (Meas(b3 `1,b4)) . (b3 `2);

:: QMAX_1:prednot 4 => QMAX_1:pred 4
definition
  let a1 be Quantum_Mechanics-like QM_Str;
  let a2, a3 be Element of Prop a1;
  pred A2 <==> A3 means
    a2 |- a3 & a3 |- a2;
end;

:: QMAX_1:dfs 11
definiens
  let a1 be Quantum_Mechanics-like QM_Str;
  let a2, a3 be Element of Prop a1;
To prove
     a2 <==> a3
it is sufficient to prove
  thus a2 |- a3 & a3 |- a2;

:: QMAX_1:def 11
theorem
for b1 being Quantum_Mechanics-like QM_Str
for b2, b3 being Element of Prop b1 holds
   b2 <==> b3
iff
   b2 |- b3 & b3 |- b2;

:: QMAX_1:th 20
theorem
for b1 being Quantum_Mechanics-like QM_Str
for b2, b3 being Element of Prop b1 holds
   b2 <==> b3
iff
   for b4 being Element of Sts b1 holds
      (Meas(b2 `1,b4)) . (b2 `2) = (Meas(b3 `1,b4)) . (b3 `2);

:: QMAX_1:th 21
theorem
for b1 being Quantum_Mechanics-like QM_Str
for b2 being Element of Prop b1 holds
   b2 |- b2;

:: QMAX_1:th 22
theorem
for b1 being Quantum_Mechanics-like QM_Str
for b2, b3, b4 being Element of Prop b1
      st b2 |- b3 & b3 |- b4
   holds b2 |- b4;

:: QMAX_1:th 23
theorem
for b1 being Quantum_Mechanics-like QM_Str
for b2 being Element of Prop b1 holds
   b2 <==> b2;

:: QMAX_1:th 24
theorem
for b1 being Quantum_Mechanics-like QM_Str
for b2, b3 being Element of Prop b1
      st b2 <==> b3
   holds b3 <==> b2;

:: QMAX_1:th 25
theorem
for b1 being Quantum_Mechanics-like QM_Str
for b2, b3, b4 being Element of Prop b1
      st b2 <==> b3 & b3 <==> b4
   holds b2 <==> b4;

:: QMAX_1:th 27
theorem
for b1 being Quantum_Mechanics-like QM_Str
for b2 being Element of Prop b1 holds
   'not' 'not' b2 = b2;

:: QMAX_1:th 28
theorem
for b1 being Quantum_Mechanics-like QM_Str
for b2, b3 being Element of Prop b1
      st b2 |- b3
   holds 'not' b3 |- 'not' b2;

:: QMAX_1:funcnot 9 => QMAX_1:func 9
definition
  let a1 be Quantum_Mechanics-like QM_Str;
  func PropRel A1 -> symmetric transitive total Relation of Prop a1,Prop a1 means
    for b1, b2 being Element of Prop a1 holds
       [b1,b2] in it
    iff
       b1 <==> b2;
end;

:: QMAX_1:def 12
theorem
for b1 being Quantum_Mechanics-like QM_Str
for b2 being symmetric transitive total Relation of Prop b1,Prop b1 holds
      b2 = PropRel b1
   iff
      for b3, b4 being Element of Prop b1 holds
         [b3,b4] in b2
      iff
         b3 <==> b4;

:: QMAX_1:th 30
theorem
for b1 being Quantum_Mechanics-like QM_Str
for b2, b3 being Element of bool Prop b1
   st b2 in Class PropRel b1 & b3 in Class PropRel b1
for b4, b5, b6, b7 being Element of Prop b1
      st b4 in b2 & b5 in b2 & b6 in b3 & b7 in b3 & b4 |- b6
   holds b5 |- b7;

:: QMAX_1:funcnot 10 => QMAX_1:func 10
definition
  let a1 be Quantum_Mechanics-like QM_Str;
  func OrdRel A1 -> Relation of Class PropRel a1,Class PropRel a1 means
    for b1, b2 being Element of bool Prop a1 holds
       [b1,b2] in it
    iff
       b1 in Class PropRel a1 &
        b2 in Class PropRel a1 &
        (for b3, b4 being Element of Prop a1
              st b3 in b1 & b4 in b2
           holds b3 |- b4);
end;

:: QMAX_1:def 13
theorem
for b1 being Quantum_Mechanics-like QM_Str
for b2 being Relation of Class PropRel b1,Class PropRel b1 holds
      b2 = OrdRel b1
   iff
      for b3, b4 being Element of bool Prop b1 holds
         [b3,b4] in b2
      iff
         b3 in Class PropRel b1 &
          b4 in Class PropRel b1 &
          (for b5, b6 being Element of Prop b1
                st b5 in b3 & b6 in b4
             holds b5 |- b6);

:: QMAX_1:th 32
theorem
for b1 being Quantum_Mechanics-like QM_Str
for b2, b3 being Element of Prop b1 holds
   b2 |- b3
iff
   [Class(PropRel b1,b2),Class(PropRel b1,b3)] in OrdRel b1;

:: QMAX_1:th 33
theorem
for b1 being Quantum_Mechanics-like QM_Str
for b2, b3 being Element of bool Prop b1
   st b2 in Class PropRel b1 & b3 in Class PropRel b1
for b4, b5 being Element of Prop b1
      st b4 in b2 & b5 in b2 & 'not' b4 in b3
   holds 'not' b5 in b3;

:: QMAX_1:th 34
theorem
for b1 being Quantum_Mechanics-like QM_Str
for b2, b3 being Element of bool Prop b1
   st b2 in Class PropRel b1 & b3 in Class PropRel b1
for b4, b5 being Element of Prop b1
      st 'not' b4 in b3 & 'not' b5 in b3 & b4 in b2
   holds b5 in b2;

:: QMAX_1:funcnot 11 => QMAX_1:func 11
definition
  let a1 be Quantum_Mechanics-like QM_Str;
  func InvRel A1 -> Function-like quasi_total Relation of Class PropRel a1,Class PropRel a1 means
    for b1 being Element of Prop a1 holds
       it . Class(PropRel a1,b1) = Class(PropRel a1,'not' b1);
end;

:: QMAX_1:def 14
theorem
for b1 being Quantum_Mechanics-like QM_Str
for b2 being Function-like quasi_total Relation of Class PropRel b1,Class PropRel b1 holds
      b2 = InvRel b1
   iff
      for b3 being Element of Prop b1 holds
         b2 . Class(PropRel b1,b3) = Class(PropRel b1,'not' b3);

:: QMAX_1:th 36
theorem
for b1 being Quantum_Mechanics-like QM_Str holds
   OrthoRelStr(#Class PropRel b1,OrdRel b1,InvRel b1#) is_a_Quantuum_Logic_on;