nfa_props.h

 
#ifndef NFA_PROPS_H
#define NFA_PROPS_H
 
#include "monoid_props.h"
#include "nfa_props.h"
#include "nfa.h"
#include "nfa_determi.h"
#include "nfa_intersec.h"
 
 /*  _   _ _____ _        ____                            _   _            */
 /* | \ | |  ___/ \   _  |  _ \ _ __ ___  _ __   ___ _ __| |_(_) ___  ___  */
 /* |  \| | |_ / _ \ (_) | |_) | '__/ _ \| '_ \ / _ \ '__| __| |/ _ \/ __| */
 /* | |\  |  _/ ___ \ _  |  __/| | | (_) | |_) |  __/ |  | |_| |  __/\__ \ */
 /* |_| \_|_|/_/   \_(_) |_|   |_|  \___/| .__/ \___|_|   \__|_|\___||___/ */
 /*                                      |_|                               */
 
 
/***********************/
/* Auxiliary functions */
/***********************/

uint* dfacexa_get_alphaloop(dgraph* g, 
    parti* sccs, //<! The partition of the dgraph into strongly connected components (in order to stay within the SCC of the state).
    bool* alph, 
    uint s 
);
 
 
 
 
 
 
 
 
 
 
 
/***********/
/* Trivial */
/***********/

bool is_trivial_dfa(dfa*, 
    FILE* 
);

bool is_ddtrivial_dfa(dfa*, 
    FILE* 
);
 
 
 

bool is_letterind_dfa(dfa*, 
    int* error, 
    FILE* 
);
 
/*********/
/* Group */
/*********/

bool is_permutation_dfa(dfa* A, 
    int* error, 
    FILE* out 
);

bool is_permutationplus_dfa(dfa* A, 
    int* error, 
    FILE* out 
);
 
/*********/
/* Local */
/*********/

bool is_comm_dfa(dfa*, 
    int* error, 
    FILE* 
);

bool is_alphaidem_dfa(dfa*, 
    int* error, 
    FILE* 
);
 

bool is_ddidem_dfa(dfa*, 
    int* error, 
    FILE* 
);

bool is_ddcomm_dfa(dfa*, 
    int* error, 
    FILE* 
);
 

bool is_lttcomm_dfa(dfa*, 
    int* error, 
    FILE* 
);
 
 
/*************************/
/* Counter-free variants */
/*************************/

bool is_counterfreegp_dfa(dfa*,      
    basis mode, 
    int* error, // !< The error code.
    FILE*      
);

bool is_nosmallcountertwo_dfa(dfa* A);
 
bool is_nosimple_counter_dfa(dfa* A, 
    int* error 
);
 
/*******/
/* Pol */
/*******/

bool is_polgp_dfa(dfa* A, 
    basis mode, 
    int* error, 
    FILE* out 
);
 

bool is_polgpplus_dfa(dfa* A, 
    basis mode, 
    int* error, 
    FILE* out 
);
 
 

bool is_pol2gp_dfa(dfa* A, 
    basis mode, 
    int* error, 
    FILE* out 
);

bool is_pol2gpplus_dfa(dfa* A, 
    basis mode, 
    int* error, 
    FILE* out 
);
 
/****************/
/*+ R-trivial. +*/
/****************/
 
 

bool is_rtrivialgp_dfa(dfa* A, 
    basis mode, 
    int* error, 
    FILE* out 
);

bool is_rtrivialgpplus_dfa(dfa* A, 
    basis mode, 
    int* error, 
    FILE* out 
);

bool is_rtrivialbpgp_dfa(dfa* A, 
    basis mode, 
    int* error, 
    FILE* out 
);

bool is_rtrivialbpgpplus_dfa(dfa* A, 
    basis mode, 
    int* error, 
    FILE* out 
);
 
/****************/
/*+ L-trivial. +*/
/****************/

bool is_ltrivialgp_dfa(dfa* A, 
    basis mode, 
    int* error, 
    FILE* out 
);

bool is_ltrivialgpplus_dfa(dfa* A, 
    basis mode, 
    int* error, 
    FILE* out 
);

bool is_ltrivialbpgp_dfa(dfa* A, 
    basis mode, 
    int* error, 
    FILE* out 
);
 

bool is_ltrivialbpgpplus_dfa(dfa* A, 
    basis mode, 
    int* error, 
    FILE* out 
);
 
/********/
/*+ DA +*/
/********/

bool is_dagp_dfa(dfa* A, 
    basis mode, 
    int* error, 
    FILE* out 
);

bool is_dagpplus_dfa(dfa* A, 
    basis mode, 
    int* error, 
    FILE* out 
);

bool is_dabpgp_dfa(dfa* A, 
    basis mode, 
    int* error, 
    FILE* out 
);

bool is_dabpgpplus_dfa(dfa* A, 
    basis mode, 
    int* error, 
    FILE* out 
);
 
/**********/
/*+ BPol +*/
/**********/

bool is_piecewise_dfa(dfa* A, 
    int* error 
);

bool is_bpolmod_dfa(dfa* A, 
    int* error, 
    FILE* out 
);
 

bool is_bpolamt_dfa(dfa* A, 
    int* error, 
    FILE* out 
);

bool is_bpoldd_dfa(dfa* A, 
    int* error, 
    FILE* out 
);

bool is_bpolmodplus_dfa(dfa* A, 
    int* error, 
    FILE* out 
);
 

bool is_bpolamtplus_dfa(dfa* A, 
    int* error, 
    FILE* out 
);
 

bool is_bpolgrplus_dfa(dfa* A, 
    int* error, 
    FILE* out 
);
 

bool is_knastgpplus_dfa(dfa* A, 
    basis mode, 
    int* error, 
    FILE* out 
);
 

bool is_knastat_dfa(dfa* A, 
    int* error, 
    FILE* out 
);
 
/**********/
/*+ UPol +*/
/**********/
 

bool is_upolgpplus_dfa(dfa* A, 
    basis mode, 
    int* error, 
    FILE* out 
);
 
bool is_upolbp2gp_dfa(dfa* A, basis mode, int* error, FILE* out);
 
bool is_upolbp2gpplus_dfa(dfa* A, basis mode, int* error, FILE* out);
 
#endif