amachine.am_generator

  1import random
  2import numpy as np
  3import matplotlib.pyplot as plt
  4from pathlib import Path
  5from copy import deepcopy
  6
  7from .am_create import star, star_join, isomorphic_to
  8import random
  9
 10class Generator :
 11
 12    def __init__(self, random_seed=None ) -> None :
 13        
 14        if random_seed :
 15        
 16            np.random.seed( random_seed ) 
 17            random.seed( random_seed )
 18
 19        self.vocabulary = { 
 20            
 21            # 1. Printable ASCII: space (32) through tilde (126) → 95 chars
 22            "ASCII" : [chr(i) for i in range(32, 127)],
 23
 24            # 2. Greek capitals Α–Τ (19), skipping U+03A2 (undefined slot)
 25            "greek_upper" : [chr(i) for i in range(0x0391, 0x03A5) if i != 0x03A2][:19],
 26
 27            # 3. Greek smalls α–τ (19), skipping U+03C2 (ς, final-sigma variant)
 28            "greek_lower" : [chr(i) for i in range(0x03B1, 0x03C5) if i != 0x03C2][:19],
 29
 30            # 4. Geometric Shapes block: U+25A0–U+25FF → 96 chars
 31            "geometric" : [chr(i) for i in range(0x25A0, 0x2600)]
 32        }
 33
 34        self.exit_symbol = self.vocabulary[ "geometric" ][ 0 ]
 35
 36    def generate( 
 37        self, n_states : int, 
 38        n_symbols, 
 39        n_modes : int,
 40        mode_alphas : list[float],
 41        residency_factor : float,
 42        levels : int ) :
 43        
 44        # 0-9 ASCII + lowercase letters + uppercase letters
 45        normal_symbols  = [ chr(i) for i in range( 48,  58 ) ]
 46        normal_symbols += [ chr(i) for i in range( 97, 123 ) ]
 47        normal_symbols += [ chr(i) for i in range( 65,  91 ) ]
 48        enter_symbols = self.vocabulary[ "greek_lower" ] + self.vocabulary[ "greek_upper" ]
 49
 50        n_gen = n_modes*2
 51
 52        # n_gen^levels leaves
 53        machines = [
 54            star(
 55                exit_symbol=self.exit_symbol,
 56                enter_symbols=enter_symbols[ 0:n_modes*2 ],
 57                normal_symbols=normal_symbols,
 58                n_modes=n_modes,
 59                n_isomorphic=2,
 60                randomness=0.3,
 61                connectedness=0.5,
 62                residency_factor=residency_factor,
 63                n_normal_symbols=n_symbols,
 64                t_states_per_machine=n_states
 65            )
 66            for i in range( n_gen**levels )
 67        ]
 68
 69        es_per_lev = n_gen
 70        es_offset = n_modes*2
 71
 72        # Reduce bottom-up, levels-1 times
 73        for i in range( levels - 1 ) :
 74            next_level = []
 75            x = 0
 76
 77            es = enter_symbols[ es_offset + es_per_lev*i : es_offset+es_per_lev*(i+1) ]
 78
 79            for k in range( len(machines) // n_gen ) :  # shrinks each pass
 80                m = star_join(
 81                    exit_symbol=self.exit_symbol,
 82                    enter_symbols=es,
 83                    machines=machines[ x:x+n_gen ],
 84                    mode_residency_factor=0.5
 85                )
 86                next_level.append( m )
 87                x += n_gen
 88            machines = deepcopy( next_level )
 89
 90        # machines now has exactly n_gen elements — join into root
 91        return star_join(
 92            exit_symbol=self.exit_symbol,
 93            enter_symbols=normal_symbols,
 94            machines=machines,
 95            mode_residency_factor=0.5
 96        )
 97
 98if __name__ == "__main__":
 99
100    n_modes = 1
101    alpha = 0.3
102    residency_factor = 0.5
103    n_symbols = 4
104    n_states = 27
105    random_seed=42
106
107    generator = Generator( random_seed=random_seed )
108
109    path = Path("../data/aM_7-mode-iso" )
110    path.mkdir(parents=True, exist_ok=True)
111
112    aM = generator.generate( 
113        n_states=n_states, 
114        n_symbols=n_symbols, 
115        n_modes=n_modes, 
116        mode_alphas=[ alpha ]*n_modes,
117        residency_factor=residency_factor,
118        levels=3 )
119
120    aM.minimize(retain_names=True)
121    print( aM.is_epsilon_HMM() )
122
123    aM.draw_graph()
124
125    print( f"h_mu : {aM.h_mu()}" )
126    print( f"C_mu : {aM.C_mu()}" )