Upload permutation-groups.py with huggingface_hub

permutation-groups.py

@@ -3,103 +3,67 @@ import json
 import os
 import pyarrow as pa
 
-_DESCRIPTION = "A comprehensive collection of permutation composition datasets for various mathematical groups including symmetric, alternating, cyclic, dihedral, and special groups."
+_DESCRIPTION = "Permutation composition datasets with dynamic filtering by group degree, order, and sequence length."
 _HOMEPAGE = "https://huggingface.co/datasets/BeeGass/permutation-groups"
 _LICENSE = "MIT"
 
 class PermutationGroupsConfig(datasets.BuilderConfig):
-    def __init__(self, group_name=None, max_len=512, **kwargs):
-        # Handle the name parameter
-        name = kwargs.get("name", "")
+    def __init__(
+        self, 
+        group_type=None,
+        min_degree=None,
+        max_degree=None,
+        min_order=None,
+        max_order=None,
+        min_len=3,
+        max_len=512,
+        **kwargs
+    ):
+        """
+        Configuration for loading permutation groups.
         
-        # If name is provided, parse it to get group_name and max_len
-        if name:
-            if "_data" in name:
-                # Old style: s5_data
-                group_name = name.replace("_data", "").upper()
-            elif "_len" in name:
-                # Old style: s5_len32
-                parts = name.split("_len")
-                group_name = parts[0].upper()
-                if "max_len" not in kwargs:  # Don't override if explicitly provided
-                    max_len = int(parts[1])
-            else:
-                # New style: just s5
-                group_name = name.upper() if name != "all" else "All"
-        
-        # Ensure we have a name for the config
+        Args:
+            group_type: Type of group (symmetric, alternating, cyclic, dihedral, special)
+            min_degree: Minimum group degree to include
+            max_degree: Maximum group degree to include
+            min_order: Minimum group order to include
+            max_order: Maximum group order to include
+            min_len: Minimum sequence length
+            max_len: Maximum sequence length
+        """
+        # Set name based on parameters
         if "name" not in kwargs:
-            kwargs["name"] = group_name.lower() if group_name else "default"
+            if group_type:
+                kwargs["name"] = group_type
+            else:
+                kwargs["name"] = "all"
         
         super().__init__(**kwargs)
-        self.group_name = group_name
+        self.group_type = group_type
+        self.min_degree = min_degree
+        self.max_degree = max_degree
+        self.min_order = min_order
+        self.max_order = max_order
+        self.min_len = min_len
         self.max_len = max_len
-        self.data_dir = f"data/{group_name.lower()}_data" if group_name and group_name != "All" else None
 
 class PermutationGroups(datasets.ArrowBasedBuilder):
-    """Permutation groups dataset with dynamic length filtering."""
+    """Permutation groups dataset with dynamic filtering."""
     
-    VERSION = datasets.Version("3.0.0")
+    VERSION = datasets.Version("4.0.0")
     
-    # Define all available groups
-    GROUPS = {
-        # Symmetric Groups
-        "S3": {"type": "Symmetric", "degree": 3, "order": 6},
-        "S4": {"type": "Symmetric", "degree": 4, "order": 24},
-        "S5": {"type": "Symmetric", "degree": 5, "order": 120},
-        "S6": {"type": "Symmetric", "degree": 6, "order": 720},
-        "S7": {"type": "Symmetric", "degree": 7, "order": 5040},
-        # Alternating Groups
-        "A3": {"type": "Alternating", "degree": 3, "order": 3},
-        "A4": {"type": "Alternating", "degree": 4, "order": 12},
-        "A5": {"type": "Alternating", "degree": 5, "order": 60},
-        "A6": {"type": "Alternating", "degree": 6, "order": 360},
-        "A7": {"type": "Alternating", "degree": 7, "order": 2520},
-        # Cyclic Groups
-        "C3": {"type": "Cyclic", "degree": 3, "order": 3},
-        "C4": {"type": "Cyclic", "degree": 4, "order": 4},
-        "C5": {"type": "Cyclic", "degree": 5, "order": 5},
-        "C6": {"type": "Cyclic", "degree": 6, "order": 6},
-        "C7": {"type": "Cyclic", "degree": 7, "order": 7},
-        "C8": {"type": "Cyclic", "degree": 8, "order": 8},
-        "C10": {"type": "Cyclic", "degree": 10, "order": 10},
-        "C12": {"type": "Cyclic", "degree": 12, "order": 12},
-        # Cyclic Groups (Z notation)
-        "Z3": {"type": "Cyclic", "degree": 3, "order": 3},
-        "Z4": {"type": "Cyclic", "degree": 4, "order": 4},
-        "Z5": {"type": "Cyclic", "degree": 5, "order": 5},
-        "Z6": {"type": "Cyclic", "degree": 6, "order": 6},
-        # Dihedral Groups
-        "D3": {"type": "Dihedral", "degree": 3, "order": 6},
-        "D4": {"type": "Dihedral", "degree": 4, "order": 8},
-        "D5": {"type": "Dihedral", "degree": 5, "order": 10},
-        "D6": {"type": "Dihedral", "degree": 6, "order": 12},
-        "D7": {"type": "Dihedral", "degree": 7, "order": 14},
-        "D8": {"type": "Dihedral", "degree": 8, "order": 16},
-        # Special Groups
-        "PSL25": {"type": "PSL(2,5)", "degree": 6, "order": 60},
-        "F20": {"type": "Frobenius", "degree": 5, "order": 20},
-    }
+    # Define available group types
+    GROUP_TYPES = ["symmetric", "alternating", "cyclic", "dihedral", "special"]
     
     BUILDER_CONFIGS = []
     
-    # Simple configs - just group names
-    for group_name, info in GROUPS.items():
-        BUILDER_CONFIGS.append(
-            PermutationGroupsConfig(
-                name=group_name.lower(),
-                description=f"{info['type']} Group {group_name} (order {info['order']}).",
-                group_name=group_name,
-            )
-        )
-    
-    # Keep old-style configs for backwards compatibility
-    for group_name, info in GROUPS.items():
+    # Add configs for each group type
+    for group_type in GROUP_TYPES:
         BUILDER_CONFIGS.append(
             PermutationGroupsConfig(
-                name=f"{group_name.lower()}_data",
-                description=f"{info['type']} Group {group_name} (order {info['order']}).",
-                group_name=group_name,
+                name=group_type,
+                description=f"{group_type.capitalize()} permutation groups",
+                group_type=group_type,
             )
         )
     
@@ -107,12 +71,49 @@ class PermutationGroups(datasets.ArrowBasedBuilder):
     BUILDER_CONFIGS.append(
         PermutationGroupsConfig(
             name="all",
-            description="All Permutation Composition Datasets.",
-            group_name="All",
+            description="All permutation groups",
+            group_type=None,  # Will load all types
         )
     )
     
-    DEFAULT_CONFIG_NAME = "s5_data"
+    # Keep backwards compatibility configs
+    LEGACY_GROUPS = {
+        "s3": ("symmetric", 3, 3), "s4": ("symmetric", 4, 4), "s5": ("symmetric", 5, 5),
+        "s6": ("symmetric", 6, 6), "s7": ("symmetric", 7, 7),
+        "a3": ("alternating", 3, 3), "a4": ("alternating", 4, 4), "a5": ("alternating", 5, 5),
+        "a6": ("alternating", 6, 6), "a7": ("alternating", 7, 7),
+        "c3": ("cyclic", 3, 3), "c4": ("cyclic", 4, 4), "c5": ("cyclic", 5, 5),
+        "c6": ("cyclic", 6, 6), "c7": ("cyclic", 7, 7), "c8": ("cyclic", 8, 8),
+        "c10": ("cyclic", 10, 10), "c12": ("cyclic", 12, 12),
+        "z3": ("cyclic", 3, 3), "z4": ("cyclic", 4, 4), "z5": ("cyclic", 5, 5), "z6": ("cyclic", 6, 6),
+        "d3": ("dihedral", 3, 3), "d4": ("dihedral", 4, 4), "d5": ("dihedral", 5, 5),
+        "d6": ("dihedral", 6, 6), "d7": ("dihedral", 7, 7), "d8": ("dihedral", 8, 8),
+        "psl25": ("special", 6, 6), "f20": ("special", 5, 5),
+    }
+    
+    for name, (group_type, min_deg, max_deg) in LEGACY_GROUPS.items():
+        # Simple name (e.g., "s5")
+        BUILDER_CONFIGS.append(
+            PermutationGroupsConfig(
+                name=name,
+                description=f"Legacy config for {name.upper()}",
+                group_type=group_type,
+                min_degree=min_deg,
+                max_degree=max_deg,
+            )
+        )
+        # Old style name (e.g., "s5_data")
+        BUILDER_CONFIGS.append(
+            PermutationGroupsConfig(
+                name=f"{name}_data",
+                description=f"Legacy config for {name.upper()}",
+                group_type=group_type,
+                min_degree=min_deg,
+                max_degree=max_deg,
+            )
+        )
+    
+    DEFAULT_CONFIG_NAME = "symmetric"
     
     def _info(self):
         return datasets.DatasetInfo(
@@ -120,88 +121,101 @@ class PermutationGroups(datasets.ArrowBasedBuilder):
             features=datasets.Features({
                 "input_sequence": datasets.Value("string"),
                 "target": datasets.Value("string"),
+                "group_type": datasets.Value("string"),
+                "group_degree": datasets.Value("int32"),
+                "group_order": datasets.Value("int32"),
+                "sequence_length": datasets.Value("int32"),
             }),
             homepage=_HOMEPAGE,
             license=_LICENSE,
         )
     
     def _split_generators(self, dl_manager):
-        # Handle the "all" configurations
-        if self.config.name.startswith("all"):
-            all_configs = [f"{g.lower()}_data" for g in self.GROUPS.keys()]
-            
-            # Download all base datasets
-            train_files = []
-            test_files = []
-            
-            for group_lower in all_configs:
-                data_urls = {
-                    "train": f"data/{group_lower}/train/data-00000-of-00001.arrow",
-                    "test": f"data/{group_lower}/test/data-00000-of-00001.arrow",
-                }
-                try:
-                    downloaded = dl_manager.download(data_urls)
-                    train_files.append(downloaded["train"])
-                    test_files.append(downloaded["test"])
-                except:
-                    # Skip if dataset doesn't exist
-                    pass
-            
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.TRAIN,
-                    gen_kwargs={
-                        "files": train_files,
-                        "max_len": self.config.max_len,
-                    },
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.TEST,
-                    gen_kwargs={
-                        "files": test_files,
-                        "max_len": self.config.max_len,
-                    },
-                ),
-            ]
+        # Determine which datasets to load
+        if self.config.group_type:
+            if self.config.group_type == "special":
+                # Special groups are stored separately
+                datasets_to_load = ["psl25_data", "f20_data"]
+            else:
+                # Load the superset for this group type
+                datasets_to_load = [f"{self.config.group_type}_superset"]
         else:
-            # Single configuration - always use base data
+            # Load all supersets
+            datasets_to_load = ["symmetric_superset", "alternating_superset", 
+                              "cyclic_superset", "dihedral_superset", 
+                              "psl25_data", "f20_data"]
+        
+        # Download files
+        train_files = []
+        test_files = []
+        
+        for dataset_name in datasets_to_load:
             data_urls = {
-                "train": [f"{self.config.data_dir}/train/data-00000-of-00001.arrow"],
-                "test": [f"{self.config.data_dir}/test/data-00000-of-00001.arrow"],
+                "train": f"data/{dataset_name}/train/data-*-of-*.arrow",
+                "test": f"data/{dataset_name}/test/data-*-of-*.arrow",
             }
-            
-            downloaded_files = dl_manager.download(data_urls)
-            
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.TRAIN,
-                    gen_kwargs={
-                        "files": downloaded_files["train"],
-                        "max_len": self.config.max_len,
-                    },
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.TEST,
-                    gen_kwargs={
-                        "files": downloaded_files["test"],
-                        "max_len": self.config.max_len,
-                    },
-                ),
-            ]
+            try:
+                downloaded = dl_manager.download(data_urls)
+                if isinstance(downloaded["train"], list):
+                    train_files.extend(downloaded["train"])
+                    test_files.extend(downloaded["test"])
+                else:
+                    train_files.append(downloaded["train"])
+                    test_files.append(downloaded["test"])
+            except:
+                # Skip if dataset doesn't exist
+                pass
+        
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "files": train_files,
+                    "config": self.config,
+                },
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs={
+                    "files": test_files,
+                    "config": self.config,
+                },
+            ),
+        ]
     
-    def _generate_tables(self, files, max_len):
-        """Yield arrow tables with length filtering."""
+    def _generate_tables(self, files, config):
+        """Yield arrow tables with filtering."""
         for file_idx, file in enumerate(files):
             # Load the dataset
             dataset = datasets.Dataset.from_file(file)
             
-            # Filter by sequence length if needed
-            if max_len < 512:
-                def filter_length(example):
-                    seq_len = len(example["input_sequence"].split())
-                    return seq_len <= max_len
+            # Apply filters
+            def filter_fn(example):
+                # Filter by group type (if not already filtered by file selection)
+                if config.group_type and example.get("group_type") != config.group_type:
+                    return False
                 
-                dataset = dataset.filter(filter_length)
+                # Filter by degree
+                if config.min_degree and example.get("group_degree", 0) < config.min_degree:
+                    return False
+                if config.max_degree and example.get("group_degree", float('inf')) > config.max_degree:
+                    return False
+                
+                # Filter by order
+                if config.min_order and example.get("group_order", 0) < config.min_order:
+                    return False
+                if config.max_order and example.get("group_order", float('inf')) > config.max_order:
+                    return False
+                
+                # Filter by sequence length
+                seq_len = example.get("sequence_length", len(example["input_sequence"].split()))
+                if seq_len < config.min_len or seq_len > config.max_len:
+                    return False
+                
+                return True
+            
+            # Apply filtering
+            dataset = dataset.filter(filter_fn)
             
             # Get the underlying Arrow table
             table = dataset.data.table