fina-logic-lib 0.1.0__py3-none-any.whl

fina_logic_lib-0.1.0.dist-info/METADATA

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: fina-logic-lib
+Version: 0.1.0
+Summary: Deterministic FinBench logic library (195 rules across 6 layers)
+Requires-Python: >=3.10

fina_logic_lib-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+logic_lib/__init__.py,sha256=nsfk2E9FBIpvCkmpEbwQJsq0DR4e007tmwQSRPMtOAE,244
+logic_lib/base.py,sha256=2Jf94N6ABhgN_KXUw5khTHEe4JzRRgGVX9x04HptRWQ,837
+logic_lib/composite_resolver.py,sha256=4JZ4Kr8lnaBpdc6t9FKlX4hW5LalBxMnHMmNMNO009U,14421
+logic_lib/decision_rules.py,sha256=M3hh1X9A925Ds2THR7__H6UJAvF85rmyBCqpScR6BK0,22700
+logic_lib/extraction_resolver.py,sha256=uSbzv87W8tPC46wjZU8oTDRLyY7S6FZZfGVGMRcE1tI,21084
+logic_lib/narrative_reasoner.py,sha256=u2zUyGlBvBF91r4MhqMX5bs1BnY8yk0x3jLWX9TaZvI,9768
+logic_lib/reconciliation.py,sha256=YppTb8zSzYUokSV0GmQvu4RY0FIC2OMb01aXMN_xqNg,12244
+logic_lib/registry.py,sha256=mnvkpFuN1BWSeLEQacvRU5WK00Wx51UxOy2OgiSwDJQ,1302
+logic_lib/rule_catalog.py,sha256=CoArzE_MS27rbFgemG5WsOZ1JKIkROM2p5--RghmMRA,555
+logic_lib/thresholds.py,sha256=-tDqFv9yN3cej_qgvrQ6F1D9vTumw9hbpKkzZ1EIiFo,106
+logic_lib/verifier.py,sha256=YwqMitOwavzHOIePCu5dojeFbX_XGanH8DPze1cZqX4,12315
+fina_logic_lib-0.1.0.dist-info/METADATA,sha256=Ic-wwg4FAHTN2iZCo1EEHmm99izoivjkBz9NEVC8xOs,161
+fina_logic_lib-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+fina_logic_lib-0.1.0.dist-info/top_level.txt,sha256=1kFoNKUK9YnMhQKB-qSaTfoBbXJsAPSNmTCQmDoIwjc,10
+fina_logic_lib-0.1.0.dist-info/RECORD,,

fina_logic_lib-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fina_logic_lib-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+logic_lib

logic_lib/__init__.py

@@ -0,0 +1,11 @@
+from .base import RULE_REGISTRY, RuleResult
+from .registry import fire, list_by_layer, search_rules, describe
+
+__all__ = [
+    "RULE_REGISTRY",
+    "RuleResult",
+    "fire",
+    "list_by_layer",
+    "search_rules",
+    "describe",
+]

logic_lib/base.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict
+
+
+@dataclass
+class RuleResult:
+    rule_id: str
+    rule_name: str
+    fired: bool
+    output: Any
+    branch: str = ""
+    reason: str = ""
+    confidence: float = 1.0
+    layer: str = ""
+    inputs_used: Dict[str, Any] = field(default_factory=dict)
+
+
+RULE_REGISTRY: Dict[str, Dict[str, Any]] = {}
+
+
+def rule(rid: str, name: str, layer: str, logic_desc: str) -> Callable[[Callable[..., RuleResult]], Callable[..., RuleResult]]:
+    def wrap(fn: Callable[..., RuleResult]) -> Callable[..., RuleResult]:
+        RULE_REGISTRY[rid] = {
+            "fn": fn,
+            "name": name,
+            "layer": layer,
+            "logic": logic_desc,
+        }
+        return fn
+
+    return wrap

logic_lib/composite_resolver.py

@@ -0,0 +1,199 @@
+from __future__ import annotations
+
+import re
+from typing import Any, Dict
+
+from .base import RuleResult, rule
+
+
+def _missing(inputs: Dict[str, Any]) -> bool:
+    return any(v is None for v in inputs.values())
+
+
+def _safe_float(x: Any, default: float = 0.0) -> float:
+    try:
+        return float(x)
+    except Exception:
+        return default
+
+
+def _evaluate_threshold_logic(rule_id: str, rule_name: str, layer: str, logic: str, inputs: Dict[str, Any]) -> RuleResult:
+    if _missing(inputs):
+        return RuleResult(rule_id=rule_id, rule_name=rule_name, fired=False, output="cannot determine", branch="missing_input", reason="Missing required inputs", confidence=0.6, layer=layer, inputs_used=inputs)
+
+    value = _safe_float(next(iter(inputs.values()), 0.0))
+    parts = [p.strip() for p in logic.split(";") if p.strip()]
+    for p in parts:
+        m_gt = re.match(r"^>(-?\d+(?:\.\d+)?)%?\s+(.+)$", p)
+        m_lt = re.match(r"^<(-?\d+(?:\.\d+)?)%?\s+(.+)$", p)
+        m_rng = re.match(r"^(-?\d+(?:\.\d+)?)\s*[-–]\s*(-?\d+(?:\.\d+)?)%?\s+(.+)$", p)
+        m_gte = re.match(r"^>=(-?\d+(?:\.\d+)?)\s+(.+)$", p)
+        m_lte = re.match(r"^<=(-?\d+(?:\.\d+)?)\s+(.+)$", p)
+
+        if m_gt and value > float(m_gt.group(1)):
+            return RuleResult(rule_id, rule_name, True, m_gt.group(2), f">{m_gt.group(1)}", f"value={value}", 1.0, layer, inputs)
+        if m_lt and value < float(m_lt.group(1)):
+            return RuleResult(rule_id, rule_name, True, m_lt.group(2), f"<{m_lt.group(1)}", f"value={value}", 1.0, layer, inputs)
+        if m_rng:
+            lo = float(m_rng.group(1))
+            hi = float(m_rng.group(2))
+            if lo <= value <= hi:
+                return RuleResult(rule_id, rule_name, True, m_rng.group(3), f"{lo}-{hi}", f"value={value}", 1.0, layer, inputs)
+        if m_gte and value >= float(m_gte.group(1)):
+            return RuleResult(rule_id, rule_name, True, m_gte.group(2), f">={m_gte.group(1)}", f"value={value}", 1.0, layer, inputs)
+        if m_lte and value <= float(m_lte.group(1)):
+            return RuleResult(rule_id, rule_name, True, m_lte.group(2), f"<={m_lte.group(1)}", f"value={value}", 1.0, layer, inputs)
+
+    # Fallback for non-threshold rules
+    return RuleResult(rule_id, rule_name, True, "applied", "default", logic, 0.8, layer, inputs)
+
+
+@rule('sideword_excluding', 'Side-Word: Excluding', 'L03_composite', "IF 'excluding'/'net of'/'without' THEN subtract that component")
+def sideword_excluding(**kwargs) -> RuleResult:
+    """Side-Word: Excluding. Logic: IF 'excluding'/'net of'/'without' THEN subtract that component"""
+    return _evaluate_threshold_logic('sideword_excluding', 'Side-Word: Excluding', 'L03_composite', "IF 'excluding'/'net of'/'without' THEN subtract that component", kwargs)
+
+@rule('sideword_assuming', 'Side-Word: Assuming', 'L03_composite', "IF 'assuming'/'if' THEN apply stated assumption")
+def sideword_assuming(**kwargs) -> RuleResult:
+    """Side-Word: Assuming. Logic: IF 'assuming'/'if' THEN apply stated assumption"""
+    return _evaluate_threshold_logic('sideword_assuming', 'Side-Word: Assuming', 'L03_composite', "IF 'assuming'/'if' THEN apply stated assumption", kwargs)
+
+@rule('sideword_rate_multiplier', 'Side-Word: Rate Multiplier', 'L03_composite', "IF 'Nx the rate' THEN multiply base rate by N")
+def sideword_rate_multiplier(**kwargs) -> RuleResult:
+    """Side-Word: Rate Multiplier. Logic: IF 'Nx the rate' THEN multiply base rate by N"""
+    return _evaluate_threshold_logic('sideword_rate_multiplier', 'Side-Word: Rate Multiplier', 'L03_composite', "IF 'Nx the rate' THEN multiply base rate by N", kwargs)
+
+@rule('sideword_same_as', 'Side-Word: Same As', 'L03_composite', "IF 'same rate/pace as' THEN reuse prior computed rate")
+def sideword_same_as(**kwargs) -> RuleResult:
+    """Side-Word: Same As. Logic: IF 'same rate/pace as' THEN reuse prior computed rate"""
+    return _evaluate_threshold_logic('sideword_same_as', 'Side-Word: Same As', 'L03_composite', "IF 'same rate/pace as' THEN reuse prior computed rate", kwargs)
+
+@rule('sideword_between', 'Side-Word: Between', 'L03_composite', "IF 'between X and Y' THEN define period window")
+def sideword_between(**kwargs) -> RuleResult:
+    """Side-Word: Between. Logic: IF 'between X and Y' THEN define period window"""
+    return _evaluate_threshold_logic('sideword_between', 'Side-Word: Between', 'L03_composite', "IF 'between X and Y' THEN define period window", kwargs)
+
+@rule('sideword_per', 'Side-Word: Per', 'L03_composite', "IF 'per share/employee/store' THEN divide by count")
+def sideword_per(**kwargs) -> RuleResult:
+    """Side-Word: Per. Logic: IF 'per share/employee/store' THEN divide by count"""
+    return _evaluate_threshold_logic('sideword_per', 'Side-Word: Per', 'L03_composite', "IF 'per share/employee/store' THEN divide by count", kwargs)
+
+@rule('sideword_compared_to', 'Side-Word: Compared To', 'L03_composite', "IF 'compared to/vs' THEN set comparison operand")
+def sideword_compared_to(**kwargs) -> RuleResult:
+    """Side-Word: Compared To. Logic: IF 'compared to/vs' THEN set comparison operand"""
+    return _evaluate_threshold_logic('sideword_compared_to', 'Side-Word: Compared To', 'L03_composite', "IF 'compared to/vs' THEN set comparison operand", kwargs)
+
+@rule('sideword_change_in', 'Side-Word: Change In', 'L03_composite', "IF 'change in/growth in' THEN compute difference")
+def sideword_change_in(**kwargs) -> RuleResult:
+    """Side-Word: Change In. Logic: IF 'change in/growth in' THEN compute difference"""
+    return _evaluate_threshold_logic('sideword_change_in', 'Side-Word: Change In', 'L03_composite', "IF 'change in/growth in' THEN compute difference", kwargs)
+
+@rule('sideword_average_of', 'Side-Word: Average Of', 'L03_composite', "IF 'average/mean of' THEN collect and average")
+def sideword_average_of(**kwargs) -> RuleResult:
+    """Side-Word: Average Of. Logic: IF 'average/mean of' THEN collect and average"""
+    return _evaluate_threshold_logic('sideword_average_of', 'Side-Word: Average Of', 'L03_composite', "IF 'average/mean of' THEN collect and average", kwargs)
+
+@rule('sideword_negation', 'Side-Word: Negation', 'L03_composite', "IF 'not'/'excluding' THEN invert logic")
+def sideword_negation(**kwargs) -> RuleResult:
+    """Side-Word: Negation. Logic: IF 'not'/'excluding' THEN invert logic"""
+    return _evaluate_threshold_logic('sideword_negation', 'Side-Word: Negation', 'L03_composite', "IF 'not'/'excluding' THEN invert logic", kwargs)
+
+@rule('decompose_compound', 'Decompose Compound Question', 'L03_composite', 'Parse conjunctions into ordered sub-tasks')
+def decompose_compound(**kwargs) -> RuleResult:
+    """Decompose Compound Question. Logic: Parse conjunctions into ordered sub-tasks"""
+    return _evaluate_threshold_logic('decompose_compound', 'Decompose Compound Question', 'L03_composite', 'Parse conjunctions into ordered sub-tasks', kwargs)
+
+@rule('build_dependency_graph', 'Build Dependency Graph', 'L03_composite', 'Construct DAG of formula inputs/outputs')
+def build_dependency_graph(**kwargs) -> RuleResult:
+    """Build Dependency Graph. Logic: Construct DAG of formula inputs/outputs"""
+    return _evaluate_threshold_logic('build_dependency_graph', 'Build Dependency Graph', 'L03_composite', 'Construct DAG of formula inputs/outputs', kwargs)
+
+@rule('topological_sort', 'Topological Solve Order', 'L03_composite', 'Sort DAG so inputs computed before use')
+def topological_sort(**kwargs) -> RuleResult:
+    """Topological Solve Order. Logic: Sort DAG so inputs computed before use"""
+    return _evaluate_threshold_logic('topological_sort', 'Topological Solve Order', 'L03_composite', 'Sort DAG so inputs computed before use', kwargs)
+
+@rule('single_value_anchor', 'Single-Value Anchor', 'L03_composite', 'Identify the seed value the chain depends on')
+def single_value_anchor(**kwargs) -> RuleResult:
+    """Single-Value Anchor. Logic: Identify the seed value the chain depends on"""
+    return _evaluate_threshold_logic('single_value_anchor', 'Single-Value Anchor', 'L03_composite', 'Identify the seed value the chain depends on', kwargs)
+
+@rule('chain_extract_compute', 'Extract-Compute Chain', 'L03_composite', 'Pipeline: extract inputs -> apply formula -> output')
+def chain_extract_compute(**kwargs) -> RuleResult:
+    """Extract-Compute Chain. Logic: Pipeline: extract inputs -> apply formula -> output"""
+    return _evaluate_threshold_logic('chain_extract_compute', 'Extract-Compute Chain', 'L03_composite', 'Pipeline: extract inputs -> apply formula -> output', kwargs)
+
+@rule('sub_formula_match', 'Sub-Formula Matching', 'L03_composite', 'Map detected hints to maths_lib formula IDs')
+def sub_formula_match(**kwargs) -> RuleResult:
+    """Sub-Formula Matching. Logic: Map detected hints to maths_lib formula IDs"""
+    return _evaluate_threshold_logic('sub_formula_match', 'Sub-Formula Matching', 'L03_composite', 'Map detected hints to maths_lib formula IDs', kwargs)
+
+@rule('intermediate_carry', 'Intermediate Result Carry', 'L03_composite', 'Output of step N becomes input of step N+1')
+def intermediate_carry(**kwargs) -> RuleResult:
+    """Intermediate Result Carry. Logic: Output of step N becomes input of step N+1"""
+    return _evaluate_threshold_logic('intermediate_carry', 'Intermediate Result Carry', 'L03_composite', 'Output of step N becomes input of step N+1', kwargs)
+
+@rule('multi_year_chain', 'Multi-Year Chain', 'L03_composite', 'Collect each year, then aggregate/compare')
+def multi_year_chain(**kwargs) -> RuleResult:
+    """Multi-Year Chain. Logic: Collect each year, then aggregate/compare"""
+    return _evaluate_threshold_logic('multi_year_chain', 'Multi-Year Chain', 'L03_composite', 'Collect each year, then aggregate/compare', kwargs)
+
+@rule('ratio_of_ratios', 'Ratio of Ratios', 'L03_composite', 'Compute inner ratios then outer')
+def ratio_of_ratios(**kwargs) -> RuleResult:
+    """Ratio of Ratios. Logic: Compute inner ratios then outer"""
+    return _evaluate_threshold_logic('ratio_of_ratios', 'Ratio of Ratios', 'L03_composite', 'Compute inner ratios then outer', kwargs)
+
+@rule('conditional_branch', 'Conditional Branch', 'L03_composite', 'IF condition THEN path A ELSE path B')
+def conditional_branch(**kwargs) -> RuleResult:
+    """Conditional Branch. Logic: IF condition THEN path A ELSE path B"""
+    return _evaluate_threshold_logic('conditional_branch', 'Conditional Branch', 'L03_composite', 'IF condition THEN path A ELSE path B', kwargs)
+
+@rule('unit_propagation', 'Unit Propagation', 'L03_composite', 'Carry and reconcile units across steps')
+def unit_propagation(**kwargs) -> RuleResult:
+    """Unit Propagation. Logic: Carry and reconcile units across steps"""
+    return _evaluate_threshold_logic('unit_propagation', 'Unit Propagation', 'L03_composite', 'Carry and reconcile units across steps', kwargs)
+
+@rule('assumption_injection', 'Assumption Injection', 'L03_composite', "Add 'assuming X' values to input set")
+def assumption_injection(**kwargs) -> RuleResult:
+    """Assumption Injection. Logic: Add 'assuming X' values to input set"""
+    return _evaluate_threshold_logic('assumption_injection', 'Assumption Injection', 'L03_composite', "Add 'assuming X' values to input set", kwargs)
+
+@rule('two_stage_growth', 'Two-Stage Growth Chain', 'L03_composite', 'Stage1 rate for years 1-n, stage2 after')
+def two_stage_growth(**kwargs) -> RuleResult:
+    """Two-Stage Growth Chain. Logic: Stage1 rate for years 1-n, stage2 after"""
+    return _evaluate_threshold_logic('two_stage_growth', 'Two-Stage Growth Chain', 'L03_composite', 'Stage1 rate for years 1-n, stage2 after', kwargs)
+
+@rule('forecast_chain', 'Forecast Chain', 'L03_composite', 'Grow base by rate then apply formula')
+def forecast_chain(**kwargs) -> RuleResult:
+    """Forecast Chain. Logic: Grow base by rate then apply formula"""
+    return _evaluate_threshold_logic('forecast_chain', 'Forecast Chain', 'L03_composite', 'Grow base by rate then apply formula', kwargs)
+
+@rule('backsolve', 'Back-Solve', 'L03_composite', 'Given output, invert formula for missing input')
+def backsolve(**kwargs) -> RuleResult:
+    """Back-Solve. Logic: Given output, invert formula for missing input"""
+    return _evaluate_threshold_logic('backsolve', 'Back-Solve', 'L03_composite', 'Given output, invert formula for missing input', kwargs)
+
+@rule('scenario_branch', 'Scenario Branch', 'L03_composite', 'Run chain under bull/base/bear inputs')
+def scenario_branch(**kwargs) -> RuleResult:
+    """Scenario Branch. Logic: Run chain under bull/base/bear inputs"""
+    return _evaluate_threshold_logic('scenario_branch', 'Scenario Branch', 'L03_composite', 'Run chain under bull/base/bear inputs', kwargs)
+
+@rule('aggregate_then_ratio', 'Aggregate Then Ratio', 'L03_composite', 'Sum parts, then compute ratio on totals')
+def aggregate_then_ratio(**kwargs) -> RuleResult:
+    """Aggregate Then Ratio. Logic: Sum parts, then compute ratio on totals"""
+    return _evaluate_threshold_logic('aggregate_then_ratio', 'Aggregate Then Ratio', 'L03_composite', 'Sum parts, then compute ratio on totals', kwargs)
+
+@rule('difference_then_pct', 'Difference Then Percent', 'L03_composite', 'Compute delta, then express as percent')
+def difference_then_pct(**kwargs) -> RuleResult:
+    """Difference Then Percent. Logic: Compute delta, then express as percent"""
+    return _evaluate_threshold_logic('difference_then_pct', 'Difference Then Percent', 'L03_composite', 'Compute delta, then express as percent', kwargs)
+
+@rule('weighted_combine', 'Weighted Combine', 'L03_composite', 'Sum(weight_i * result_i)')
+def weighted_combine(**kwargs) -> RuleResult:
+    """Weighted Combine. Logic: Sum(weight_i * result_i)"""
+    return _evaluate_threshold_logic('weighted_combine', 'Weighted Combine', 'L03_composite', 'Sum(weight_i * result_i)', kwargs)
+
+@rule('self_consistency_3path', '3-Path Self-Consistency', 'L03_composite', 'Compute by 3 decompositions; agree=confident')
+def self_consistency_3path(**kwargs) -> RuleResult:
+    """3-Path Self-Consistency. Logic: Compute by 3 decompositions; agree=confident"""
+    return _evaluate_threshold_logic('self_consistency_3path', '3-Path Self-Consistency', 'L03_composite', 'Compute by 3 decompositions; agree=confident', kwargs)

logic_lib/decision_rules.py

@@ -0,0 +1,299 @@
+from __future__ import annotations
+
+import re
+from typing import Any, Dict
+
+from .base import RuleResult, rule
+
+
+def _missing(inputs: Dict[str, Any]) -> bool:
+    return any(v is None for v in inputs.values())
+
+
+def _safe_float(x: Any, default: float = 0.0) -> float:
+    try:
+        return float(x)
+    except Exception:
+        return default
+
+
+def _evaluate_threshold_logic(rule_id: str, rule_name: str, layer: str, logic: str, inputs: Dict[str, Any]) -> RuleResult:
+    if _missing(inputs):
+        return RuleResult(rule_id=rule_id, rule_name=rule_name, fired=False, output="cannot determine", branch="missing_input", reason="Missing required inputs", confidence=0.6, layer=layer, inputs_used=inputs)
+
+    value = _safe_float(next(iter(inputs.values()), 0.0))
+    parts = [p.strip() for p in logic.split(";") if p.strip()]
+    for p in parts:
+        m_gt = re.match(r"^>(-?\d+(?:\.\d+)?)%?\s+(.+)$", p)
+        m_lt = re.match(r"^<(-?\d+(?:\.\d+)?)%?\s+(.+)$", p)
+        m_rng = re.match(r"^(-?\d+(?:\.\d+)?)\s*[-–]\s*(-?\d+(?:\.\d+)?)%?\s+(.+)$", p)
+        m_gte = re.match(r"^>=(-?\d+(?:\.\d+)?)\s+(.+)$", p)
+        m_lte = re.match(r"^<=(-?\d+(?:\.\d+)?)\s+(.+)$", p)
+
+        if m_gt and value > float(m_gt.group(1)):
+            return RuleResult(rule_id, rule_name, True, m_gt.group(2), f">{m_gt.group(1)}", f"value={value}", 1.0, layer, inputs)
+        if m_lt and value < float(m_lt.group(1)):
+            return RuleResult(rule_id, rule_name, True, m_lt.group(2), f"<{m_lt.group(1)}", f"value={value}", 1.0, layer, inputs)
+        if m_rng:
+            lo = float(m_rng.group(1))
+            hi = float(m_rng.group(2))
+            if lo <= value <= hi:
+                return RuleResult(rule_id, rule_name, True, m_rng.group(3), f"{lo}-{hi}", f"value={value}", 1.0, layer, inputs)
+        if m_gte and value >= float(m_gte.group(1)):
+            return RuleResult(rule_id, rule_name, True, m_gte.group(2), f">={m_gte.group(1)}", f"value={value}", 1.0, layer, inputs)
+        if m_lte and value <= float(m_lte.group(1)):
+            return RuleResult(rule_id, rule_name, True, m_lte.group(2), f"<={m_lte.group(1)}", f"value={value}", 1.0, layer, inputs)
+
+    # Fallback for non-threshold rules
+    return RuleResult(rule_id, rule_name, True, "applied", "default", logic, 0.8, layer, inputs)
+
+
+@rule('liquidity_current_ratio', 'Liquidity by Current Ratio', 'L02_decision', '>2.0 very healthy; 1.5-2.0 healthy; 1.0-1.5 adequate; <1.0 concern')
+def liquidity_current_ratio(**kwargs) -> RuleResult:
+    """Liquidity by Current Ratio. Logic: >2.0 very healthy; 1.5-2.0 healthy; 1.0-1.5 adequate; <1.0 concern"""
+    return _evaluate_threshold_logic('liquidity_current_ratio', 'Liquidity by Current Ratio', 'L02_decision', '>2.0 very healthy; 1.5-2.0 healthy; 1.0-1.5 adequate; <1.0 concern', kwargs)
+
+@rule('liquidity_quick_ratio', 'Liquidity by Quick Ratio', 'L02_decision', '>1.0 strong; 0.7-1.0 acceptable; <0.7 tight')
+def liquidity_quick_ratio(**kwargs) -> RuleResult:
+    """Liquidity by Quick Ratio. Logic: >1.0 strong; 0.7-1.0 acceptable; <0.7 tight"""
+    return _evaluate_threshold_logic('liquidity_quick_ratio', 'Liquidity by Quick Ratio', 'L02_decision', '>1.0 strong; 0.7-1.0 acceptable; <0.7 tight', kwargs)
+
+@rule('liquidity_cash_ratio', 'Cash Liquidity', 'L02_decision', '>0.5 strong; 0.2-0.5 moderate; <0.2 thin')
+def liquidity_cash_ratio(**kwargs) -> RuleResult:
+    """Cash Liquidity. Logic: >0.5 strong; 0.2-0.5 moderate; <0.2 thin"""
+    return _evaluate_threshold_logic('liquidity_cash_ratio', 'Cash Liquidity', 'L02_decision', '>0.5 strong; 0.2-0.5 moderate; <0.2 thin', kwargs)
+
+@rule('liquidity_composite', 'Composite Liquidity', 'L02_decision', 'Weighted classification across 3 ratios')
+def liquidity_composite(**kwargs) -> RuleResult:
+    """Composite Liquidity. Logic: Weighted classification across 3 ratios"""
+    return _evaluate_threshold_logic('liquidity_composite', 'Composite Liquidity', 'L02_decision', 'Weighted classification across 3 ratios', kwargs)
+
+@rule('capital_intensity_class', 'Capital Intensity Class', 'L02_decision', '>15% highly; 5-15% moderately; <5% not capital-intensive')
+def capital_intensity_class(**kwargs) -> RuleResult:
+    """Capital Intensity Class. Logic: >15% highly; 5-15% moderately; <5% not capital-intensive"""
+    return _evaluate_threshold_logic('capital_intensity_class', 'Capital Intensity Class', 'L02_decision', '>15% highly; 5-15% moderately; <5% not capital-intensive', kwargs)
+
+@rule('leverage_debt_ebitda', 'Leverage by Debt/EBITDA', 'L02_decision', '<1 conservative; 1-3 moderate; 3-4 elevated; >4 high')
+def leverage_debt_ebitda(**kwargs) -> RuleResult:
+    """Leverage by Debt/EBITDA. Logic: <1 conservative; 1-3 moderate; 3-4 elevated; >4 high"""
+    return _evaluate_threshold_logic('leverage_debt_ebitda', 'Leverage by Debt/EBITDA', 'L02_decision', '<1 conservative; 1-3 moderate; 3-4 elevated; >4 high', kwargs)
+
+@rule('leverage_debt_equity', 'Leverage by D/E', 'L02_decision', '<0.5 low; 0.5-1.5 moderate; >1.5 high')
+def leverage_debt_equity(**kwargs) -> RuleResult:
+    """Leverage by D/E. Logic: <0.5 low; 0.5-1.5 moderate; >1.5 high"""
+    return _evaluate_threshold_logic('leverage_debt_equity', 'Leverage by D/E', 'L02_decision', '<0.5 low; 0.5-1.5 moderate; >1.5 high', kwargs)
+
+@rule('solvency_interest_coverage', 'Interest Coverage Health', 'L02_decision', '>5 strong; 2-5 adequate; 1.5-2 weak; <1.5 risk')
+def solvency_interest_coverage(**kwargs) -> RuleResult:
+    """Interest Coverage Health. Logic: >5 strong; 2-5 adequate; 1.5-2 weak; <1.5 risk"""
+    return _evaluate_threshold_logic('solvency_interest_coverage', 'Interest Coverage Health', 'L02_decision', '>5 strong; 2-5 adequate; 1.5-2 weak; <1.5 risk', kwargs)
+
+@rule('solvency_dscr', 'DSCR Health', 'L02_decision', '>1.5 healthy; 1.0-1.5 tight; <1.0 default risk')
+def solvency_dscr(**kwargs) -> RuleResult:
+    """DSCR Health. Logic: >1.5 healthy; 1.0-1.5 tight; <1.0 default risk"""
+    return _evaluate_threshold_logic('solvency_dscr', 'DSCR Health', 'L02_decision', '>1.5 healthy; 1.0-1.5 tight; <1.0 default risk', kwargs)
+
+@rule('profitability_net_margin', 'Net Margin Quality', 'L02_decision', '>20% excellent; 10-20% good; 0-10% modest; <0 loss')
+def profitability_net_margin(**kwargs) -> RuleResult:
+    """Net Margin Quality. Logic: >20% excellent; 10-20% good; 0-10% modest; <0 loss"""
+    return _evaluate_threshold_logic('profitability_net_margin', 'Net Margin Quality', 'L02_decision', '>20% excellent; 10-20% good; 0-10% modest; <0 loss', kwargs)
+
+@rule('profitability_roe', 'ROE Quality', 'L02_decision', '>20% excellent; 10-20% good; <10% weak')
+def profitability_roe(**kwargs) -> RuleResult:
+    """ROE Quality. Logic: >20% excellent; 10-20% good; <10% weak"""
+    return _evaluate_threshold_logic('profitability_roe', 'ROE Quality', 'L02_decision', '>20% excellent; 10-20% good; <10% weak', kwargs)
+
+@rule('profitability_roic_wacc', 'ROIC vs WACC', 'L02_decision', 'IF ROIC > WACC THEN creating value ELSE destroying')
+def profitability_roic_wacc(**kwargs) -> RuleResult:
+    """ROIC vs WACC. Logic: IF ROIC > WACC THEN creating value ELSE destroying"""
+    return _evaluate_threshold_logic('profitability_roic_wacc', 'ROIC vs WACC', 'L02_decision', 'IF ROIC > WACC THEN creating value ELSE destroying', kwargs)
+
+@rule('margin_direction', 'Margin Direction', 'L02_decision', 'IF current > prior THEN improved ELSE worsened (by pp)')
+def margin_direction(**kwargs) -> RuleResult:
+    """Margin Direction. Logic: IF current > prior THEN improved ELSE worsened (by pp)"""
+    return _evaluate_threshold_logic('margin_direction', 'Margin Direction', 'L02_decision', 'IF current > prior THEN improved ELSE worsened (by pp)', kwargs)
+
+@rule('growth_direction', 'Growth Direction', 'L02_decision', 'IF current > prior THEN growing ELSE declining')
+def growth_direction(**kwargs) -> RuleResult:
+    """Growth Direction. Logic: IF current > prior THEN growing ELSE declining"""
+    return _evaluate_threshold_logic('growth_direction', 'Growth Direction', 'L02_decision', 'IF current > prior THEN growing ELSE declining', kwargs)
+
+@rule('growth_acceleration', 'Growth Acceleration', 'L02_decision', 'IF growth_rate_now > growth_rate_prior THEN accelerating')
+def growth_acceleration(**kwargs) -> RuleResult:
+    """Growth Acceleration. Logic: IF growth_rate_now > growth_rate_prior THEN accelerating"""
+    return _evaluate_threshold_logic('growth_acceleration', 'Growth Acceleration', 'L02_decision', 'IF growth_rate_now > growth_rate_prior THEN accelerating', kwargs)
+
+@rule('trend_three_period', 'Three-Period Trend', 'L02_decision', 'Compare 3 consecutive: rising/falling/stable/volatile')
+def trend_three_period(**kwargs) -> RuleResult:
+    """Three-Period Trend. Logic: Compare 3 consecutive: rising/falling/stable/volatile"""
+    return _evaluate_threshold_logic('trend_three_period', 'Three-Period Trend', 'L02_decision', 'Compare 3 consecutive: rising/falling/stable/volatile', kwargs)
+
+@rule('dividend_sustainability', 'Dividend Sustainability', 'L02_decision', 'IF payout < 60% THEN sustainable; 60-90% watch; >90% at-risk')
+def dividend_sustainability(**kwargs) -> RuleResult:
+    """Dividend Sustainability. Logic: IF payout < 60% THEN sustainable; 60-90% watch; >90% at-risk"""
+    return _evaluate_threshold_logic('dividend_sustainability', 'Dividend Sustainability', 'L02_decision', 'IF payout < 60% THEN sustainable; 60-90% watch; >90% at-risk', kwargs)
+
+@rule('dividend_stability', 'Dividend Stability', 'L02_decision', 'IF dividends non-decreasing over N years THEN stable')
+def dividend_stability(**kwargs) -> RuleResult:
+    """Dividend Stability. Logic: IF dividends non-decreasing over N years THEN stable"""
+    return _evaluate_threshold_logic('dividend_stability', 'Dividend Stability', 'L02_decision', 'IF dividends non-decreasing over N years THEN stable', kwargs)
+
+@rule('efficiency_ccc', 'Cash Conversion Cycle Health', 'L02_decision', '<0 excellent; 0-30 strong; 30-60 normal; >60 slow')
+def efficiency_ccc(**kwargs) -> RuleResult:
+    """Cash Conversion Cycle Health. Logic: <0 excellent; 0-30 strong; 30-60 normal; >60 slow"""
+    return _evaluate_threshold_logic('efficiency_ccc', 'Cash Conversion Cycle Health', 'L02_decision', '<0 excellent; 0-30 strong; 30-60 normal; >60 slow', kwargs)
+
+@rule('efficiency_inventory_turn', 'Inventory Turnover Health', 'L02_decision', 'Industry-relative: higher = better')
+def efficiency_inventory_turn(**kwargs) -> RuleResult:
+    """Inventory Turnover Health. Logic: Industry-relative: higher = better"""
+    return _evaluate_threshold_logic('efficiency_inventory_turn', 'Inventory Turnover Health', 'L02_decision', 'Industry-relative: higher = better', kwargs)
+
+@rule('peer_comparison_better', 'Peer Comparison', 'L02_decision', 'Compare metric vs peer with direction awareness')
+def peer_comparison_better(**kwargs) -> RuleResult:
+    """Peer Comparison. Logic: Compare metric vs peer with direction awareness"""
+    return _evaluate_threshold_logic('peer_comparison_better', 'Peer Comparison', 'L02_decision', 'Compare metric vs peer with direction awareness', kwargs)
+
+@rule('peer_rank', 'Peer Ranking', 'L02_decision', 'Sort and return position')
+def peer_rank(**kwargs) -> RuleResult:
+    """Peer Ranking. Logic: Sort and return position"""
+    return _evaluate_threshold_logic('peer_rank', 'Peer Ranking', 'L02_decision', 'Sort and return position', kwargs)
+
+@rule('yes_no_threshold', 'Generic Yes/No Threshold', 'L02_decision', 'IF value [op] threshold THEN yes ELSE no')
+def yes_no_threshold(**kwargs) -> RuleResult:
+    """Generic Yes/No Threshold. Logic: IF value [op] threshold THEN yes ELSE no"""
+    return _evaluate_threshold_logic('yes_no_threshold', 'Generic Yes/No Threshold', 'L02_decision', 'IF value [op] threshold THEN yes ELSE no', kwargs)
+
+@rule('cannot_determine', 'Cannot Determine', 'L02_decision', "IF required inputs missing THEN 'cannot determine'")
+def cannot_determine(**kwargs) -> RuleResult:
+    """Cannot Determine. Logic: IF required inputs missing THEN 'cannot determine'"""
+    return _evaluate_threshold_logic('cannot_determine', 'Cannot Determine', 'L02_decision', "IF required inputs missing THEN 'cannot determine'", kwargs)
+
+@rule('materiality_check', 'Materiality Check', 'L02_decision', 'IF abs(change) > 5% of base THEN material')
+def materiality_check(**kwargs) -> RuleResult:
+    """Materiality Check. Logic: IF abs(change) > 5% of base THEN material"""
+    return _evaluate_threshold_logic('materiality_check', 'Materiality Check', 'L02_decision', 'IF abs(change) > 5% of base THEN material', kwargs)
+
+@rule('concentration_risk', 'Concentration Risk', 'L02_decision', 'IF top share > 10% THEN concentration risk flag')
+def concentration_risk(**kwargs) -> RuleResult:
+    """Concentration Risk. Logic: IF top share > 10% THEN concentration risk flag"""
+    return _evaluate_threshold_logic('concentration_risk', 'Concentration Risk', 'L02_decision', 'IF top share > 10% THEN concentration risk flag', kwargs)
+
+@rule('altman_zone', 'Altman Z Zone', 'L02_decision', '>2.99 safe; 1.81-2.99 grey; <1.81 distress')
+def altman_zone(**kwargs) -> RuleResult:
+    """Altman Z Zone. Logic: >2.99 safe; 1.81-2.99 grey; <1.81 distress"""
+    return _evaluate_threshold_logic('altman_zone', 'Altman Z Zone', 'L02_decision', '>2.99 safe; 1.81-2.99 grey; <1.81 distress', kwargs)
+
+@rule('piotroski_strength', 'Piotroski Strength', 'L02_decision', '>=8 strong; 4-7 moderate; <=3 weak')
+def piotroski_strength(**kwargs) -> RuleResult:
+    """Piotroski Strength. Logic: >=8 strong; 4-7 moderate; <=3 weak"""
+    return _evaluate_threshold_logic('piotroski_strength', 'Piotroski Strength', 'L02_decision', '>=8 strong; 4-7 moderate; <=3 weak', kwargs)
+
+@rule('revenue_quality', 'Revenue Quality', 'L02_decision', 'IF recurring share > 70% THEN high quality')
+def revenue_quality(**kwargs) -> RuleResult:
+    """Revenue Quality. Logic: IF recurring share > 70% THEN high quality"""
+    return _evaluate_threshold_logic('revenue_quality', 'Revenue Quality', 'L02_decision', 'IF recurring share > 70% THEN high quality', kwargs)
+
+@rule('earnings_quality_flag', 'Earnings Quality Flag', 'L02_decision', 'IF cash_conversion < 0.8 THEN low quality flag')
+def earnings_quality_flag(**kwargs) -> RuleResult:
+    """Earnings Quality Flag. Logic: IF cash_conversion < 0.8 THEN low quality flag"""
+    return _evaluate_threshold_logic('earnings_quality_flag', 'Earnings Quality Flag', 'L02_decision', 'IF cash_conversion < 0.8 THEN low quality flag', kwargs)
+
+@rule('working_capital_health', 'Working Capital Health', 'L02_decision', 'IF WC > 0 AND current_ratio > 1.2 THEN healthy')
+def working_capital_health(**kwargs) -> RuleResult:
+    """Working Capital Health. Logic: IF WC > 0 AND current_ratio > 1.2 THEN healthy"""
+    return _evaluate_threshold_logic('working_capital_health', 'Working Capital Health', 'L02_decision', 'IF WC > 0 AND current_ratio > 1.2 THEN healthy', kwargs)
+
+@rule('debt_maturity_risk', 'Debt Maturity Risk', 'L02_decision', 'IF ST_debt / total_debt > 40% THEN refinancing risk')
+def debt_maturity_risk(**kwargs) -> RuleResult:
+    """Debt Maturity Risk. Logic: IF ST_debt / total_debt > 40% THEN refinancing risk"""
+    return _evaluate_threshold_logic('debt_maturity_risk', 'Debt Maturity Risk', 'L02_decision', 'IF ST_debt / total_debt > 40% THEN refinancing risk', kwargs)
+
+@rule('margin_vs_peer', 'Margin vs Peer', 'L02_decision', 'Compare margin to peer median')
+def margin_vs_peer(**kwargs) -> RuleResult:
+    """Margin vs Peer. Logic: Compare margin to peer median"""
+    return _evaluate_threshold_logic('margin_vs_peer', 'Margin vs Peer', 'L02_decision', 'Compare margin to peer median', kwargs)
+
+@rule('size_classification', 'Size Classification', 'L02_decision', '>200B mega; 10-200B large; 2-10B mid; <2B small')
+def size_classification(**kwargs) -> RuleResult:
+    """Size Classification. Logic: >200B mega; 10-200B large; 2-10B mid; <2B small"""
+    return _evaluate_threshold_logic('size_classification', 'Size Classification', 'L02_decision', '>200B mega; 10-200B large; 2-10B mid; <2B small', kwargs)
+
+@rule('valuation_pe_signal', 'P/E Signal', 'L02_decision', 'Compare P/E to sector median')
+def valuation_pe_signal(**kwargs) -> RuleResult:
+    """P/E Signal. Logic: Compare P/E to sector median"""
+    return _evaluate_threshold_logic('valuation_pe_signal', 'P/E Signal', 'L02_decision', 'Compare P/E to sector median', kwargs)
+
+@rule('growth_vs_value', 'Growth vs Value', 'L02_decision', 'High P/E + high growth = growth; low P/E = value')
+def growth_vs_value(**kwargs) -> RuleResult:
+    """Growth vs Value. Logic: High P/E + high growth = growth; low P/E = value"""
+    return _evaluate_threshold_logic('growth_vs_value', 'Growth vs Value', 'L02_decision', 'High P/E + high growth = growth; low P/E = value', kwargs)
+
+@rule('fcf_positive', 'FCF Positivity', 'L02_decision', 'IF FCF > 0 AND growing THEN healthy cash generation')
+def fcf_positive(**kwargs) -> RuleResult:
+    """FCF Positivity. Logic: IF FCF > 0 AND growing THEN healthy cash generation"""
+    return _evaluate_threshold_logic('fcf_positive', 'FCF Positivity', 'L02_decision', 'IF FCF > 0 AND growing THEN healthy cash generation', kwargs)
+
+@rule('buyback_vs_dividend', 'Capital Return Mix', 'L02_decision', 'Compare buyback yield to dividend yield')
+def buyback_vs_dividend(**kwargs) -> RuleResult:
+    """Capital Return Mix. Logic: Compare buyback yield to dividend yield"""
+    return _evaluate_threshold_logic('buyback_vs_dividend', 'Capital Return Mix', 'L02_decision', 'Compare buyback yield to dividend yield', kwargs)
+
+@rule('tax_rate_normal', 'Tax Rate Normality', 'L02_decision', 'IF 15-30% THEN normal; outliers flagged')
+def tax_rate_normal(**kwargs) -> RuleResult:
+    """Tax Rate Normality. Logic: IF 15-30% THEN normal; outliers flagged"""
+    return _evaluate_threshold_logic('tax_rate_normal', 'Tax Rate Normality', 'L02_decision', 'IF 15-30% THEN normal; outliers flagged', kwargs)
+
+@rule('operating_leverage_signal', 'Operating Leverage Signal', 'L02_decision', 'IF DOL > 2 THEN high operating leverage')
+def operating_leverage_signal(**kwargs) -> RuleResult:
+    """Operating Leverage Signal. Logic: IF DOL > 2 THEN high operating leverage"""
+    return _evaluate_threshold_logic('operating_leverage_signal', 'Operating Leverage Signal', 'L02_decision', 'IF DOL > 2 THEN high operating leverage', kwargs)
+
+@rule('seasonality_flag', 'Seasonality Flag', 'L02_decision', 'IF quarterly variance high THEN seasonal')
+def seasonality_flag(**kwargs) -> RuleResult:
+    """Seasonality Flag. Logic: IF quarterly variance high THEN seasonal"""
+    return _evaluate_threshold_logic('seasonality_flag', 'Seasonality Flag', 'L02_decision', 'IF quarterly variance high THEN seasonal', kwargs)
+
+@rule('one_time_item_flag', 'One-Time Item Flag', 'L02_decision', 'IF item flagged unusual THEN exclude from run-rate')
+def one_time_item_flag(**kwargs) -> RuleResult:
+    """One-Time Item Flag. Logic: IF item flagged unusual THEN exclude from run-rate"""
+    return _evaluate_threshold_logic('one_time_item_flag', 'One-Time Item Flag', 'L02_decision', 'IF item flagged unusual THEN exclude from run-rate', kwargs)
+
+@rule('guidance_beat_miss', 'Guidance Beat/Miss', 'L02_decision', 'IF actual > guidance THEN beat ELSE miss')
+def guidance_beat_miss(**kwargs) -> RuleResult:
+    """Guidance Beat/Miss. Logic: IF actual > guidance THEN beat ELSE miss"""
+    return _evaluate_threshold_logic('guidance_beat_miss', 'Guidance Beat/Miss', 'L02_decision', 'IF actual > guidance THEN beat ELSE miss', kwargs)
+
+@rule('covenant_compliance', 'Covenant Compliance', 'L02_decision', 'IF ratio within covenant THEN compliant ELSE breach')
+def covenant_compliance(**kwargs) -> RuleResult:
+    """Covenant Compliance. Logic: IF ratio within covenant THEN compliant ELSE breach"""
+    return _evaluate_threshold_logic('covenant_compliance', 'Covenant Compliance', 'L02_decision', 'IF ratio within covenant THEN compliant ELSE breach', kwargs)
+
+@rule('margin_expansion_driver', 'Margin Driver Classification', 'L02_decision', 'Volume / price / mix / cost classification')
+def margin_expansion_driver(**kwargs) -> RuleResult:
+    """Margin Driver Classification. Logic: Volume / price / mix / cost classification"""
+    return _evaluate_threshold_logic('margin_expansion_driver', 'Margin Driver Classification', 'L02_decision', 'Volume / price / mix / cost classification', kwargs)
+
+@rule('trend_reversal', 'Trend Reversal Detection', 'L02_decision', 'IF direction changed vs prior trend THEN reversal')
+def trend_reversal(**kwargs) -> RuleResult:
+    """Trend Reversal Detection. Logic: IF direction changed vs prior trend THEN reversal"""
+    return _evaluate_threshold_logic('trend_reversal', 'Trend Reversal Detection', 'L02_decision', 'IF direction changed vs prior trend THEN reversal', kwargs)
+
+@rule('relative_strength', 'Relative Strength', 'L02_decision', 'Compare return to peer/benchmark')
+def relative_strength(**kwargs) -> RuleResult:
+    """Relative Strength. Logic: Compare return to peer/benchmark"""
+    return _evaluate_threshold_logic('relative_strength', 'Relative Strength', 'L02_decision', 'Compare return to peer/benchmark', kwargs)
+
+@rule('efficiency_improving', 'Efficiency Improving', 'L02_decision', 'Compare turnover/CCC across periods')
+def efficiency_improving(**kwargs) -> RuleResult:
+    """Efficiency Improving. Logic: Compare turnover/CCC across periods"""
+    return _evaluate_threshold_logic('efficiency_improving', 'Efficiency Improving', 'L02_decision', 'Compare turnover/CCC across periods', kwargs)
+
+@rule('balance_sheet_strength', 'Balance Sheet Strength', 'L02_decision', 'Combine leverage + liquidity + coverage')
+def balance_sheet_strength(**kwargs) -> RuleResult:
+    """Balance Sheet Strength. Logic: Combine leverage + liquidity + coverage"""
+    return _evaluate_threshold_logic('balance_sheet_strength', 'Balance Sheet Strength', 'L02_decision', 'Combine leverage + liquidity + coverage', kwargs)
+
+@rule('going_concern_signal', 'Going Concern Signal', 'L02_decision', 'Combine Altman + liquidity + losses')
+def going_concern_signal(**kwargs) -> RuleResult:
+    """Going Concern Signal. Logic: Combine Altman + liquidity + losses"""
+    return _evaluate_threshold_logic('going_concern_signal', 'Going Concern Signal', 'L02_decision', 'Combine Altman + liquidity + losses', kwargs)