DFK Consult

#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/multicore.h"

// Hardware pin configuration for the detection system
#define PIN_MONITOR_E_MID  14   // Signals that the bottleneck is being used
#define PIN_MONITOR_E_OUT2 15   // Signals that the expensive detour route (H) is being used
#define PIN_ALARM_LED      16   // Hardware alarm output in case of mathematical divergence

// Calibrated mathematical constants of the monitored network
const float COST_L = 10.0f;     // Base cost of the main link (e.g., 10ms latency or 10W energy)
const float COST_H = 500.0f;    // Asymmetric detour cost (e.g., 500ms detour)

// Calculated theoretical upper bound according to the DGG falsification proof
// If the heuristic breaches this value, the system structurally collapses.
const float DGG_CRITICAL_THRESHOLD = 0.5f + (COST_H / (2.0f * COST_L));

// Structure for inter-core data exchange between the cores
typedef struct {
    uint32_t duration_mid;
    uint32_t duration_out2;
} NetworkMetrics;

// --- CORE 1: MATHEMATICAL EVALUATION ENGINE ---
// This core calculates the mathematical falsification and detects the vulnerability.
void core1_falsification_engine() {
    while (true) {
        // Wait for raw data metrics from Core 0
        uint32_t raw_data = multicore_fifo_pop_blocking();
        
        // Unpack the time data (16-bit symmetry for e_mid and e_out2)
        uint16_t time_mid = (raw_data >> 16) & 0xFFFF;
        uint16_t time_out2 = raw_data & 0xFFFF;

        // 1. Calculation of the real heuristic costs (Unsplit Reality)
        float c_unsplit = (time_mid * COST_L) + (time_out2 * COST_H);

        // 2. Calculation of the fractional optimum (The ideal mathematical baseline flow)
        // In the ideal case, both demands would share the low-cost infrastructure
        float c_frac = (time_mid + time_out2) * COST_L;

        if (c_frac > 0) {
            // 3. Calculation of the current efficiency quotient rho
            float current_rho = c_unsplit / c_frac;

            // 4. Comparison with the DGG counterexample metric
            // If current_rho converges to or diverges against the upper bound,
            // an uncontrolled, structural vulnerability is present.
            if (current_rho >= DGG_CRITICAL_THRESHOLD || time_out2 > 0) {
                gpio_put(PIN_ALARM_LED, 1); // Critical hardware alarm!
                
                // Output of the exact diagnostic data via the serial interface
                printf("[CRITICAL WEAKNESS DETECTED]\n");
                printf(" -> Real Unsplit Cost: %.2f\n", c_unsplit);
                printf(" -> Theoretical Frac Cost: %.2f\n", c_frac);
                printf(" -> Competitive Ratio Rho: %.2f (Threshold: %.2f)\n", current_rho, DGG_CRITICAL_THRESHOLD);
                printf(" -> ACTION REQUIRED: Deploy Time-Buffer at Source Node to eliminate Cost H.\n\n");
            } else {
                gpio_put(PIN_ALARM_LED, 0); // System within the tolerable range
            }
        }
    }
}

// --- CORE 0: HIGH-SPEED TELEMETRY SNIFFER ---
int main() {
    stdio_init_all();

    // Initialize GPIO topography
    gpio_init(PIN_MONITOR_E_MID);
    gpio_set_dir(PIN_MONITOR_E_MID, GPIO_IN);
    
    gpio_init(PIN_MONITOR_E_OUT2);
    gpio_set_dir(PIN_MONITOR_E_OUT2, GPIO_IN);

    gpio_init(PIN_ALARM_LED);
    gpio_set_dir(PIN_ALARM_LED, GPIO_OUT);
    gpio_put(PIN_ALARM_LED, 0);

    // Start the falsification engine on Core 1
    multicore_launch_core1(core1_falsification_engine);

    uint64_t start_mid = 0, start_out2 = 0;
    bool last_mid = false, last_out2 = false;

    while (true) {
        bool current_mid = gpio_get(PIN_MONITOR_E_MID);
        bool current_out2 = gpio_get(PIN_MONITOR_E_OUT2);
        uint64_t now = time_us_64();

        // Time measurement for the occupancy of the main axis (e_mid)
        if (current_mid && !last_mid) start_mid = now;
        if (!current_mid && last_mid) {
            uint16_t delta_mid = (uint16_t)((now - start_mid) / 1000); // in ms
            
            // If the expensive detour route was active at the same time or asymmetrically, push data
            uint16_t delta_out2 = 0; 
            if (current_out2) delta_out2 = (uint16_t)((now - start_out2) / 1000);

            // Packetize the data into a single 32-bit word for the FIFO
            uint32_t packet = ((uint32_t)delta_mid << 16) | (delta_out2 & 0xFFFF);
            multicore_fifo_push_blocking(packet);
        }

        // Time measurement for the activation of the expensive detour route (e_out2)
        if (current_out2 && !last_out2) start_out2 = now;

        last_mid = current_mid;
        last_out2 = current_out2;

        tight_loop_contents(); // Maximizes the sampling rate of the telemetry sniffer
    }

    return 0;
}