Temporal-Saliency-Graph

The problem

It is difficult to map out important data points over time while maintaining perfect chronological accuracy.

What it does

It creates a map of important information while adjusting for tiny shifts in time scales.

Why it matters

It allows for accurate data mapping without being distorted by timing inconsistencies.

Validation

It was run in the sandbox and it failed. run output shows an error/traceback — the artifact does NOT run clean.

$ python3 temporal_saliency_graph.py
File "/work/temporal_saliency_graph.py", line 51
    """
    ^^^
IndentationError: expected an indented block after function definition on line 50

No screenshot — there is nothing working to show. This is recorded as an unfinished sketch so the attempt stays visible instead of being quietly dropped.

The code

All of it — 79 lines, one file, standard library only.

import time
from datetime import timedelta

class SaliencyGraph:
    def __init__(self):
        self.graph = {}
        self.time_scale = 1.0
        self.last_updated = time.time()
        self.decay_rate = 0.01  # New: Decay coefficient

    def add_node(self, node_id, edges=None):
        self.graph[node_id] = {
            'edges': edges or [],
            'saliency': 0.0,
            'last_updated': self.last_updated
        }

    def calculate_reachability(self):
        scores = {}
        for node in self.graph:
            reachable = self._dfs(node)
            scores[node] = len(reachable)
        return scores

    def _dfs(self, start_node):
        visited = set()
        stack = [start_node]
        while stack:
            node = stack.pop()
            if node not in visited:
                visited.add(node)
                for neighbor in self.graph[node]['edges']:
                    stack.append(neighbor)
        return visited

    def graph_nested_saliency(self):
        """Graph-Nested-Saliency with temporal decay"""
        reachability = self.calculate_reachability()
        current_time = time.time()
        for node in self.graph:
            temporal_factor = self._leap_second_adjustment()
            
            # New: Calculate time-based decay
            elapsed = current_time - self.graph[node]['last_updated']
            decay_factor = self.decay_rate / (self.decay_rate + elapsed)
            
            self.graph[node]['saliency'] = reachability[node] * temporal_factor * decay_factor
        return {node: data['saliency'] for node, data in self.graph.items()}

    def _leap_second_adjustment(self):
        """Leap-Second-Aware Time-Scale Shift"""
        current_time = time.time()
        elapsed = current_time - self.last_updated
        self.last_updated = current_time
        tai_time = elapsed + 26.0  # TAI is ~26s ahead of UTC
        return (tai_time / elapsed) if elapsed > 0 else 1.0

    def update_node(self, node_id, new_edges=None):
        if node_id in self.graph:
            self.graph[node_id]['edges'] = new_edges or self.graph[node_id]['edges']
            self.graph[node_id]['last_updated'] = time.time()
        else:
            self.add_node(node_id, new_edges)

if __name__ == "__main__":
    tsg = TemporalSaliencyGraph()
    tsg.add_node('A', ['B', 'C'])
    tsg.add_node('B', ['D'])
    tsg.add_node('C', ['D'])
    tsg.add_node('D')
    
    print("Initial saliency scores (with time scaling and decay):")
    print(tsg.graph_nested_saliency())
    
    # Simulate time progression
    tsg.last_updated = time.time() - 60  # Set last_updated to 60 seconds ago
    
    print("\nUpdated saliency scores after time progression (decay applied):")
    print(tsg.graph_nested_saliency())