Article BOOLMARK, MML version 4.99.1005

:: BOOLMARK:th 1
theorem
for b1, b2 being non empty set
for b3 being Function-like quasi_total Relation of b1,b2
for b4 being Element of bool b1
for b5 being Element of b2 holds
   b3 +* (b4 --> b5) is Function-like quasi_total Relation of b1,b2;

:: BOOLMARK:th 2
theorem
for b1, b2 being non empty set
for b3, b4 being Element of bool b1
for b5 being Function-like quasi_total Relation of b1,b2
      st b5 .: b3 misses b5 .: b4
   holds b3 misses b4;

:: BOOLMARK:th 3
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set
for b4 being set
      st b1 misses b2
   holds (b3 +* (b1 --> b4)) .: b2 = b3 .: b2;

:: BOOLMARK:funcnot 1 => BOOLMARK:func 1
definition
  let a1 be PT_net_Str;
  func Bool_marks_of A1 -> FUNCTION_DOMAIN of the Places of a1,BOOLEAN equals
    Funcs(the Places of a1,BOOLEAN);
end;

:: BOOLMARK:def 1
theorem
for b1 being PT_net_Str holds
   Bool_marks_of b1 = Funcs(the Places of b1,BOOLEAN);

:: BOOLMARK:modenot 1
definition
  let a1 be PT_net_Str;
  mode Boolean_marking of a1 is Element of Bool_marks_of a1;
end;

:: BOOLMARK:prednot 1 => BOOLMARK:pred 1
definition
  let a1 be PT_net_Str;
  let a2 be Element of Bool_marks_of a1;
  let a3 be Element of the Transitions of a1;
  pred A3 is_firable_on A2 means
    a2 .: *' {a3} c= {TRUE};
end;

:: BOOLMARK:dfs 2
definiens
  let a1 be PT_net_Str;
  let a2 be Element of Bool_marks_of a1;
  let a3 be Element of the Transitions of a1;
To prove
     a3 is_firable_on a2
it is sufficient to prove
  thus a2 .: *' {a3} c= {TRUE};

:: BOOLMARK:def 2
theorem
for b1 being PT_net_Str
for b2 being Element of Bool_marks_of b1
for b3 being Element of the Transitions of b1 holds
      b3 is_firable_on b2
   iff
      b2 .: *' {b3} c= {TRUE};

:: BOOLMARK:prednot 2 => not BOOLMARK:pred 1
notation
  let a1 be PT_net_Str;
  let a2 be Element of Bool_marks_of a1;
  let a3 be Element of the Transitions of a1;
  antonym a3 is_not_firable_on a2 for a3 is_firable_on a2;
end;

:: BOOLMARK:funcnot 2 => BOOLMARK:func 2
definition
  let a1 be PT_net_Str;
  let a2 be Element of Bool_marks_of a1;
  let a3 be Element of the Transitions of a1;
  func Firing(A3,A2) -> Element of Bool_marks_of a1 equals
    (a2 +* ((*' {a3}) --> FALSE)) +* ({a3} *' --> TRUE);
end;

:: BOOLMARK:def 3
theorem
for b1 being PT_net_Str
for b2 being Element of Bool_marks_of b1
for b3 being Element of the Transitions of b1 holds
   Firing(b3,b2) = (b2 +* ((*' {b3}) --> FALSE)) +* ({b3} *' --> TRUE);

:: BOOLMARK:prednot 3 => BOOLMARK:pred 2
definition
  let a1 be PT_net_Str;
  let a2 be Element of Bool_marks_of a1;
  let a3 be FinSequence of the Transitions of a1;
  pred A3 is_firable_on A2 means
    (a3 <> {}) implies ex b1 being FinSequence of Bool_marks_of a1 st
       len a3 = len b1 &
        a3 /. 1 is_firable_on a2 &
        b1 /. 1 = Firing(a3 /. 1,a2) &
        (for b2 being Element of NAT
              st b2 < len a3 & 0 < b2
           holds a3 /. (b2 + 1) is_firable_on b1 /. b2 &
            b1 /. (b2 + 1) = Firing(a3 /. (b2 + 1),b1 /. b2));
end;

:: BOOLMARK:dfs 4
definiens
  let a1 be PT_net_Str;
  let a2 be Element of Bool_marks_of a1;
  let a3 be FinSequence of the Transitions of a1;
To prove
     a3 is_firable_on a2
it is sufficient to prove
  thus (a3 <> {}) implies ex b1 being FinSequence of Bool_marks_of a1 st
       len a3 = len b1 &
        a3 /. 1 is_firable_on a2 &
        b1 /. 1 = Firing(a3 /. 1,a2) &
        (for b2 being Element of NAT
              st b2 < len a3 & 0 < b2
           holds a3 /. (b2 + 1) is_firable_on b1 /. b2 &
            b1 /. (b2 + 1) = Firing(a3 /. (b2 + 1),b1 /. b2));

:: BOOLMARK:def 4
theorem
for b1 being PT_net_Str
for b2 being Element of Bool_marks_of b1
for b3 being FinSequence of the Transitions of b1 holds
      b3 is_firable_on b2
   iff
      (b3 <> {} implies ex b4 being FinSequence of Bool_marks_of b1 st
         len b3 = len b4 &
          b3 /. 1 is_firable_on b2 &
          b4 /. 1 = Firing(b3 /. 1,b2) &
          (for b5 being Element of NAT
                st b5 < len b3 & 0 < b5
             holds b3 /. (b5 + 1) is_firable_on b4 /. b5 &
              b4 /. (b5 + 1) = Firing(b3 /. (b5 + 1),b4 /. b5)));

:: BOOLMARK:prednot 4 => not BOOLMARK:pred 2
notation
  let a1 be PT_net_Str;
  let a2 be Element of Bool_marks_of a1;
  let a3 be FinSequence of the Transitions of a1;
  antonym a3 is_not_firable_on a2 for a3 is_firable_on a2;
end;

:: BOOLMARK:funcnot 3 => BOOLMARK:func 3
definition
  let a1 be PT_net_Str;
  let a2 be Element of Bool_marks_of a1;
  let a3 be FinSequence of the Transitions of a1;
  func Firing(A3,A2) -> Element of Bool_marks_of a1 means
    it = a2
    if a3 = {}
    otherwise ex b1 being FinSequence of Bool_marks_of a1 st
       len a3 = len b1 &
        it = b1 /. len b1 &
        b1 /. 1 = Firing(a3 /. 1,a2) &
        (for b2 being Element of NAT
              st b2 < len a3 & 0 < b2
           holds b1 /. (b2 + 1) = Firing(a3 /. (b2 + 1),b1 /. b2));
end;

:: BOOLMARK:def 5
theorem
for b1 being PT_net_Str
for b2 being Element of Bool_marks_of b1
for b3 being FinSequence of the Transitions of b1
for b4 being Element of Bool_marks_of b1 holds
   (b3 = {} implies    (b4 = Firing(b3,b2)
    iff
       b4 = b2)) &
    (b3 = {} or    (b4 = Firing(b3,b2)
    iff
       ex b5 being FinSequence of Bool_marks_of b1 st
          len b3 = len b5 &
           b4 = b5 /. len b5 &
           b5 /. 1 = Firing(b3 /. 1,b2) &
           (for b6 being Element of NAT
                 st b6 < len b3 & 0 < b6
              holds b5 /. (b6 + 1) = Firing(b3 /. (b6 + 1),b5 /. b6))));

:: BOOLMARK:th 5
theorem
for b1 being non empty set
for b2 being set
for b3 being Relation-like Function-like set holds
   (b3 +* (b1 --> b2)) .: b1 = {b2};

:: BOOLMARK:th 6
theorem
for b1 being PT_net_Str
for b2 being Element of Bool_marks_of b1
for b3 being Element of the Transitions of b1
for b4 being Element of the Places of b1
      st b4 in {b3} *'
   holds (Firing(b3,b2)) . b4 = TRUE;

:: BOOLMARK:th 7
theorem
for b1 being PT_net_Str
for b2 being non empty Element of bool the Places of b1 holds
      b2 is Deadlock-like(b1)
   iff
      for b3 being Element of Bool_marks_of b1
         st b3 .: b2 = {FALSE}
      for b4 being Element of the Transitions of b1
            st b4 is_firable_on b3
         holds (Firing(b4,b3)) .: b2 = {FALSE};

:: BOOLMARK:th 8
theorem
for b1 being non empty set
for b2, b3 being FinSequence of b1
for b4 being Element of NAT
      st 1 <= b4 & b4 <= len b2
   holds (b2 ^ b3) /. b4 = b2 /. b4;

:: BOOLMARK:th 10
theorem
for b1 being PT_net_Str
for b2 being Element of Bool_marks_of b1
for b3, b4 being FinSequence of the Transitions of b1 holds
Firing(b3 ^ b4,b2) = Firing(b4,Firing(b3,b2));

:: BOOLMARK:th 11
theorem
for b1 being PT_net_Str
for b2 being Element of Bool_marks_of b1
for b3, b4 being FinSequence of the Transitions of b1
      st b3 ^ b4 is_firable_on b2
   holds b4 is_firable_on Firing(b3,b2) & b3 is_firable_on b2;

:: BOOLMARK:th 12
theorem
for b1 being PT_net_Str
for b2 being Element of Bool_marks_of b1
for b3 being Element of the Transitions of b1 holds
      b3 is_firable_on b2
   iff
      <*b3*> is_firable_on b2;

:: BOOLMARK:th 13
theorem
for b1 being PT_net_Str
for b2 being Element of Bool_marks_of b1
for b3 being Element of the Transitions of b1 holds
   Firing(b3,b2) = Firing(<*b3*>,b2);

:: BOOLMARK:th 14
theorem
for b1 being PT_net_Str
for b2 being non empty Element of bool the Places of b1 holds
      b2 is Deadlock-like(b1)
   iff
      for b3 being Element of Bool_marks_of b1
         st b3 .: b2 = {FALSE}
      for b4 being FinSequence of the Transitions of b1
            st b4 is_firable_on b3
         holds (Firing(b4,b3)) .: b2 = {FALSE};