Module Generic_rule_interpreter.Make

Parameters

Signature

type t

Abstract graph

type instance
type result =
| Clash
| Corrected
| Blocked
| Success of t

Clash means rectangular approximation failure Corrected means molecular ambiguity failure

Initialisation

val empty : outputs:(Data.t -> unit) -> with_trace:bool -> Random.State.t -> Kappa_terms.Model.t -> Counter.t -> t

algebraic expression computation

val value_alg : Counter.t -> t -> Kappa_terms.Primitives.alg_expr -> Kappa_generic_toolset.Nbr.t
val value_bool : Counter.t -> t -> (Kappa_terms.Pattern.id array list, int) Kappa_terms.Alg_expr.bool -> bool
val activity : t -> float
val get_edges : t -> Kappa_mixtures.Edges.t

Core

val apply_given_rule : debugMode:bool -> outputs:(Data.t -> unit) -> ?⁠rule_id:int -> Kappa_terms.Model.t -> Counter.t -> t -> Trace.event_kind -> Kappa_terms.Primitives.elementary_rule -> result

Returns the graph obtained by applying the rule. rule_id is mandatory if the rule has an unary rate.

val pick_an_instance : debugMode:bool -> Kappa_terms.Model.t -> t -> instance
val is_correct_instance : Kappa_terms.Model.t -> t -> instance -> bool
val apply_instance : debugMode:bool -> outputs:(Data.t -> unit) -> ?⁠maxConsecutiveBlocked:int -> maxConsecutiveClash:int -> Kappa_terms.Model.t -> Counter.t -> t -> instance -> int option * bool * t

apply_rule ~outputs ~maxConsecutiveClash ?is_blocked model counter st Returns (corresponding_syntactic_rule, is_final_step, new_state). is_final_step is determined by the counter. corresponding_syntactic_rule is equal to None if and only if a null event occured

val force_rule : debugMode:bool -> outputs:(Data.t -> unit) -> Kappa_terms.Model.t -> Counter.t -> t -> Trace.event_kind -> ?⁠rule_id:int -> Kappa_terms.Primitives.elementary_rule -> t option

Apply the rule for sure if it is possible. Try apply_rule but in case of null_event, it computes the exact injections of the left hand side to do apply the rule and returns the remaining exact injections.

val incorporate_extra_pattern : debugMode:bool -> Kappa_terms.Pattern.Env.t -> t -> Kappa_terms.Pattern.id -> t
val overwrite_var : int -> Counter.t -> t -> Kappa_terms.Primitives.alg_expr -> t
val update_outdated_activities : debugMode:bool -> (int -> float -> float -> unit) -> Kappa_terms.Model.t -> Counter.t -> t -> int list -> t * int list

Resynchronize the state after a rule application.

It takes the function to store the new activities as an argument whose signature is store rule_id syntactic_rule_id new_activity.

As long as you don't use any algebraic variable (that include don't pick a rule randomly), you can apply several rules in row before resynchronizing. (This is what initial state does.)

takes the list of perturbations to be tried and returns it updated

val snapshot : debugMode:bool -> raw:bool -> Kappa_terms.Model.t -> Counter.t -> t -> Data.snapshot
val print : Kappa_terms.Model.t -> Format.formatter -> t -> unit
val get_random_state : t -> Random.State.t
val update_edges_from_actions : debugMode:bool -> outputs:(Data.t -> unit) -> Kappa_mixtures.Signature.s -> Counter.t -> Kappa_terms.Pattern.Env.t -> t -> (Kappa_terms.Instantiation.concrete Kappa_terms.Instantiation.action list * Kappa_terms.Instantiation.concrete Kappa_terms.Instantiation.site list) -> t
val send_instances_message : Instances.message -> t -> t

Blocking events

type event_predicate = int option -> Kappa_terms.Matching.t -> Kappa_terms.Instantiation.concrete Kappa_terms.Instantiation.test list -> Kappa_terms.Instantiation.concrete Kappa_terms.Instantiation.action list -> bool
val set_events_to_block : event_predicate option -> t -> t

Stories

val add_tracked : outputs:(Data.t -> unit) -> Kappa_terms.Pattern.id array -> string -> Kappa_terms.Instantiation.abstract Kappa_terms.Instantiation.test list list -> t -> t
val remove_tracked : Kappa_terms.Pattern.id array -> string option -> t -> t

Species

val add_tracked_species : Kappa_terms.Pattern.id array -> string -> Kappa_terms.Instantiation.abstract Kappa_terms.Instantiation.test list list -> t -> t
val remove_tracked_species : string -> t -> t

Debugging

type stats = {
mixture_stats : Kappa_mixtures.Edges.stats;
}
val stats : t -> stats
val print_stats : Format.formatter -> t -> unit
val debug_print : Format.formatter -> t -> unit
val apply_negative_transformation : ?⁠mod_connectivity_store:Roots.mod_ccs_cache -> Instances.t -> (Kappa_terms.Instantiation.concrete Kappa_terms.Instantiation.site list * Kappa_mixtures.Edges.t) -> Kappa_terms.Instantiation.concrete Kappa_terms.Primitives.Transformation.t -> Kappa_terms.Instantiation.concrete Kappa_terms.Instantiation.site list * Kappa_mixtures.Edges.t

Internals

val apply_positive_transformation : debugMode:bool -> Kappa_mixtures.Signature.s -> ?⁠mod_connectivity_store:Roots.mod_ccs_cache -> Instances.t -> ((Kappa_terms.Matching.t * int Kappa_generic_toolset.Mods.IntMap.t) * Kappa_terms.Instantiation.concrete Kappa_terms.Instantiation.site list * Kappa_mixtures.Edges.t) -> Kappa_terms.Instantiation.abstract Kappa_terms.Primitives.Transformation.t -> ((Kappa_terms.Matching.t * int Kappa_generic_toolset.Mods.IntMap.t) * Kappa_terms.Instantiation.concrete Kappa_terms.Instantiation.site list * Kappa_mixtures.Edges.t) * Kappa_terms.Instantiation.concrete Kappa_terms.Primitives.Transformation.t
val apply_concrete_positive_transformation : Kappa_mixtures.Signature.s -> ?⁠mod_connectivity_store:Roots.mod_ccs_cache -> Instances.t -> Kappa_mixtures.Edges.t -> Kappa_terms.Instantiation.concrete Kappa_terms.Primitives.Transformation.t -> Kappa_mixtures.Edges.t
val obs_from_transformations : debugMode:bool -> Kappa_terms.Pattern.Env.t -> Kappa_mixtures.Edges.t -> Kappa_terms.Instantiation.concrete Kappa_terms.Primitives.Transformation.t list -> (Kappa_terms.Pattern.id * Kappa_mixtures.Agent.t) list * Kappa_generic_toolset.Operator.DepSet.t

obs_from_transformations domain state transformations

returns

(obs, deps)

val add_outdated_dependencies : Kappa_generic_toolset.Operator.DepSet.t -> t -> t
val debug_print_instances : Format.formatter -> t -> unit