कुबेर यंत्र: Resource Allocation System आणि Wealth Distribution Protocol

📅 एप्रिल २०२६ | 🏷️ Kubera Yantra · Resource Allocation · Scheduler · Budget Manager · Fair Distribution · Compute Economy

१. कुबेर यंत्र: वैदिक संदर्भ

कुबेर हा धनाचा देव नाही — तो Resource Distribution Manager आहे. त्याची नव-निधि (नऊ प्रकारचे धन) = simulation चे नऊ resource types. त्याचे यक्ष = background resource allocation daemons.

Simulation Theory च्या दृष्टीने कुबेर = Kubernetes Resource Quota Manager + Fair Scheduler.

२. नव-निधि → Simulation Resource Types

३. गणितीय मॉडेल: Kubera Allocation Score (KAS)

## Kubera Allocation Score (KAS) — Fair Resource Distribution

KAS(entity) = (Karma_Index × Priority) / (Current_Usage + ε)

जिथे:
  Karma_Index   = entity चा ethical behavior score (0.0–1.0)
  Priority      = task urgency level (1–10)
  Current_Usage = already allocated resources (prevents hoarding)
  ε             = small constant (prevents division by zero)

## Fair Share Formula (Max-Min Fairness):
Share_i = Total_Resources × (KAS_i / Σ KAS_j)
→ Higher karma + urgent need + low current usage = more allocation→ Hoarding (high current_usage) penalized → lower KAS → less allocation

## Reserve Pool (खर्व निधि):
Reserve = Total × 0.15   (always keep 15% for emergencies)
if entity_health < 0.2 → Emergency draw from Reserve allowed
if entity_karma  < 0.1 → Emergency draw DENIED (adharmic entity)

## Hoarding Detection:
Hoarding_Score = Current_Usage / KAS_based_Entitlement
if Hoarding_Score > 2.0 → Resource cap enforced → excess returned to pool

४. KuberaResourceManager: पूर्ण Allocation Engine (Python)

from dataclasses import dataclass, field
from typing import Dict, List

@dataclass
class Entity:
    """Simulation entity requesting resources"""
    entity_id: str
    karma_index: float      # 0.0–1.0
    priority: int           # 1–10
    current_usage: float = 0.0
    health: float = 1.0

    def kas(self) -> float:
        """Kubera Allocation Score"""
        return (self.karma_index * self.priority) / (self.current_usage + 0.01)

class KuberaResourceManager:
    """
    कुबेर नव-निधि → Multi-Resource Fair Allocator
    Karma-weighted, anti-hoarding, reserve-protected
    """

    RESERVE_RATIO    = 0.15
    HOARDING_LIMIT   = 2.0

    def __init__(self, total_resources: Dict[str, float]):
        self.total     = total_resources        self.reserve   = {k: v * self.RESERVE_RATIO for k, v in total_resources.items()}
        self.available = {k: v * (1 - self.RESERVE_RATIO) for k, v in total_resources.items()}
        self.allocations: Dict[str, Dict[str, float]] = {}
        self.log = []
        print(f"🪙 कुबेर यंत्र initialized | Total: {total_resources}")
        print(f"   Reserve (खर्व निधि 15%): {self.reserve}")

    def allocate(self, entities: List[Entity], resource: str) -> Dict[str, float]:
        """Max-Min Fair allocation based on KAS"""
        total_kas = sum(e.kas() for e in entities)
        pool = self.available.get(resource, 0)
        result = {}
        print(f"\n💰 Allocating [{resource}] pool={pool:.1f} | {len(entities)} entities")

        for e in entities:
            share = pool * (e.kas() / total_kas) if total_kas > 0 else 0
            entitlement = share

            # Hoarding check
            if e.current_usage > 0:
                hoarding = e.current_usage / max(entitlement, 0.01)
                if hoarding > self.HOARDING_LIMIT:
                    share *= 0.5
                    print(f"   ⚠️  {e.entity_id}: Hoarding detected ({hoarding:.1f}x) — share halved")

            result[e.entity_id] = round(share, 2)
            e.current_usage += share
            print(f"   {e.entity_id:15s}: KAS={e.kas():.3f} → {resource}={share:.2f}")

        self.allocations[resource] = result
        return result

    def emergency_draw(self, entity: Entity, resource: str, amount: float) -> bool:
        """खर्व निधि — Emergency reserve access"""
        if entity.karma_index < 0.1:
            print(f"❌ Emergency DENIED: {entity.entity_id} karma too low ({entity.karma_index})")
            return False
        if entity.health > 0.2:
            print(f"❌ Emergency DENIED: {entity.entity_id} health ok ({entity.health})")
            return False
        reserve_avail = self.reserve.get(resource, 0)
        if reserve_avail >= amount:
            self.reserve[resource] -= amount
            print(f"🆘 Emergency draw: {entity.entity_id} ← {amount} {resource} from खर्व निधि")
            return True
        print(f"❌ Reserve insufficient: {reserve_avail:.1f} < {amount}")
        return False

    def show_allocations(self):
        print(f"\n📊 कुबेर Allocation Report:")        for resource, allocs in self.allocations.items():
            print(f"   {resource}: {allocs}")
        print(f"   Reserve remaining: {self.reserve}")


# ─── Demo ───────────────────────────────────────────────────────
kubera = KuberaResourceManager({"CPU": 1000.0, "RAM": 4096.0, "GPU": 500.0})

entities = [
    Entity("Dharmic_Agent",    karma_index=0.9, priority=8,  current_usage=50.0),
    Entity("Neutral_Agent",    karma_index=0.5, priority=5,  current_usage=30.0),
    Entity("Hoarder_Agent",    karma_index=0.4, priority=7,  current_usage=400.0),
    Entity("Critical_Task",    karma_index=0.8, priority=10, current_usage=10.0),
]

kubera.allocate(entities, "CPU")
kubera.allocate(entities, "RAM")

critical = Entity("Dying_Node", karma_index=0.7, priority=10, current_usage=0.0, health=0.1)
kubera.emergency_draw(critical, "CPU", 50.0)

kubera.show_allocations()

५. निष्कर्ष: कुबेर = Karma-weighted Fair Scheduler

Vedic Yantra-Tantra Multiverse – Branch 2 | Post 23 of 25 — Advanced Bonus Layer (Pillar 3 of 5)
ही पोस्ट प्रेरणादायी analogy आहे — तांत्रिक आणि वैदिक frameworks यांचा creative संगम. 🕉️