Library Smallstep

Tools for small-step operational semantics

This module defines generic operations and theorems over the one-step transition relations that are used to specify operational semantics in small-step style.





Require Import Wf.

Require Import Wf_nat.

Require Import Classical.

Require Import Coqlib.

Require Import AST.

Require Import Events.

Require Import Globalenvs.

Require Import Integers.




Set Implicit Arguments.

Closures of transitions relations





Section CLOSURES.




Variable genv: Type.

Variable state: Type.

A one-step transition relation has the following signature. It is parameterized by a global environment, which does not change during the transition. It relates the initial state of the transition with its final state. The trace parameter captures the observable events possibly generated during the transition.





Variable step: genv -> state -> trace -> state -> Prop.

No transitions: stuck state





Definition nostep (ge: genv) (s: state) : Prop :=

  forall t s', ~(step ge s t s').

Zero, one or several transitions. Also known as Kleene closure, or reflexive transitive closure.





Inductive star (ge: genv): state -> trace -> state -> Prop :=

  | star_refl: forall s,

      star ge s E0 s

  | star_step: forall s1 t1 s2 t2 s3 t,

      step ge s1 t1 s2 -> star ge s2 t2 s3 -> t = t1 ** t2 ->

      star ge s1 t s3.




Lemma star_one:

  forall ge s1 t s2, step ge s1 t s2 -> star ge s1 t s2.






Lemma star_trans:

  forall ge s1 t1 s2, star ge s1 t1 s2 ->

  forall t2 s3 t, star ge s2 t2 s3 -> t = t1 ** t2 -> star ge s1 t s3.






Lemma star_left:

  forall ge s1 t1 s2 t2 s3 t,

  step ge s1 t1 s2 -> star ge s2 t2 s3 -> t = t1 ** t2 ->

  star ge s1 t s3.

Proof star_step.




Lemma star_right:

  forall ge s1 t1 s2 t2 s3 t,

  star ge s1 t1 s2 -> step ge s2 t2 s3 -> t = t1 ** t2 ->

  star ge s1 t s3.

One or several transitions. Also known as the transitive closure.





Inductive plus (ge: genv): state -> trace -> state -> Prop :=

  | plus_left: forall s1 t1 s2 t2 s3 t,

      step ge s1 t1 s2 -> star ge s2 t2 s3 -> t = t1 ** t2 ->

      plus ge s1 t s3.




Lemma plus_one:

  forall ge s1 t s2,

  step ge s1 t s2 -> plus ge s1 t s2.






Lemma plus_star:

  forall ge s1 t s2, plus ge s1 t s2 -> star ge s1 t s2.






Lemma plus_right:

  forall ge s1 t1 s2 t2 s3 t,

  star ge s1 t1 s2 -> step ge s2 t2 s3 -> t = t1 ** t2 ->

  plus ge s1 t s3.






Lemma plus_left':

  forall ge s1 t1 s2 t2 s3 t,

  step ge s1 t1 s2 -> plus ge s2 t2 s3 -> t = t1 ** t2 ->

  plus ge s1 t s3.






Lemma plus_right':

  forall ge s1 t1 s2 t2 s3 t,

  plus ge s1 t1 s2 -> step ge s2 t2 s3 -> t = t1 ** t2 ->

  plus ge s1 t s3.






Lemma plus_star_trans:

  forall ge s1 t1 s2 t2 s3 t,

  plus ge s1 t1 s2 -> star ge s2 t2 s3 -> t = t1 ** t2 -> plus ge s1 t s3.






Lemma star_plus_trans:

  forall ge s1 t1 s2 t2 s3 t,

  star ge s1 t1 s2 -> plus ge s2 t2 s3 -> t = t1 ** t2 -> plus ge s1 t s3.






Lemma plus_trans:

  forall ge s1 t1 s2 t2 s3 t,

  plus ge s1 t1 s2 -> plus ge s2 t2 s3 -> t = t1 ** t2 -> plus ge s1 t s3.






Lemma plus_inv:

  forall ge s1 t s2, 

  plus ge s1 t s2 ->

  step ge s1 t s2 \/ exists s', exists t1, exists t2, step ge s1 t1 s' /\ plus ge s' t2 s2 /\ t = t1 ** t2.






Lemma star_inv:

  forall ge s1 t s2,

  star ge s1 t s2 ->

  (s2 = s1 /\ t = E0) \/ plus ge s1 t s2.

Infinitely many transitions





CoInductive forever (ge: genv): state -> traceinf -> Prop :=

  | forever_intro: forall s1 t s2 T,

      step ge s1 t s2 -> forever ge s2 T ->

      forever ge s1 (t *** T).




Lemma star_forever:

  forall ge s1 t s2, star ge s1 t s2 ->

  forall T, forever ge s2 T ->

  forever ge s1 (t *** T).

An alternate, equivalent definition of forever that is useful for coinductive reasoning.





Variable A: Type.

Variable order: A -> A -> Prop.




CoInductive forever_N (ge: genv) : A -> state -> traceinf -> Prop :=

  | forever_N_star: forall s1 t s2 a1 a2 T1 T2,

      star ge s1 t s2 -> 

      order a2 a1 ->

      forever_N ge a2 s2 T2 ->

      T1 = t *** T2 ->

      forever_N ge a1 s1 T1

  | forever_N_plus: forall s1 t s2 a1 a2 T1 T2,

      plus ge s1 t s2 ->

      forever_N ge a2 s2 T2 ->

      T1 = t *** T2 ->

      forever_N ge a1 s1 T1.




Hypothesis order_wf: well_founded order.




Lemma forever_N_inv:

  forall ge a s T,

  forever_N ge a s T ->

  exists t, exists s', exists a', exists T',

  step ge s t s' /\ forever_N ge a' s' T' /\ T = t *** T'.






Lemma forever_N_forever:

  forall ge a s T, forever_N ge a s T -> forever ge s T.

Yet another alternative definition of forever.





CoInductive forever_plus (ge: genv) : state -> traceinf -> Prop :=

  | forever_plus_intro: forall s1 t s2 T1 T2,

      plus ge s1 t s2 -> 

      forever_plus ge s2 T2 ->

      T1 = t *** T2 ->

      forever_plus ge s1 T1.




Lemma forever_plus_inv:

  forall ge s T,

  forever_plus ge s T ->

  exists s', exists t, exists T',

  step ge s t s' /\ forever_plus ge s' T' /\ T = t *** T'.






Lemma forever_plus_forever:

  forall ge s T, forever_plus ge s T -> forever ge s T.

Infinitely many silent transitions





CoInductive forever_silent (ge: genv): state -> Prop :=

  | forever_silent_intro: forall s1 s2,

      step ge s1 E0 s2 -> forever_silent ge s2 ->

      forever_silent ge s1.

An alternate definition.





CoInductive forever_silent_N (ge: genv) : A -> state -> Prop :=

  | forever_silent_N_star: forall s1 s2 a1 a2,

      star ge s1 E0 s2 -> 

      order a2 a1 ->

      forever_silent_N ge a2 s2 ->

      forever_silent_N ge a1 s1

  | forever_silent_N_plus: forall s1 s2 a1 a2,

      plus ge s1 E0 s2 ->

      forever_silent_N ge a2 s2 ->

      forever_silent_N ge a1 s1.




Lemma forever_silent_N_inv:

  forall ge a s,

  forever_silent_N ge a s ->

  exists s', exists a',

  step ge s E0 s' /\ forever_silent_N ge a' s'.






Lemma forever_silent_N_forever:

  forall ge a s, forever_silent_N ge a s -> forever_silent ge s.

Infinitely many non-silent transitions





CoInductive forever_reactive (ge: genv): state -> traceinf -> Prop :=

  | forever_reactive_intro: forall s1 s2 t T,

      star ge s1 t s2 -> t <> E0 -> forever_reactive ge s2 T ->

      forever_reactive ge s1 (t *** T).




Lemma star_forever_reactive:

  forall ge s1 t s2 T,

  star ge s1 t s2 -> forever_reactive ge s2 T ->

  forever_reactive ge s1 (t *** T).

Outcomes for program executions

The four possible outcomes for the execution of a program:

Termination, with a finite trace of observable events and an integer value that stands for the process exit code (the return value of the main function).
Divergence with a finite trace of observable events. (At some point, the program runs forever without doing any I/O.)
Reactive divergence with an infinite trace of observable events. (The program performs infinitely many I/O operations separated by finite amounts of internal computations.)
Going wrong, with a finite trace of observable events performed before the program gets stuck.





Inductive program_behavior: Type :=

  | Terminates: trace -> int -> program_behavior

  | Diverges: trace -> program_behavior

  | Reacts: traceinf -> program_behavior

  | Goes_wrong: trace -> program_behavior.




Definition not_wrong (beh: program_behavior) : Prop :=

  match beh with

  | Terminates _ _ => True

  | Diverges _ => True

  | Reacts _ => True

  | Goes_wrong _ => False

  end.

Given a characterization of initial states and final states, program_behaves relates a program behaviour with the sequences of transitions that can be taken from an initial state to a final state.





Variable initial_state: state -> Prop.

Variable final_state: state -> int -> Prop.




Inductive program_behaves (ge: genv): program_behavior -> Prop :=

  | program_terminates: forall s t s' r,

      initial_state s ->

      star ge s t s' ->

      final_state s' r ->

      program_behaves ge (Terminates t r)

  | program_diverges: forall s t s',

      initial_state s ->

      star ge s t s' -> forever_silent ge s' ->

      program_behaves ge (Diverges t)

  | program_reacts: forall s T,

      initial_state s ->

      forever_reactive ge s T ->

      program_behaves ge (Reacts T)

  | program_goes_wrong: forall s t s',

      initial_state s ->

      star ge s t s' ->

      nostep ge s' ->

      (forall r, ~final_state s' r) ->

      program_behaves ge (Goes_wrong t)

  | program_goes_initially_wrong:

      (forall s, ~initial_state s) ->

      program_behaves ge (Goes_wrong E0).




End CLOSURES.

Simulations between two small-step semantics.

In this section, we show that if two transition relations satisfy certain simulation diagrams, then every program behaviour generated by the first transition relation can also occur with the second transition relation.





Section SIMULATION.

The first small-step semantics is axiomatized as follows.





Variable genv1: Type.

Variable state1: Type.

Variable step1: genv1 -> state1 -> trace -> state1 -> Prop.

Variable initial_state1: state1 -> Prop.

Variable final_state1: state1 -> int -> Prop.

Variable ge1: genv1.

The second small-step semantics is also axiomatized.





Variable genv2: Type.

Variable state2: Type.

Variable step2: genv2 -> state2 -> trace -> state2 -> Prop.

Variable initial_state2: state2 -> Prop.

Variable final_state2: state2 -> int -> Prop.

Variable ge2: genv2.

We assume given a matching relation between states of both semantics. This matching relation must be compatible with initial states and with final states.





Variable match_states: state1 -> state2 -> Prop.




Hypothesis match_initial_states:

  forall st1, initial_state1 st1 ->

  exists st2, initial_state2 st2 /\ match_states st1 st2.




Hypothesis match_final_states:

  forall st1 st2 r,

  match_states st1 st2 ->

  final_state1 st1 r ->

  final_state2 st2 r.

Simulation when one transition in the first program corresponds to zero, one or several transitions in the second program. However, there is no stuttering: infinitely many transitions in the source program must correspond to infinitely many transitions in the second program.





Section SIMULATION_STAR_WF.

order is a well-founded ordering associated with states of the first semantics. Stuttering steps must correspond to states that decrease w.r.t. order.





Variable order: state1 -> state1 -> Prop.

Hypothesis order_wf: well_founded order.




Hypothesis simulation:

  forall st1 t st1', step1 ge1 st1 t st1' ->

  forall st2, match_states st1 st2 ->

  exists st2',

  (plus step2 ge2 st2 t st2' \/ (star step2 ge2 st2 t st2' /\ order st1' st1))

  /\ match_states st1' st2'.




Lemma simulation_star_star:

  forall st1 t st1', star step1 ge1 st1 t st1' ->

  forall st2, match_states st1 st2 ->

  exists st2', star step2 ge2 st2 t st2' /\ match_states st1' st2'.






Lemma simulation_star_forever_silent:

  forall st1 st2,

  forever_silent step1 ge1 st1 -> match_states st1 st2 ->

  forever_silent step2 ge2 st2.






Lemma simulation_star_forever_reactive:

  forall st1 st2 T,

  forever_reactive step1 ge1 st1 T -> match_states st1 st2 ->

  forever_reactive step2 ge2 st2 T.






Lemma simulation_star_wf_preservation:

  forall beh,

  not_wrong beh ->

  program_behaves step1 initial_state1 final_state1 ge1 beh ->

  program_behaves step2 initial_state2 final_state2 ge2 beh.






End SIMULATION_STAR_WF.




Section SIMULATION_STAR.

We now consider the case where we have a nonnegative integer measure associated with states of the first semantics. It must decrease when we take a stuttering step.





Variable measure: state1 -> nat.




Hypothesis simulation:

  forall st1 t st1', step1 ge1 st1 t st1' ->

  forall st2, match_states st1 st2 ->

  (exists st2', plus step2 ge2 st2 t st2' /\ match_states st1' st2')

  \/ (measure st1' < measure st1 /\ t = E0 /\ match_states st1' st2)%nat.




Lemma simulation_star_preservation:

  forall beh,

  not_wrong beh ->

  program_behaves step1 initial_state1 final_state1 ge1 beh ->

  program_behaves step2 initial_state2 final_state2 ge2 beh.






End SIMULATION_STAR.

Lock-step simulation: each transition in the first semantics corresponds to exactly one transition in the second semantics.





Section SIMULATION_STEP.




Hypothesis simulation:

  forall st1 t st1', step1 ge1 st1 t st1' ->

  forall st2, match_states st1 st2 ->

  exists st2', step2 ge2 st2 t st2' /\ match_states st1' st2'.




Lemma simulation_step_preservation:

  forall beh,

  not_wrong beh ->

  program_behaves step1 initial_state1 final_state1 ge1 beh ->

  program_behaves step2 initial_state2 final_state2 ge2 beh.






End SIMULATION_STEP.

Simulation when one transition in the first program corresponds to one or several transitions in the second program.





Section SIMULATION_PLUS.




Hypothesis simulation:

  forall st1 t st1', step1 ge1 st1 t st1' ->

  forall st2, match_states st1 st2 ->

  exists st2', plus step2 ge2 st2 t st2' /\ match_states st1' st2'.




Lemma simulation_plus_preservation:

  forall beh,

  not_wrong beh ->

  program_behaves step1 initial_state1 final_state1 ge1 beh ->

  program_behaves step2 initial_state2 final_state2 ge2 beh.






End SIMULATION_PLUS.

Simulation when one transition in the first program corresponds to zero or one transitions in the second program. However, there is no stuttering: infinitely many transitions in the source program must correspond to infinitely many transitions in the second program.





Section SIMULATION_OPT.




Variable measure: state1 -> nat.




Hypothesis simulation:

  forall st1 t st1', step1 ge1 st1 t st1' ->

  forall st2, match_states st1 st2 ->

  (exists st2', step2 ge2 st2 t st2' /\ match_states st1' st2')

  \/ (measure st1' < measure st1 /\ t = E0 /\ match_states st1' st2)%nat.




Lemma simulation_opt_preservation:

  forall beh,

  not_wrong beh ->

  program_behaves step1 initial_state1 final_state1 ge1 beh ->

  program_behaves step2 initial_state2 final_state2 ge2 beh.






End SIMULATION_OPT.




End SIMULATION.

Additional results about infinite reduction sequences

We now show that any infinite sequence of reductions is either of the "reactive" kind or of the "silent" kind (after a finite number of non-silent transitions). The proof necessitates the axiom of excluded middle. This result is used in Csem and Cminor to relate the coinductive big-step semantics for divergence with the small-step notions of divergence.





Require Import Classical.

Unset Implicit Arguments.




Section INF_SEQ_DECOMP.




Variable genv: Type.

Variable state: Type.

Variable step: genv -> state -> trace -> state -> Prop.




Variable ge: genv.




Inductive State: Type :=

  ST: forall (s: state) (T: traceinf), forever step ge s T -> State.




Definition state_of_State (S: State): state :=

  match S with ST s T F => s end.

Definition traceinf_of_State (S: State) : traceinf :=

  match S with ST s T F => T end.




Inductive Step: trace -> State -> State -> Prop :=

  | Step_intro: forall s1 t T s2 S F,

      Step t (ST s1 (t *** T) (@forever_intro genv state step ge s1 t s2 T S F))

             (ST s2 T F).




Inductive Steps: State -> State -> Prop :=

  | Steps_refl: forall S, Steps S S

  | Steps_left: forall t S1 S2 S3, Step t S1 S2 -> Steps S2 S3 -> Steps S1 S3.




Remark Steps_trans:

  forall S1 S2, Steps S1 S2 -> forall S3, Steps S2 S3 -> Steps S1 S3.






Let Reactive (S: State) : Prop :=

  forall S1, 

  Steps S S1 ->

  exists S2, exists S3, exists t, Steps S1 S2 /\ Step t S2 S3 /\ t <> E0.




Let Silent (S: State) : Prop :=

  forall S1 t S2, Steps S S1 -> Step t S1 S2 -> t = E0.




Lemma Reactive_or_Silent:

  forall S, Reactive S \/ (exists S', Steps S S' /\ Silent S').






Lemma Steps_star:

  forall S1 S2, Steps S1 S2 ->

  exists t, star step ge (state_of_State S1) t (state_of_State S2)

         /\ traceinf_of_State S1 = t *** traceinf_of_State S2.






Lemma Silent_forever_silent:

  forall S,

  Silent S -> forever_silent step ge (state_of_State S).






Lemma Reactive_forever_reactive:

  forall S,

  Reactive S -> forever_reactive step ge (state_of_State S) (traceinf_of_State S).






Theorem forever_silent_or_reactive:

  forall s T,

  forever step ge s T ->

  forever_reactive step ge s T \/

  exists t, exists s', exists T',

  star step ge s t s' /\ forever_silent step ge s' /\ T = t *** T'.






End INF_SEQ_DECOMP.