open Preamble

open IO

open CostLabel

open PositiveMap

open Deqsets

open Lists

open Identifiers

open AST

open Division

open Z

open BitVectorZ

open Pointers

open Coqlib

open Values

open Events

open Exp

open Arithmetic

open Vector

open FoldStuff

open BitVector

open Extranat

open Integers

open Proper

open ErrorMessages

open Option

open Setoids

open Monad

open Positive

open PreIdentifiers

open Errors

open IOMonad

open Div_and_mod

open Jmeq

open Russell

open Util

open Bool

open Relations

open Nat

open List

open Hints_declaration

open Core_notation

open Pts

open Logic

open Types

open Extralib

open SmallstepExec

open Executions

open Hide

open Sets

open Listb

open StructuredTraces

open Stacksize

type classified_system = { cs_exec : (IO.io_out, IO.io_in)
                                     SmallstepExec.fullexec; cs_global : 
                           __; cs_labelled : (__ -> Bool.bool);
                           cs_classify : (__ ->
                                         StructuredTraces.status_class);
                           cs_callee : (__ -> __ -> AST.ident) }

val classified_system_rect_Type4 :
  ((IO.io_out, IO.io_in) SmallstepExec.fullexec -> __ -> (__ -> Bool.bool) ->
  (__ -> StructuredTraces.status_class) -> (__ -> __ -> AST.ident) -> 'a1) ->
  classified_system -> 'a1

val classified_system_rect_Type5 :
  ((IO.io_out, IO.io_in) SmallstepExec.fullexec -> __ -> (__ -> Bool.bool) ->
  (__ -> StructuredTraces.status_class) -> (__ -> __ -> AST.ident) -> 'a1) ->
  classified_system -> 'a1

val classified_system_rect_Type3 :
  ((IO.io_out, IO.io_in) SmallstepExec.fullexec -> __ -> (__ -> Bool.bool) ->
  (__ -> StructuredTraces.status_class) -> (__ -> __ -> AST.ident) -> 'a1) ->
  classified_system -> 'a1

val classified_system_rect_Type2 :
  ((IO.io_out, IO.io_in) SmallstepExec.fullexec -> __ -> (__ -> Bool.bool) ->
  (__ -> StructuredTraces.status_class) -> (__ -> __ -> AST.ident) -> 'a1) ->
  classified_system -> 'a1

val classified_system_rect_Type1 :
  ((IO.io_out, IO.io_in) SmallstepExec.fullexec -> __ -> (__ -> Bool.bool) ->
  (__ -> StructuredTraces.status_class) -> (__ -> __ -> AST.ident) -> 'a1) ->
  classified_system -> 'a1

val classified_system_rect_Type0 :
  ((IO.io_out, IO.io_in) SmallstepExec.fullexec -> __ -> (__ -> Bool.bool) ->
  (__ -> StructuredTraces.status_class) -> (__ -> __ -> AST.ident) -> 'a1) ->
  classified_system -> 'a1

val cs_exec :
  classified_system -> (IO.io_out, IO.io_in) SmallstepExec.fullexec

val cs_global : classified_system -> __

val cs_labelled : classified_system -> __ -> Bool.bool

val cs_classify : classified_system -> __ -> StructuredTraces.status_class

val cs_callee0 : classified_system -> __ -> AST.ident

val classified_system_inv_rect_Type4 :
  classified_system -> ((IO.io_out, IO.io_in) SmallstepExec.fullexec -> __ ->
  (__ -> Bool.bool) -> (__ -> StructuredTraces.status_class) -> (__ -> __ ->
  AST.ident) -> __ -> 'a1) -> 'a1

val classified_system_inv_rect_Type3 :
  classified_system -> ((IO.io_out, IO.io_in) SmallstepExec.fullexec -> __ ->
  (__ -> Bool.bool) -> (__ -> StructuredTraces.status_class) -> (__ -> __ ->
  AST.ident) -> __ -> 'a1) -> 'a1

val classified_system_inv_rect_Type2 :
  classified_system -> ((IO.io_out, IO.io_in) SmallstepExec.fullexec -> __ ->
  (__ -> Bool.bool) -> (__ -> StructuredTraces.status_class) -> (__ -> __ ->
  AST.ident) -> __ -> 'a1) -> 'a1

val classified_system_inv_rect_Type1 :
  classified_system -> ((IO.io_out, IO.io_in) SmallstepExec.fullexec -> __ ->
  (__ -> Bool.bool) -> (__ -> StructuredTraces.status_class) -> (__ -> __ ->
  AST.ident) -> __ -> 'a1) -> 'a1

val classified_system_inv_rect_Type0 :
  classified_system -> ((IO.io_out, IO.io_in) SmallstepExec.fullexec -> __ ->
  (__ -> Bool.bool) -> (__ -> StructuredTraces.status_class) -> (__ -> __ ->
  AST.ident) -> __ -> 'a1) -> 'a1

val cs_exec__o__es1 :
  classified_system -> (IO.io_out, IO.io_in) SmallstepExec.trans_system

type cs_state = __

val intensional_event_of_event :
  Events.event -> StructuredTraces.intensional_event List.list

val intensional_events_of_events :
  Events.trace -> StructuredTraces.intensional_event List.list

val intensional_state_change :
  classified_system -> AST.ident List.list -> __ -> (AST.ident List.list,
  StructuredTraces.intensional_event List.list) Types.prod

val intensional_trace_of_trace :
  classified_system -> AST.ident List.list -> (cs_state, Events.trace)
  Types.prod List.list -> (AST.ident List.list,
  StructuredTraces.intensional_event List.list) Types.prod

val normal_state : classified_system -> cs_state -> Bool.bool

val measure_stack :
  (AST.ident -> Nat.nat Types.option) -> Stacksize.stacksize_info ->
  StructuredTraces.intensional_event List.list -> Stacksize.stacksize_info

val will_return_aux :
  classified_system -> Nat.nat -> (cs_state, Events.trace) Types.prod
  List.list -> Bool.bool

val will_return' :
  classified_system -> (cs_state, Events.trace) Types.prod List.list ->
  Bool.bool

type preclassified_system = { pcs_exec : (IO.io_out, IO.io_in)
                                         SmallstepExec.fullexec;
                              pcs_labelled : (__ -> __ -> Bool.bool);
                              pcs_classify : (__ -> __ ->
                                             StructuredTraces.status_class);
                              pcs_callee : (__ -> __ -> __ -> AST.ident) }

val preclassified_system_rect_Type4 :
  ((IO.io_out, IO.io_in) SmallstepExec.fullexec -> (__ -> __ -> Bool.bool) ->
  (__ -> __ -> StructuredTraces.status_class) -> (__ -> __ -> __ ->
  AST.ident) -> 'a1) -> preclassified_system -> 'a1

val preclassified_system_rect_Type5 :
  ((IO.io_out, IO.io_in) SmallstepExec.fullexec -> (__ -> __ -> Bool.bool) ->
  (__ -> __ -> StructuredTraces.status_class) -> (__ -> __ -> __ ->
  AST.ident) -> 'a1) -> preclassified_system -> 'a1

val preclassified_system_rect_Type3 :
  ((IO.io_out, IO.io_in) SmallstepExec.fullexec -> (__ -> __ -> Bool.bool) ->
  (__ -> __ -> StructuredTraces.status_class) -> (__ -> __ -> __ ->
  AST.ident) -> 'a1) -> preclassified_system -> 'a1

val preclassified_system_rect_Type2 :
  ((IO.io_out, IO.io_in) SmallstepExec.fullexec -> (__ -> __ -> Bool.bool) ->
  (__ -> __ -> StructuredTraces.status_class) -> (__ -> __ -> __ ->
  AST.ident) -> 'a1) -> preclassified_system -> 'a1

val preclassified_system_rect_Type1 :
  ((IO.io_out, IO.io_in) SmallstepExec.fullexec -> (__ -> __ -> Bool.bool) ->
  (__ -> __ -> StructuredTraces.status_class) -> (__ -> __ -> __ ->
  AST.ident) -> 'a1) -> preclassified_system -> 'a1

val preclassified_system_rect_Type0 :
  ((IO.io_out, IO.io_in) SmallstepExec.fullexec -> (__ -> __ -> Bool.bool) ->
  (__ -> __ -> StructuredTraces.status_class) -> (__ -> __ -> __ ->
  AST.ident) -> 'a1) -> preclassified_system -> 'a1

val pcs_exec :
  preclassified_system -> (IO.io_out, IO.io_in) SmallstepExec.fullexec

val pcs_labelled : preclassified_system -> __ -> __ -> Bool.bool

val pcs_classify :
  preclassified_system -> __ -> __ -> StructuredTraces.status_class

val pcs_callee0 : preclassified_system -> __ -> __ -> AST.ident

val preclassified_system_inv_rect_Type4 :
  preclassified_system -> ((IO.io_out, IO.io_in) SmallstepExec.fullexec ->
  (__ -> __ -> Bool.bool) -> (__ -> __ -> StructuredTraces.status_class) ->
  (__ -> __ -> __ -> AST.ident) -> __ -> 'a1) -> 'a1

val preclassified_system_inv_rect_Type3 :
  preclassified_system -> ((IO.io_out, IO.io_in) SmallstepExec.fullexec ->
  (__ -> __ -> Bool.bool) -> (__ -> __ -> StructuredTraces.status_class) ->
  (__ -> __ -> __ -> AST.ident) -> __ -> 'a1) -> 'a1

val preclassified_system_inv_rect_Type2 :
  preclassified_system -> ((IO.io_out, IO.io_in) SmallstepExec.fullexec ->
  (__ -> __ -> Bool.bool) -> (__ -> __ -> StructuredTraces.status_class) ->
  (__ -> __ -> __ -> AST.ident) -> __ -> 'a1) -> 'a1

val preclassified_system_inv_rect_Type1 :
  preclassified_system -> ((IO.io_out, IO.io_in) SmallstepExec.fullexec ->
  (__ -> __ -> Bool.bool) -> (__ -> __ -> StructuredTraces.status_class) ->
  (__ -> __ -> __ -> AST.ident) -> __ -> 'a1) -> 'a1

val preclassified_system_inv_rect_Type0 :
  preclassified_system -> ((IO.io_out, IO.io_in) SmallstepExec.fullexec ->
  (__ -> __ -> Bool.bool) -> (__ -> __ -> StructuredTraces.status_class) ->
  (__ -> __ -> __ -> AST.ident) -> __ -> 'a1) -> 'a1

val pcs_exec__o__es1 :
  preclassified_system -> (IO.io_out, IO.io_in) SmallstepExec.trans_system

val pcs_to_cs : preclassified_system -> __ -> classified_system

val observables :
  preclassified_system -> __ -> Nat.nat -> Nat.nat ->
  (StructuredTraces.intensional_event List.list,
  StructuredTraces.intensional_event List.list) Types.prod Errors.res

val observe_all_in_measurable :
  Nat.nat -> classified_system -> (StructuredTraces.intensional_event ->
  Types.unit0) -> AST.ident List.list -> __ ->
  (StructuredTraces.intensional_event List.list, Integers.int Errors.res)
  Types.prod