A Computational Framework for Ismail’s Contemporary Pointwise Stationary Fluid Approximation TheoryThe Non-Stationary Ek/M/1 Queue Transitions Between Stability, Traffic Intensity and Chaos

1. Introduction

Understanding the stability and transition dynamics in complex systems is vital across domains like traffic management, population dynamics, and queueing theory. These systems exhibit various phases based on control parameters, including stability, intensity, and chaotic behaviour. Capturing these transitions mathematically and computationally remains a challenging yet essential task.

The foundational work in [1,2,3,4,5,6,7,8,9] provides a simplified approximation for nonstationary queues, laying the groundwork for dynamic system modelling. Building on this, we aim to refine the analysis by iteratively approximating the σ function, a measure of system response (σ), as a function of control parameters $k$ and $\rho$.

Let $f_{in}\left(t\right)$ and $f_{out}\left(t\right)$ serve as the temporal flow in [1,2,3,4,5], and fow out, respectively. Therefore, by Equation (1)

$${\displaystyle \frac{dx\left(t\right)}{dt}}=x^{.}\left(t\right)=-f_{out}\left(t\right)+f_{in}\left(t\right), x\left(t\right) \mathrm{a}\mathrm{s} \mathrm{t}\mathrm{h}\mathrm{e} \mathrm{s}\mathrm{t}\mathrm{a}\mathrm{t}\mathrm{e} \mathrm{v}\mathrm{a}\mathrm{r}\mathrm{i}\mathrm{a}\mathrm{b}\mathrm{l}\mathrm{e}$$

(1)

$$f_{out}\left(t\right)=\mu \left(t\right)\rho \left(t\right)$$

(2)

For an infite queue waiting space, defined by Equation (3):

$$f_{in}\left(t\right)=\mathrm{M}\mathrm{e}\mathrm{a}\mathrm{n} \mathrm{a}\mathrm{r}\mathrm{r}\mathrm{i}\mathrm{v}\mathrm{a}\mathrm{l} \mathrm{r}\mathrm{a}\mathrm{t}\mathrm{e}=\lambda \left(t\right)$$

(3)

Thus (1) rewrites to Equation (4):

$$x^{.}\left(t\right)=-\mu \left(t\right)\rho \left(t\right)+\lambda \left(t\right) , 1>\rho \left(t\right)={\displaystyle \frac{\lambda \left(t\right) }{\mu \left(t\right)}}>0$$

(4)

With

$$\rho \left(t\right)=\left(1-\sigma \left(t\right)\right)x\left(t\right)$$

(5)

The $GI/M/1$ PSSFA for the non-stationary $E_k/M/1$ queue reads[1,2,3,4,5,6,7,8,9] as:

$$x^{.}\left(t\right)=-\mu \left(t\right)\rho \left(t\right)=\left(1-\sigma \left(t\right)\right)x\left(t\right)+\lambda \left(t\right) , \sigma ={\left({\displaystyle \frac{k\rho }{k\rho +(1-\sigma )}}\right)}^k$$

(6)

Where $k$ defines the number of set of phases, $k=\mathrm{1,2},\mathrm{3,4},\dots$

Problem Definition

This study focuses on addressing the following phases:

• Stability Phase: Explore how σ changes for ρ ∈ [0.1, 0.999] and $k \in$ [1, 100].
• Traffic Intensity Phase: Examine system behaviour when ρ = 1 and $k \in$ [1, 100].
• Chaotic Phase: Investigate the system response for ρ > 1 (e.g., 2, 3, 4) and $k \in$ [1, 100].

Our approach utilizes computational tools to visualize these relationships, ensuring accurate representation of transitions between these phases.

Here is the structure of the current paper

2. Methodology

The computational framework is implemented in Python[10,11,12,13] leveraging libraries such as NumPy for numerical operations and Matplotlib for visualization. The iterative algorithm approximates σ using the formula (c.f., Equation (6)):

$${\sigma }_{\left(new\right)}={\left({\displaystyle \frac{k\rho }{k\rho +(1-\sigma )}}\right)}^k$$

where σ is initialized to 0.5 and updated until convergence or reaching a tolerance of 10⁻⁶.

Key components of the algorithm include:

• Error handling for division by zero, ensuring robustness.
• Validation of results, checking for undefined outputs (e.g., NaN).
• Visualization of results in 2D and 3D plots.

Phases Overview

Stability Phase:

• Objective: Identify conditions where the system remains stable.
• Parameters: ρ ∈ [0.1, 0.999], k ∈ [1, 100].
• Visualization: 3D plots showing the surface of σ as a function of ρ and k.

Traffic Intensity Phase:

• Objective: Analyse steady-state behaviour under maximum utilization (ρ = 1).
• Parameters: k ∈ [1, 100].
• Visualization: 2D plots of σ vs. k.

Chaotic Phase:

• Objective: Explore instability for ρ > 1 (e.g., 2, 3, 4).
• Parameters: ρ ∈ [2, 4], k ∈ [1, 100].
• Visualization: 3D plots highlighting unpredictable behaviour.

In what follows, the Pseudocode Diagram is visualized

Here is the source code of the program:

The pseudocode is structured as follows:

The algorithm for calculating the sigma (σ) values iteratively is illustrated below:

• Import Libraries:
  • The algorithm starts by importing necessary libraries such as NumPy and Matplotlib for numerical computation and visualization.
• Define $\sigma$-stability Function:
  • This function computes σ iteratively for given parameters k and ρ.
  • Starting with an initial guess ($\sigma =0.5$), the function calculates updated values of σ until convergence or a maximum number of iterations (default 100).
• Iterative Convergence:
  • In each iteration, a new value of $\sigma$ is computed using the formula:

    $${\sigma }_{\left(new\right)}={\left({\displaystyle \frac{k\rho }{k\rho +(1-\sigma )}}\right)}^k$$
  • If the absolute difference between consecutive σ values is less than a specified tolerance (1e-6), the function exits, returning the converged value of σ.
• Error Handling:
  • A try-except block handles division-by-zero errors, ensuring the algorithm does not crash but returns NaN when such cases occur.
• Iterate Over Phases:
  • Stability Phase: Iterates over a range of ρ and k values to compute σ.
  • Traffic Intensity Phase: Sets ρ = 1 (indicating maximum utilization) and computes how σ changes for varying values of k.
  • Chaotic Phase: Explores the behaviour of σ for ρ > 1.

Explanation of Traffic Intensity Phase

The Traffic Intensity Phase models the system at maximum utilization ($\rho =1$):

• Significance: This phase highlights how the system behaves under a fixed load condition. Unlike the stability phase, where ρ changes, the traffic intensity phase focuses solely on the effect of increasing k.
• Results: The algorithm computes σ for a range of k values (1 to 100) with ρ fixed at 1. This setup demonstrates saturation effects in the system, where σ stabilizes despite increasing k.

In the pseudocode, the traffic intensity phase is implemented as a separate loop that calculates and plots $\sigma$ as a function of $k$.

Here is the source code to generate Figures, 1,2 and 3

from graphviz import Digraph

def parse_python_to_flowchart():

# Create a directed graph for the flowchart

graph = Digraph(format=‘png’)

graph.attr(dpi=‘300’, rankdir=‘TB’, size=‘16,10’, margin=‘0.5’) # A4 landscape format

# Add nodes for the pseudocode

graph.node(“Start”, “Start”, shape=“ellipse”, style=“filled”, fillcolor=“#9AEBA3”) # Start node

# Algorithm explanation

graph.node(“Step1”, “Import required libraries:\n- numpy\n- matplotlib\n- 3D plotting tools”, shape=“box”, style=“filled”, fillcolor=“#DAFDBA”)

graph.node(“Step2”, “Define `sigma_stability` function:\n- Compute σ iteratively for given k and ρ”, shape=“box”, style=“filled”, fillcolor=“#DAFDBA”)

graph.node(“Step3”, “Initialize σ = 0.5 (initial guess)”, shape=“box”, style=“filled”, fillcolor=“#DAFDBA”)

graph.node(“Step4”, “Iterate until convergence or max iterations (100)”, shape=“box”, style=“filled”, fillcolor=“#DAFDBA”)

graph.node(“Step5”, “Check if abs(new_sigma - sigma) < tolerance”, shape=“diamond”, style=“filled”, fillcolor=“#45C4B0”)

graph.node(“Step6”, “Update σ to new_sigma”, shape=“box”, style=“filled”, fillcolor=“#DAFDBA”)

graph.node(“Step7”, “Handle division by zero (set σ = NaN)”, shape=“box”, style=“filled”, fillcolor=“#13678A”)

# Phase 1: Stability Phase

graph.node(“Phase1”, “Phase 1: Stability Phase\n- Vary ρ (0.1 to 0.999)\n- k (1 to 100)”, shape=“box”, style=“filled”, fillcolor=“#9AEBA3”)

graph.node(“Plot1”, “Create 3D plot for σ as a function of k and ρ”, shape=“box”, style=“filled”, fillcolor=“#DAFDBA”)

# Phase 2: Traffic Intensity Phase

graph.node(“Phase2”, “Phase 2: Traffic Intensity Phase\n- Set ρ = 1\n- Vary k (1 to 100)”, shape=“box”, style=“filled”, fillcolor=“#9AEBA3”)

graph.node(“Plot2”, “Create 2D plot for σ vs k”, shape=“box”, style=“filled”, fillcolor=“#DAFDBA”)

# Phase 3: Chaotic Phase

graph.node(“Phase3”, “Phase 3: Chaotic Phase\n- Set ρ > 1 (e.g., 2, 3, 4)\n- Vary k (1 to 100)”, shape=“box”, style=“filled”, fillcolor=“#9AEBA3”)

graph.node(“Plot3”, “Create 3D plot for σ as a function of k and ρ”, shape=“box”, style=“filled”, fillcolor=“#DAFDBA”)

# End node

graph.node(“End”, “End of Algorithm”, shape=“ellipse”, style=“filled”, fillcolor=“#9AEBA3”)

# Connect nodes

graph.edge(“Start”, “Step1”)

graph.edge(“Step1”, “Step2”)

graph.edge(“Step2”, “Step3”)

graph.edge(“Step3”, “Step4”)

graph.edge(“Step4”, “Step5”)

graph.edge(“Step5”, “Step6”, label=“Yes”)

graph.edge(“Step6”, “Step4”)

graph.edge(“Step5”, “Step7”, label=“No”)

graph.edge(“Step7”, “Step4”)

graph.edge(“Step4”, “Phase1”)

graph.edge(“Phase1”, “Plot1”)

graph.edge(“Plot1”, “Phase2”)

graph.edge(“Phase2”, “Plot2”)

graph.edge(“Plot2”, “Phase3”)

graph.edge(“Phase3”, “Plot3”)

graph.edge(“Plot3”, “End”)

return graph

# Main script

if __name__ == “__main__”:

# Generate the flowchart

flowchart = parse_python_to_flowchart()

# Render the flowchart as a PNG file

output_path = “System_Stability_&_Transition_Dynamics_Flowchart”

flowchart.render(output_path, format=“png”, cleanup=True)

print(f”Flowchart saved as ‘{output_path}.png’“)

3. Results and Analysis

Visualization

Stability Phase:

Data Snippets

As showcased by Figure 1, it is seen that for $\mathit{k}=\mathrm{1,2},\dots , 100$, the stability phase, adhering $1>\mathit{\rho }>0$, the root parameter $\sigma$ will follow the dynamics of stability.

Traffic Intensity Phase:

Data Snippets

Looking closely at Figure 2, it is seen that for $\mathit{k}=\mathrm{1,2},\dots , 100$, the traffic intensity phase, namely, whenever we reach $\mathit{\rho }=1$, the root parameter $\sigma$ will follow the dynamics of stability, which is a new phenomenon in PSFFA.

Chaotic Phase:

Figure 3 (Chaotic Phase 3D Plot): The plot reveals sharp, unpredictable variations in σ, indicating chaos as $\rho$ exceeds 1.

Data Snippets

As for Figure 3, it is seen that for $\mathit{k}=\mathrm{1,2},\dots , 100$, the traffic intensity phase, namely, whenever we reach $\mathit{\rho }>1$, the root parameter $\sigma$ will follow the dynamics of stability, which is again another new phenomenon in PSFFA theory.

Comparison to [14]

• [14] provides an analytical model for nonstationary queues, focusing on approximations for steady states. Our work complements this by offering computational insights into transitions between stable and unstable phases.
• Unlike [14], which assumes stationary behaviour, our approach identifies conditions under which chaos emerges.

Insights

• Critical Transitions: The stability phase is highly sensitive to small changes in ρ, whereas the chaotic phase exhibits larger, unpredictable variations.
• Algorithm Robustness: The iterative approach converges reliably under most conditions, with exceptions managed through error handling.

4. Conclusion Alongside Research Pathways

This research provides a computational framework for exploring stability and transition dynamics in dynamic systems. By iteratively approximating σ, we uncover critical insights into system behaviour across stable, intense, and chaotic phases. The findings not only validating the theoretical predictions , but also extend them by identifying new behaviours in chaotic systems.

Future work includes:

• Extending the analysis to all real values of $\rho$, as hinted at in the unexplored negative values of $k$.
• Exploring real-world applications in traffic management and population dynamics