Apply suggestions

Author: 0xLucca

llms.txt

@@ -16021,7 +16021,7 @@ title: Elastic Scaling
 description: Learn how elastic scaling in Polkadot boosts parachain throughput, reduces latency, and supports dynamic, cost-efficient resource allocation.
 ---
 
-#  Elastic Scaling
+# Elastic Scaling
 
 ## Introduction
 
@@ -16033,13 +16033,19 @@ This technical advancement enables parachains to process multiple blocks within
 
 ## How Elastic Scaling Works
 
-Elastic scaling enables parachains to process multiple blocks in parallel by utilizing additional cores on the relay chain. This section provides a technical analysis of the performance advantages and implementation details.
+Elastic scaling enables parachains to process multiple blocks in parallel by utilizing additional cores on the relay chain. This section provides a technical analysis of the performance advantages and details of the implementation.
 
-Consider a parachain that needs to process four consecutive parablocks (P1-P4). With traditional single-core allocation, the validation process follows a strictly sequential pattern. Each parablock undergoes a two-phase process on the relay chain:
+Consider a parachain that needs to process four consecutive parablocks. With traditional single-core allocation, the validation process follows a strictly sequential pattern. Each parablock undergoes a two-phase process on the relay chain:
 
 1. **Backing phase** - validators create and distribute validity statements
 2. **Inclusion phase** - the parablock is included in the relay chain after availability verification
 
+Throughout the following diagrams, specific notation is used to represent different components of the system:
+
+- R1, R2, ... - relay chain blocks (produced at ~6-second intervals)
+- P1, P2, ... - parachain blocks that need validation and inclusion
+- C1, C2, ... - cores on the relay chain
+
 In the single-core scenario (assuming a 6-second relay chain block time), processing four parablocks requires approximately 30 seconds:
 
 ```mermaid
@@ -16094,13 +16100,20 @@ sequenceDiagram
     end
 ```
 
-The relay chain processes these multiple parablocks as independent validation units during backing, availability, and approval phases. However, during inclusion, it verifies that their state roots align properly to maintain chain consistency.
+To help interpret the sequence diagrams above, note the following key elements:
+
+- The horizontal axis represents time progression through relay chain blocks (R1-R5)
+- Each colored rectangle shows processing on a specific core (C1 or C2)
+- In the single-core scenario, all blocks must be processed sequentially on one core
+- In the multi-core scenario, blocks are processed in parallel across multiple cores, reducing total time
+
+The relay chain processes these multiple parablocks as independent validation units during the backing, availability, and approval phases. However, during inclusion, it verifies that their state roots align properly to maintain chain consistency.
 
 From an implementation perspective:
 
-- **Parachain side** - collators must increase their block production rate to fully utilize multiple cores
-- **Validation process** - each core operates independently but with coordinated state verification
-- **Resource management** -cores are dynamically allocated based on parachain requirements
+- **Parachain side** - collators must increase their block production rate to utilize multiple cores fully
+- **Validation process** - each core operates independently, but with coordinated state verification
+- **Resource management** - cores are dynamically allocated based on parachain requirements
 - **State consistency** - while backed and processed in parallel, the parablocks maintain sequential state transitions
 
 ## Benefits of Elastic Scaling
@@ -16109,21 +16122,21 @@ From an implementation perspective:
 
 - **Lower latency** - transaction finality improves substantially with multi-core processing. Parachains currently achieve 2-second latency with three cores, with projected improvements to 500ms using 12 cores, enabling near-real-time application responsiveness
 
-- **Resource efficiency** - applications acquire computational resources precisely matched to their needs, eliminating wasteful over-provisioning. Coretime can be purchased at granular intervals (blocks, hours, days), creating cost-effective operations particularly for applications with variable transaction patterns
+- **Resource efficiency** - applications acquire computational resources precisely matched to their needs, eliminating wasteful over-provisioning. Coretime can be purchased at granular intervals (blocks, hours, days), creating cost-effective operations, particularly for applications with variable transaction patterns
 
 - **Scalable growth** - new applications can launch with minimal initial resource commitment and scale dynamically as adoption increases. This eliminates the traditional paradox of either over-allocating resources (increasing costs) or under-allocating (degrading performance) during growth phases
 
 - **Workload distribution** - parachains intelligently distribute workloads across cores during peak demand periods and release resources when traffic subsides. Paired with secondary coretime markets, this ensures maximum resource utilization across the entire network ecosystem
 
-- **Reliable performance** - end-users experience reliable application performance regardless of network congestion levels. Applications maintain responsiveness even during traffic spikes, eliminating performance degradation that commonly impacts blockchain applications during high-demand periods.
+- **Reliable performance** - end-users experience reliable application performance regardless of network congestion levels. Applications maintain responsiveness even during traffic spikes, eliminating performance degradation that commonly impacts blockchain applications during high-demand periods
 
 ## Use Cases
 
-Elastic scaling enables applications to dynamically adjust their resource consumption based on real-time demand. This is especially valuable for decentralized applications where usage patterns can be highly variable. The following examples illustrate common scenarios where elastic scaling delivers significant performance and cost-efficiency benefits:
+Elastic scaling enables applications to dynamically adjust their resource consumption based on real-time demand. This is especially valuable for decentralized applications where usage patterns can be highly variable. The following examples illustrate common scenarios where elastic scaling delivers significant performance and cost-efficiency benefits.
 
 ### Handling Sudden Traffic Spikes
 
-Many decentralized applications experience unpredictable, high-volume traffic bursts, especially in areas like gaming, DeFi protocols, NFT auctions, messaging platforms, and social media. Elastic scaling allows these systems to acquire additional coretime during peak usage and release it during quieter periods, ensuring responsiveness without incurring constant high infrastructure costs.
+Many decentralized applications experience unpredictable, high-volume traffic bursts, especially in gaming, DeFi protocols, NFT auctions, messaging platforms, and social media. Elastic scaling allows these systems to acquire additional coretime during peak usage and release it during quieter periods, ensuring responsiveness without incurring constant high infrastructure costs.
 
 ### Supporting Early-Stage Growth
 
@@ -16132,7 +16145,6 @@ Startups and new projects often begin with uncertain or volatile demand. With el
 ### Scaling Massive IoT Networks
 
 Internet of Things (IoT) applications often involve processing data from millions of devices in real time. Elastic scaling supports this need by enabling high-throughput transaction processing as demand fluctuates. Combined with Polkadot’s shared security model, it provides a reliable and privacy-preserving foundation for large-scale IoT deployments.
-IoT Applications
 
 ### Powering Real-Time, Low-Latency Systems
 

polkadot-protocol/architecture/polkadot-chain/elastic-scaling.md

@@ -17,11 +17,17 @@ This technical advancement enables parachains to process multiple blocks within
 
 Elastic scaling enables parachains to process multiple blocks in parallel by utilizing additional cores on the relay chain. This section provides a technical analysis of the performance advantages and details of the implementation.
 
-Consider a parachain that needs to process four consecutive parablocks (P1-P4). With traditional single-core allocation, the validation process follows a strictly sequential pattern. Each parablock undergoes a two-phase process on the relay chain:
+Consider a parachain that needs to process four consecutive parablocks. With traditional single-core allocation, the validation process follows a strictly sequential pattern. Each parablock undergoes a two-phase process on the relay chain:
 
 1. **Backing phase** - validators create and distribute validity statements
 2. **Inclusion phase** - the parablock is included in the relay chain after availability verification
 
+Throughout the following diagrams, specific notation is used to represent different components of the system:
+
+- R1, R2, ... - relay chain blocks (produced at ~6-second intervals)
+- P1, P2, ... - parachain blocks that need validation and inclusion
+- C1, C2, ... - cores on the relay chain
+
 In the single-core scenario (assuming a 6-second relay chain block time), processing four parablocks requires approximately 30 seconds:
 
 ```mermaid
@@ -76,6 +82,13 @@ sequenceDiagram
     end
 ```
 
+To help interpret the sequence diagrams above, note the following key elements:
+
+- The horizontal axis represents time progression through relay chain blocks (R1-R5)
+- Each colored rectangle shows processing on a specific core (C1 or C2)
+- In the single-core scenario, all blocks must be processed sequentially on one core
+- In the multi-core scenario, blocks are processed in parallel across multiple cores, reducing total time
+
 The relay chain processes these multiple parablocks as independent validation units during the backing, availability, and approval phases. However, during inclusion, it verifies that their state roots align properly to maintain chain consistency.
 
 From an implementation perspective: