package lascar

  1. Overview
  2. Docs
package lascar
Legend:
Library
Module
Module type
Parameter
Class
Class type

Functor for converting a Moore machine into an equivalent Mealy one

Parameters

module MM : Moore.T

Signature

include Mealy.T with type state = MM.state
type state = MM.state
include Ltsa.T with type label := Mealy.Transition.t and type state := state and type attr := unit
type transition = state * Mealy.Transition.t * state

The type for transitions. A transition is a triplet (s1,l,s2), where s1 is the source state, s2 the destination state and l the transition label

type itransition = Mealy.Transition.t * state

The type for initial transitions. An initial transition is a pair (l,s), where s is the destination state and l the transition label

type t

The type of Labeled Transition Systems with state attributes

module State : Ltsa.STATE with type t = state
module Label : Ltsa.LABEL with type t = Mealy.Transition.t
module Attr : Ltsa.ATTR with type t = unit
module States : Utils.SetExt.S with type elt = state
module Attrs : Map.S with type key = state
module Tree : Utils.Tree.S with type node = state and type edge = Mealy.Transition.t
val states : t -> States.t

Returns the set of states

val states' : t -> (state * unit) list

Returns the set of states, with attached attribute as a assocation list

val istates : t -> States.t

Returns the set of initial states

val istates' : t -> state list

Returns the set of initial states as a list

val transitions : t -> transition list

Returns the list of transitions

val itransitions : t -> itransition list

Returns the list of initial transitions

val string_of_state : state -> string

A synonym of State.to_string

val string_of_label : Mealy.Transition.t -> string

A synonym of Label.to_string

val string_of_attr : unit -> string

A synonym of Attr.to_string

Inspectors

val is_state : t -> state -> bool

is_state s q returns true iff q is a state in s

val is_init_state : t -> state -> bool

is_init s q returns true iff q is an initial state in s

val is_reachable : t -> state -> bool

is_reachable s q returns true iff q is a reachable state in s, i.e. if it can be reached from an initial state using the transitio relation.

val is_transition : t -> transition -> bool

is_transition t q returns true iff t is a transition in s

val succs : t -> state -> States.t

succs s q returns the set of immediate successors in s, i.e. the set of state q' such that there exists a transition (q,l,q') in R. Raise Invalid_argument if q is not in s.

val succs' : t -> state -> (state * Mealy.Transition.t) list

succs' s q returns the list of immediate successors, with the associated transition label, of state q in s. Raise Invalid_argument if q is not in s.

val preds : t -> state -> States.t

preds s q returns the set of immediate predecessors of state q in s, i.e. the set of state q' such that there exists a transition (q',l,q) in R. Raise Invalid_argument if q is not in s.

val preds' : t -> state -> (state * Mealy.Transition.t) list

preds' s q returns the list of immediate predecessors, with the associated transition label, of state q in s. Raise Invalid_argument if q is not in s.

val succs_hat : t -> state -> States.t

Transitive closure of succs. succs_hat s q returns all the successors (immediate or not) of q in s

val preds_hat : t -> state -> States.t

Transitive closure of preds. preds_hat s q returns all the predecessors (immediate or not) of q in s

val attr_of : t -> state -> unit

attr_of s q returns the attribute of state q in s. Raise Not_found if there is no state q in s

Building functions

exception Invalid_state of state

Global iterators

val iter_states : (state -> unit -> unit) -> t -> unit

iter_states f s applies function f to all states (with associated attribute) of s

val fold_states : (state -> unit -> 'a -> 'a) -> t -> 'a -> 'a

fold_states f s z computes f xN ... (f x2 (f x1 z))..., where x1, ..., xN are all the states of s

val iter_transitions : (transition -> unit) -> t -> unit

iter_transitions f s applies function f to all transitions of s

val fold_transitions : (transition -> 'a -> 'a) -> t -> 'a -> 'a

fold_transitions f s z computes f xN ... (f x2 (f x1 z))..., where x1, ..., xN are all the transitions of s

val iter_itransitions : (itransition -> unit) -> t -> unit

iter_itransitions f s applies function f to all initial transitions of s

val fold_itransitions : (itransition -> 'a -> 'a) -> t -> 'a -> 'a

fold_itransitions f s z computes f xN ... (f x2 (f x1 z))..., where x1, ..., xN are all the initial transitions of s

State iterators

val fold_succs : t -> state -> (state -> Mealy.Transition.t -> 'a -> 'a) -> 'a -> 'a

fold_succs s x f z computes f xN lN ... (f x2 (f x1 l1 z) l2)..., where x1, ..., xN are all the successors of state x in LTSA s, and l1, ..., lN the associated transitions labels

val iter_succs : t -> state -> (state -> Mealy.Transition.t -> unit) -> unit

iter_succs s x f z computes f x1 l1; ... ;f xN lN, where x1, ..., xN are all the successors of state x in LTSA s, and l1, ..., lN the associated transitions labels

val fold_preds : t -> state -> (state -> Mealy.Transition.t -> 'a -> 'a) -> 'a -> 'a

fold_preds s x f z computes f xN lN ... (f x2 (f x1 l1 z) l2)..., where x1, ..., xN are all the predecessors of state x in LTSA s, and l1, ..., lN the associated transitions labels

val iter_preds : t -> state -> (state -> Mealy.Transition.t -> unit) -> unit

iter_preds s x f z computes f x1 l1; ... ;f xN lN, where x1, ..., xN are all the predecessors of state x in LTSA s, and l1, ..., lN the associated transitions labels

Global transformations

val map_state : (state -> state) -> t -> t

map_state f s returns the LTSA obtained by replacing each state q by f q in s. State attributes are left unchanged. Result is undefined if f is not injective.

val map_attr : (unit -> unit) -> t -> t

map_attr f s returns the LTSA obtained by replacing each state attribute a by f a in s.

val map_state_attr : ((state * unit) -> state * unit) -> t -> t

map_state_attr f s returns the LTSA obtained by replacing each pair of state and associated attributes (q,a) by f (q,a) in s. As for map_state, the result is undefined if f is not injective its first argument.

val map_label : (Mealy.Transition.t -> Mealy.Transition.t) -> t -> t

map_label f s returns the LTSA obtained by replacing each transition label l by f l in s.

val map_transition : ((state option * Mealy.Transition.t * state) -> state option * Mealy.Transition.t * state) -> t -> t

map_transition f s returns the LTSA obtained by replacing each transition t by f t in s. Each non-initial transition qs,l,qd is replaced by qs',l',qd', where (Some qs',l',qd') = f (Some qs,l,qd). If present, the initial transition l,qi is replaced by l',qi' where (None,l',qi') = f (None, l, qi). Warning: updating the source and/or destination state in a transition may result in a incoherent LTS description. This function should essentially be viewed as a variant of map_label in which the transformation function f can take the source and destination state into account.

val clean : t -> t

Removes unreachable nodes and associated transitions

Output functions

val dot_output_execs : string -> ?fname:string -> ?options:Utils.Dot.graph_style list -> int -> t -> unit

dot_output_execs name depth s writes a .dot representation, with name name of the execution trees obtained by calling unwind depth s. The name of the file is name.dot or specified with the fname optional argument. Drawing options can be specified with the options optional argument.

val tex_output : string -> ?fname:string -> ?listed_transitions:Mealy.Transition.t list option -> t -> unit

tex_output name fname s writes a .tex representation of s with name name. The name of the output file is name.dot or specified with the fname optional argument. When the optional argument listed_transitions is Some l, only transitions listed in l are written, otherwise all transitions of s are written.

module M : Ltsa.T with type state = state and type label = Mealy.Transition.t and type attr = unit
exception Invalid_transition of transition
val create : inps:Valuation.Bool.name list -> outps:Valuation.Bool.name list -> states:state list -> istate:state -> trans:(state * Mealy.Transition.t * state) list -> t

create ivs ovs ss is ts builds an Mealy structure from

  • a list of input and output variables
  • a list ss of states
  • an initial state is
  • a list of transitions ts, where each transition is given as (src_state,(input_valuation,output_valuation),dst_state)

Raises !Valuation.Invalid_valuation if any specified valuation/assignement is incorrect (i.e. involves identifiers not listed in ivs or ovs or incomplete (i.e. lacks a input or output identifier).

val empty : inps:Valuation.Bool.name list -> outps:Valuation.Bool.name list -> t

empty ivs ovs builds an empty Mealy structure from a list of input and output variables.

val add_state : state -> t -> t

add_state q s adds state q to the Mealy structure s

val remove_state : state -> t -> t

remove_state q s removes state q from the Mealy structure s

val add_transition : (state * Mealy.Transition.t * state) -> t -> t

add_transition (q,(iv,os),q') s adds a transition from state q to state q', labeled with the IO valuation (iv,ov) to the Mealy structure s

val add_itransition : state -> t -> t

add_itransition q s adds an initial transition to state q to the Mealy structure s

val lts_of : t -> M.t

Return the underlying representation of the Moore Machine as a LTS

val istate : t -> state option

Returns the initial state, when specified

val inps : t -> Valuation.Bool.name list

Returns the initial state, when specified

Returns the list of inputs variables

val outps : t -> Valuation.Bool.name list

Returns the list of inputs variables

Returns the list of outputs variables

val trans : t -> state -> Mealy.Transition.t -> States.t

trans a q t returns the set of states q' such that (q,t,q') belongs to the transition relation of a

val trans' : t -> state -> Mealy.Transition.t -> state list

trans a q t returns the set of states q' such that (q,t,q') belongs to the transition relation of a

trans' is like trans but returns a list

val unwind : int -> t -> M.Tree.t

unwind depth s unwind machine s to produce an execution tree (rooted at initial state) up to the specified depth.

val dot_output : string -> ?fname:string -> ?options:Utils.Dot.graph_style list -> t -> unit

dot_output name fname s writes a .dot representation of s with name name in file fname. Global graph drawing options can be specified with the options optional argument.

val dot_output_oc : string -> out_channel -> ?options:Utils.Dot.graph_style list -> t -> unit

dot_output_oc name oc s is a variant of dot_output in which the description of s is written to the (previously opened) output channel oc.

val conv : MM.t -> t

Convert a Moore automata into a Mealy automata, by turning

  • turning each state (q,o) into q
  • turning each transitions ((q,o)/i/(q',o') into q,(i/o'),q'
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct