Prometheus Topological Persistent Entropy

30 Eyl 2024

Persistence Entropy falls under the branch of math topology. Topology is a study of shapes as they twist and contort. It can be useful in the context of markets to determine how volatile they may be and different from the past.

The key idea is to create a persistence diagram from these log return segments. The persistence diagram tracks the "birth" and "death" of price features:

A birth occurs when a new price pattern or feature emerges in the data.
A death occurs when that pattern disappears.

By comparing prices within each segment, the script tracks how long specific price features persist before they die out. The lifetime of each feature (difference between death and birth) represents how robust or fleeting the pattern is. Persistent price features tend to reflect stable trends, while shorter-lived features indicate volatility.

Entropy Calculation: The lifetimes of these patterns are then used to compute the entropy of the system. Entropy, in this case, measures the amount of disorder or randomness in the price movements. The more varied the lifetimes, the higher the entropy, indicating a more volatile market. If the price patterns exhibit longer, more consistent lifetimes, the entropy is lower, signaling a more stable market.

Calculation:

We start by getting log returns for a user defined look back value. In the compute_persistent_entropy function we separate the overall log returns into windows. We then compute persistence diagrams of the windows. It tracks the birth and death of price patterns to see how persistent they are. Then we calculate the entropy of the windows.

After we go through that process we get an array of entropies, we then smooth it by taking the sum of all of them and dividing it by how many we have so the indicator can function better.

// Calculate log returns
log_returns = array.new<float>()
for i = 1 to lgr_lkb
    array.push(log_returns, math.log(close / close[i + 1]))

// Function to compute a simplified persistence diagram
compute_persistence_diagram(segment) =>
    n = array.size(segment)
    lifetimes = array.new<float>()
    for i = 0 to n - 1
        for j = i + 1 to n - 1
            birth = array.get(segment, i)
            death = array.get(segment, j-1)
            if birth != death
                array.push(lifetimes, math.abs(death - birth))
    lifetimes

// Function to compute entropy of a list of values
compute_entropy(values) =>
    n = array.size(values)
    if n == 0
        0.0
    else
        freq_map = map.new<float, float>()
        total_sum = 0.0
        for i = 0 to n - 1
            value = array.get(values, i)
            //freq_map[value] := freq_map.get(value, 0.0) + 1
            map.put(freq_map, value, value + 1)
            total_sum += 1
        entropy = 0.0
        for [value, count] in freq_map
            p = count / total_sum
            entropy -= p * math.log(p)
        entropy

compute_persistent_entropy(log_returns, window_size) =>
    n = (lgr_lkb) - (2 * window_size) + 1
    entropies = array.new<float>()
    for i = 0 to n - 1
        segment1 = array.new<float>()
        segment2 = array.new<float>()
        for j = 0 to window_size - 1
            array.push(segment1, array.get(log_returns, i + j))
            array.push(segment2, array.get(log_returns, i + window_size + j))
        dgm1 = compute_persistence_diagram(segment1)
        dgm2 = compute_persistence_diagram(segment2)
        combined_diagram = array.concat(dgm1, dgm2)
        entropy = compute_entropy(combined_diagram)
        array.push(entropies, entropy)
    entropies


//---------------------------------------------
//---------------PE----------------------------
//---------------------------------------------

// Calculate Persistent Entropy
entropies = compute_persistent_entropy(log_returns, window_size)
smooth_pe = array.sum(entropies) / array.size(entropies)

This image illustrates how the indicator works for traders. The purple line is the actual indicator value. The line that changes from green to red is a SMA of the indicator value, we use this to determine bullish or bearish. When the smoothed persistence entropy is above it’s SMA that signals bearishness.



The indicator tends to look prettier on higher time frames, we see TSLA on a 4 hour here and below we see it on the 5 minute.



On a lower time frame it looks a little weird but still functions the same way.

Prometheus encourages users to use indicators as tools along with their own discretion. No indicator is 100% accurate. We encourage comments about requested features and criticism.

30 Eyl 2024

Sürüm Notları

Fixed the red and green coloring; was backwards.

4 gün önce

Sürüm Notları

Updates include:
- Improving the entropy function.
- Improving the visuals
- Addition of binning to the entropy function