shell_memb.h

#ifndef SHELL_MEMB_H
#define SHELL_MEMB_H
 
#include "alloc.h"
#include "monoid_congruences.h"
#include "monoid_props.h"
#include "nfa_enum.h"
#include "shell_commands.h"
#include "shell_languages.h"
#include "shell_sclass.h"
 
#include <stdint.h>

typedef enum {
    MEMB_MINIMAL,  
    MEMB_SYNTAC,   
    MEMB_OPTIMAL,  
    MEMB_SIZE,
}
membership_mode;

extern membership_mode memb_mode;
 

extern bool (*class_membership[CL_END])(int, membership_mode, FILE*);

void init_membership(void);

bool shell_membership_needs_order(classes 
);
 
/**************************************/
/* Membership functions for languages */
/**************************************/

bool shell_membership_reg(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_empty(
    int,   
    membership_mode, 
    FILE* 
);
 
bool shell_membership_htgen(
    int,   
    membership_mode, 
    FILE* 
);
 
/*****************/
/* Group classes */
/*****************/

bool shell_membership_st(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_dd(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_mod(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_modp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_amt(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_amtp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_gr(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_grp(
    int,   
    membership_mode, 
    FILE* 
);
 
/*****************/
/* AT-ATT-LT-LTT */
/*****************/

bool shell_membership_at(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_att(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_lt(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_ltt(
    int,   
    membership_mode, 
    FILE* 
);
 
/*********************/
/* Star-free closure */
/*********************/

bool shell_membership_sf(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_sfmod(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_sfamt(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_sfgr(
    int,   
    membership_mode, 
    FILE* 
);
 
/**********************/
/* Polynomial closure */
/**********************/

bool shell_membership_ppt(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_polmod(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_polgr(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_poldd(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_polmodp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_polgrp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_pol2st(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_pol2mod(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_pol2amt(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_pol2gr(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_pol2dd(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_pol2modp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_pol2amtp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_pol2grp(
    int,   
    membership_mode, 
    FILE* 
);
 
/******************************/
/* Boolean polynomial closure */
/******************************/

bool shell_membership_pt(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_bpolmod(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_bpolamt(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_bpolgr(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_bpolgrp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_bpoldd(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_bpolmodp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_bpolamtp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_bpol2st(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_jorbmod(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_jorbamt(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_jorbdd(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_jorbmodp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_jorbamtp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_jorbgrp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_jorbat(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_knastamtp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_knastgrp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_knastat(
    int,   
    membership_mode, 
    FILE* 
);
 
/**********************************/
/* Unambiguous polynomial closure */
/**********************************/

bool shell_membership_upoldd(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_upolmodp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_upolamtp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_upolgrp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_ubpol2st(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_ubpol2mod(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_ubpol2amt(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_ubpol2gr(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_ubpol2dd(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_ubpol2modp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_ubpol2amtp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_ubpol2grp(
    int,   
    membership_mode, 
    FILE* 
);
 
/******************/
/* Temporal logic */
/******************/

bool shell_membership_ul(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_tlmod(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_tlamt(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_tlgr(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_tldd(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_tlmodp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_tlamtp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_tlgrp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_tl2st(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_tl2mod(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_tl2amt(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_tl2gr(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_tl2dd(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_tl2modp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_tl2amtp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_tl2grp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_fl(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_flmod(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_flamt(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_flgr(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_fldd(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_flmodp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_flamtp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_flgrp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_fl2st(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_fl2mod(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_fl2amt(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_fl2gr(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_fl2dd(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_fl2modp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_fl2amtp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_fl2grp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_pl(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_plmod(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_plamt(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_plgr(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_pldd(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_plmodp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_plamtp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_plgrp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_pl2st(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_pl2mod(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_pl2amt(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_pl2gr(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_pl2dd(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_pl2modp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_pl2amtp(
    int,   
    membership_mode, 
    FILE* 
);

bool shell_membership_pl2grp(
    int,   
    membership_mode, 
    FILE* 
);
 
/***************/
/* Hierarchies */
/***************/

void shell_chiera_summary(
    int i,    
    FILE* out 
);

void shell_navhiera_summary(
    int i,    
    FILE* out 
);
 
 

bool shell_neghiera(classes cl, 
    int i,      
    FILE* out 
);

bool shell_fphiera(classes cl, 
    int i,      
    FILE* out 
);
 
/***********************/
/* Examples generators */
/***********************/
 
typedef enum {
    EXAGEN_ALL, 
    EXAGEN_DETHIERA, 
    EXAGEN_FPHIERA, 
    EXAGEN_SIZE
} exagen_mode;
 
typedef struct {
    exagen_mode mode;  
    classes low[16];     
    uint nblow;          
    classes high[16];    
    uint nbhigh;         
    int states;          
    int alpha;           
    uint64_t done;       
    uint64_t nb_found;   
    uint64_t size_found; 
    uint64_t* found;     
    bool finished;      
} exall_profile;
 
void shell_memb_file(const char* filename);
 
void shell_file_retrieve(const char* filename, const char* pref);

void shell_exall(
    classes* low,  
    int nblow,     
    classes* high, 
    int nbhigh,    
    int states,    
    int alpha,      
    const char* prefix 
);

void shell_exall_dethiera(
    classes cl, 
    int level,  
    int states, 
    int alpha,  
    const char* prefix, 
    bool neg    
);
 
// /**
//  * @brief
//  * Searches for random DFAs satisfying a given set of membership constraints.
//  */
// bool shell_exsearch(com_parameters* //!< Command parameters (should include
// the size of the DFAs and the membership constraints).
// );
 
bool shell_exall_dfatest(void);
 
void shell_make_timestats(classes cl, int states, int alpha);
 
void shell_bugsearch(classes cl, int states, int alpha, const char* prefix);
 
#endif