selector-complexity 0.1.0__tar.gz

selector_complexity-0.1.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: selector-complexity
+Version: 0.1.0
+Summary: Selector Complexity Framework for IPS proof complexity
+Author-email: Carmen Esteban <carmen@research.dev>
+License: MIT
+Project-URL: Homepage, https://github.com/iafiscal1212/Selector-Complexity-Framework
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.20
+Requires-Dist: scipy>=1.7

selector_complexity-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "selector-complexity"
+version = "0.1.0"
+description = "Selector Complexity Framework for IPS proof complexity"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [{name = "Carmen Esteban", email = "carmen@research.dev"}]
+requires-python = ">=3.8"
+dependencies = [
+    "numpy>=1.20",
+    "scipy>=1.7",
+]
+
+[project.urls]
+Homepage = "https://github.com/iafiscal1212/Selector-Complexity-Framework"
+
+[tool.setuptools.packages.find]
+include = ["selector_complexity*"]

selector_complexity-0.1.0/selector_complexity/__init__.py

@@ -0,0 +1,28 @@
+"""
+Selector Complexity Framework
+==============================
+
+Classifies tautologies by the complexity of their selector
+families in IPS (Ideal Proof Systems).
+
+Levels:
+  0 - Polynomial certificates, no selectors needed (e.g. PHP)
+  1 - Efficient selectors in auxiliary variables (e.g. PHP-E)
+  2+- Selectors require original variables, expensive (e.g. PHP-C)
+
+Author: Carmen Esteban
+License: MIT
+"""
+
+__version__ = "0.1.0"
+__author__ = "Carmen Esteban"
+
+from selector_complexity.core import PolynomialSystem, SelectorFamily
+from selector_complexity.php import php_axioms, phpe_axioms, phpc_axioms
+from selector_complexity.solvers import build_matrix, find_certificate
+from selector_complexity.selectors import (
+    build_phpe_selectors,
+    build_phpc_explicit_selectors,
+    enumerate_vc,
+    test_s_only_feasibility,
+)

selector_complexity-0.1.0/selector_complexity/core.py

@@ -0,0 +1,77 @@
+"""Core definitions: PolynomialSystem, SelectorFamily."""
+
+import numpy as np
+from itertools import combinations
+
+
+class PolynomialSystem:
+    """A system of polynomial equations over boolean variables."""
+
+    def __init__(self, name, num_vars, axioms):
+        self.name = name
+        self.num_vars = num_vars
+        self.axioms = axioms
+
+    def evaluate(self, assignment):
+        values = []
+        for ax in self.axioms:
+            val = 0.0
+            for coef, monom in ax:
+                prod = coef
+                for v in monom:
+                    prod *= assignment.get(v, 0)
+                val += prod
+            values.append(val)
+        return values
+
+    def is_unsatisfiable(self, max_vars=15):
+        if self.num_vars > max_vars:
+            return None
+        for bits in range(2 ** self.num_vars):
+            assignment = {v: (bits >> v) & 1 for v in range(self.num_vars)}
+            vals = self.evaluate(assignment)
+            if all(abs(v) < 1e-10 for v in vals):
+                return False
+        return True
+
+    def __repr__(self):
+        return "PolynomialSystem({}, {} vars, {} axioms)".format(
+            self.name, self.num_vars, len(self.axioms))
+
+
+class SelectorFamily:
+    """A family of selector polynomials."""
+
+    def __init__(self, selectors, var_assignments_generator):
+        self.selectors = selectors
+        self.var_gen = var_assignments_generator
+
+    def verify(self):
+        labels = list(self.selectors.keys())
+        partition_ok = exclusivity_ok = boolean_ok = total = 0
+        for assignment in self.var_gen():
+            total += 1
+            vals = {}
+            for label in labels:
+                v = sum(c * np.prod([assignment.get(var, 0) for var in m])
+                        for c, m in self.selectors[label])
+                vals[label] = v
+            if all(abs(v) < 1e-10 or abs(v - 1) < 1e-10 for v in vals.values()):
+                boolean_ok += 1
+            if abs(sum(vals.values()) - 1.0) < 1e-10:
+                partition_ok += 1
+            excl = all(abs(vals[l1] * vals[l2]) < 1e-10
+                        for i, l1 in enumerate(labels)
+                        for l2 in labels[i+1:])
+            if excl:
+                exclusivity_ok += 1
+        return {"total": total, "partition": partition_ok,
+                "exclusivity": exclusivity_ok, "boolean": boolean_ok,
+                "all_pass": partition_ok == total == exclusivity_ok == boolean_ok}
+
+    def size(self):
+        return sum(len(p) for p in self.selectors.values())
+
+    def max_degree(self):
+        return max(max((len(m) for _, m in p), default=0)
+                    for p in self.selectors.values())

selector_complexity-0.1.0/selector_complexity/php.py

@@ -0,0 +1,154 @@
+from itertools import combinations
+
+def php_axioms(n):
+    pigeons = list(range(1, n + 2))
+    holes = list(range(1, n + 1))
+    var_x = {}
+    idx = 0
+    for p in pigeons:
+        for h in holes:
+            var_x[(p, h)] = idx
+            idx += 1
+    num_vars = idx
+    axioms = []
+    for p in pigeons:
+        terms = []
+        hvars = [var_x[(p, h)] for h in holes]
+        for k in range(len(hvars) + 1):
+            sign = (-1.0) ** k
+            for subset in combinations(hvars, k):
+                terms.append((sign, frozenset(subset)))
+        axioms.append(terms)
+    for h in holes:
+        for i, p in enumerate(pigeons):
+            for p2 in pigeons[i + 1:]:
+                axioms.append([(1.0, frozenset([var_x[(p, h)], var_x[(p2, h)]]))])
+    for p in pigeons:
+        for j, h in enumerate(holes):
+            for h2 in holes[j + 1:]:
+                axioms.append([(1.0, frozenset([var_x[(p, h)], var_x[(p, h2)]]))])
+    return axioms, num_vars, var_x
+
+def phpe_axioms(n):
+    pigeons = list(range(1, n + 2))
+    holes = list(range(1, n + 1))
+    var_x, var_y = {}, {}
+    idx = 0
+    for p in pigeons:
+        for h in holes:
+            var_x[(p, h)] = idx
+            idx += 1
+    for i, p in enumerate(pigeons):
+        for p2 in pigeons[i + 1:]:
+            var_y[(p, p2)] = idx
+            idx += 1
+    num_vars = idx
+    axioms = []
+    for p in pigeons:
+        terms = []
+        hvars = [var_x[(p, h)] for h in holes]
+        for k in range(len(hvars) + 1):
+            sign = (-1.0) ** k
+            for subset in combinations(hvars, k):
+                terms.append((sign, frozenset(subset)))
+        axioms.append(terms)
+    for h in holes:
+        for i, p in enumerate(pigeons):
+            for p2 in pigeons[i + 1:]:
+                axioms.append([(1.0, frozenset([var_x[(p, h)], var_x[(p2, h)]]))])
+    for p in pigeons:
+        for j, h in enumerate(holes):
+            for h2 in holes[j + 1:]:
+                axioms.append([(1.0, frozenset([var_x[(p, h)], var_x[(p, h2)]]))])
+    for i_p, p in enumerate(pigeons):
+        for p2 in pigeons[i_p + 1:]:
+            y_idx = var_y[(p, p2)]
+            for h in holes:
+                for h2 in holes:
+                    if h == h2: continue
+                    x1, x2 = var_x[(p, h)], var_x[(p2, h2)]
+                    if h < h2:
+                        axioms.append([(1.0, frozenset([x1, x2])), (-1.0, frozenset([x1, x2,
+y_idx]))])
+                    else:
+                        axioms.append([(1.0, frozenset([x1, x2, y_idx]))])
+    for i_p, p in enumerate(pigeons):
+        for j_p, p2 in enumerate(pigeons[i_p + 1:], i_p + 1):
+            for p3 in pigeons[j_p + 1:]:
+                y12, y23, y13 = var_y[(p, p2)], var_y[(p2, p3)], var_y[(p, p3)]
+                axioms.append([(1.0, frozenset([y12, y23])), (-1.0, frozenset([y12, y23,
+y13]))])
+                axioms.append([(1.0, frozenset([y13])), (-1.0, frozenset([y12, y13])),
+                                (-1.0, frozenset([y23, y13])), (1.0, frozenset([y12, y23,
+y13]))])
+    return axioms, num_vars, var_x, var_y
+
+def phpc_axioms(n):
+    pigeons = list(range(1, n + 2))
+    holes = list(range(1, n + 1))
+    var_x, var_s = {}, {}
+    idx = 0
+    for p in pigeons:
+        for h in holes:
+            var_x[(p, h)] = idx
+            idx += 1
+    for p in pigeons:
+        for q in pigeons:
+            if p != q:
+                var_s[(p, q)] = idx
+                idx += 1
+    num_vars = idx
+    axioms = []
+    for p in pigeons:
+        terms = []
+        hvars = [var_x[(p, h)] for h in holes]
+        for k in range(len(hvars) + 1):
+            sign = (-1.0) ** k
+            for subset in combinations(hvars, k):
+                terms.append((sign, frozenset(subset)))
+        axioms.append(terms)
+    for h in holes:
+        for i, p in enumerate(pigeons):
+            for p2 in pigeons[i + 1:]:
+                axioms.append([(1.0, frozenset([var_x[(p, h)], var_x[(p2, h)]]))])
+    for p in pigeons:
+        for j, h in enumerate(holes):
+            for h2 in holes[j + 1:]:
+                axioms.append([(1.0, frozenset([var_x[(p, h)], var_x[(p, h2)]]))])
+    for p in pigeons:
+        terms = []
+        svars = [var_s[(p, q)] for q in pigeons if q != p]
+        for k in range(len(svars) + 1):
+            sign = (-1.0) ** k
+            for subset in combinations(svars, k):
+                terms.append((sign, frozenset(subset)))
+        axioms.append(terms)
+    for p in pigeons:
+        others = [q for q in pigeons if q != p]
+        for i, q in enumerate(others):
+            for q2 in others[i + 1:]:
+                axioms.append([(1.0, frozenset([var_s[(p, q)], var_s[(p, q2)]]))])
+    for q in pigeons:
+        terms = []
+        svars = [var_s[(p, q)] for p in pigeons if p != q]
+        for k in range(len(svars) + 1):
+            sign = (-1.0) ** k
+            for subset in combinations(svars, k):
+                terms.append((sign, frozenset(subset)))
+        axioms.append(terms)
+    for q in pigeons:
+        others = [p for p in pigeons if p != q]
+        for i, p in enumerate(others):
+            for p2 in others[i + 1:]:
+                axioms.append([(1.0, frozenset([var_s[(p, q)], var_s[(p2, q)]]))])
+    def succ_hole(h):
+        return (h % n) + 1
+    for p in pigeons:
+        for q in pigeons:
+            if p == q: continue
+            s_idx = var_s[(p, q)]
+            for h in holes:
+                for h2 in holes:
+                    if h2 == succ_hole(h): continue
+                    axioms.append([(1.0, frozenset([s_idx, var_x[(p, h)], var_x[(q, h2)]]))])
+    return axioms, num_vars, var_x, var_s

selector_complexity-0.1.0/selector_complexity/selectors.py

@@ -0,0 +1,68 @@
+import numpy as np
+from itertools import combinations, permutations
+
+def build_phpe_selectors(n):
+    pigeons = list(range(1, n + 2))
+    var_y = {}
+    idx = 0
+    for i, p in enumerate(pigeons):
+        for p2 in pigeons[i + 1:]:
+            var_y[(p, p2)] = idx
+            idx += 1
+    indicators = {}
+    for p in pigeons:
+        factors = []
+        for q in pigeons:
+            if q == p: continue
+            if q < p:
+                factors.append([(1.0, frozenset([var_y[(q, p)]]))])
+            else:
+                factors.append([(1.0, frozenset()), (-1.0, frozenset([var_y[(p, q)]]))])
+        result = [(1.0, frozenset())]
+        for factor in factors:
+            new_result = []
+            for c1, m1 in result:
+                for c2, m2 in factor:
+                    new_result.append((c1 * c2, m1 | m2))
+            combined = {}
+            for c, m in new_result:
+                combined[m] = combined.get(m, 0) + c
+            result = [(c, m) for m, c in combined.items() if abs(c) > 1e-15]
+        indicators[p] = result
+    return indicators, var_y
+
+def test_s_only_feasibility(n, max_degree=3):
+    pigeons = list(range(1, n + 2))
+    var_s = {}
+    idx = 0
+    for p in pigeons:
+        for q in pigeons:
+            if p != q:
+                var_s[(p, q)] = idx
+                idx += 1
+    num_s_vars = idx
+    others = pigeons[1:]
+    cycle_assignments = []
+    for perm in permutations(others):
+        cycle = (pigeons[0],) + perm
+        assignment = {}
+        for i in range(len(cycle)):
+            p, q = cycle[i], cycle[(i + 1) % len(cycle)]
+            for p2 in pigeons:
+                for q2 in pigeons:
+                    if p2 != q2:
+                        assignment[var_s[(p2, q2)]] = 1 if (p2 == p and q2 == q) else 0
+        cycle_assignments.append(assignment)
+    monoms = [frozenset()]
+    for d in range(1, max_degree + 1):
+        for combo in combinations(range(num_s_vars), d):
+            monoms.append(frozenset(combo))
+    eval_matrix = np.zeros((len(cycle_assignments), len(monoms)))
+    for i, assign in enumerate(cycle_assignments):
+        for j, monom in enumerate(monoms):
+            prod = 1.0
+            for v in monom:
+                prod *= assign.get(v, 0)
+            eval_matrix[i, j] = prod
+    unique_rows = np.unique(eval_matrix, axis=0)
+    return len(unique_rows) == 1, len(cycle_assignments), len(unique_rows)

selector_complexity-0.1.0/selector_complexity/solvers.py

@@ -0,0 +1,49 @@
+import numpy as np
+from scipy import sparse
+from scipy.sparse.linalg import lsqr
+from itertools import combinations
+
+def build_matrix(axioms, num_vars, d_max):
+    all_monoms = []
+    monom_to_idx = {}
+    for d in range(d_max + 1):
+        for combo in combinations(range(num_vars), d):
+            m = frozenset(combo)
+            monom_to_idx[m] = len(all_monoms)
+            all_monoms.append(m)
+    num_monoms = len(all_monoms)
+    rows, cols, vals = [], [], []
+    total_unknowns = 0
+    for ax in axioms:
+        deg_ax = max(len(m) for c, m in ax)
+        deg_mult = max(0, d_max - deg_ax)
+        for d in range(deg_mult + 1):
+            for combo in combinations(range(num_vars), d):
+                m_mult = frozenset(combo)
+                col = total_unknowns
+                total_unknowns += 1
+                for coef_ax, m_ax in ax:
+                    m_prod = m_mult | m_ax
+                    if len(m_prod) <= d_max and m_prod in monom_to_idx:
+                        rows.append(monom_to_idx[m_prod])
+                        cols.append(col)
+                        vals.append(coef_ax)
+    if total_unknowns == 0:
+        return sparse.csr_matrix((num_monoms, 0)), np.zeros(num_monoms), num_monoms, 0
+    A = sparse.csr_matrix((vals, (rows, cols)), shape=(num_monoms, total_unknowns))
+    b = np.zeros(num_monoms)
+    b[monom_to_idx[frozenset()]] = 1.0
+    return A, b, num_monoms, total_unknowns
+
+def find_certificate(axioms, num_vars, d_max, atol=1e-12):
+    A, b, nm, nu = build_matrix(axioms, num_vars, d_max)
+    if nu == 0:
+        return None
+    res = lsqr(A, b, atol=atol, btol=atol, iter_lim=10000)
+    x = res[0]
+    residual = np.linalg.norm(A @ x - b)
+    if residual < 1e-6:
+        size = int(np.sum(np.abs(x) > 1e-8))
+        return {"degree": d_max, "size": size, "num_monoms": nm,
+                "num_unknowns": nu, "residual": float(residual), "coefficients": x}
+    return None

selector_complexity-0.1.0/selector_complexity.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: selector-complexity
+Version: 0.1.0
+Summary: Selector Complexity Framework for IPS proof complexity
+Author-email: Carmen Esteban <carmen@research.dev>
+License: MIT
+Project-URL: Homepage, https://github.com/iafiscal1212/Selector-Complexity-Framework
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.20
+Requires-Dist: scipy>=1.7

selector_complexity-0.1.0/selector_complexity.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+pyproject.toml
+selector_complexity/__init__.py
+selector_complexity/core.py
+selector_complexity/php.py
+selector_complexity/selectors.py
+selector_complexity/solvers.py
+selector_complexity.egg-info/PKG-INFO
+selector_complexity.egg-info/SOURCES.txt
+selector_complexity.egg-info/dependency_links.txt
+selector_complexity.egg-info/requires.txt
+selector_complexity.egg-info/top_level.txt

selector_complexity-0.1.0/selector_complexity.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

selector_complexity-0.1.0/selector_complexity.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numpy>=1.20
+scipy>=1.7

selector_complexity-0.1.0/selector_complexity.egg-info/top_level.txt

@@ -0,0 +1 @@
+selector_complexity

selector_complexity-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+