diff --git a/docusaurus/docs/protocol/primitives/gateways.md b/docusaurus/docs/protocol/primitives/gateways.md index b44d0a5da..80124b44f 100644 --- a/docusaurus/docs/protocol/primitives/gateways.md +++ b/docusaurus/docs/protocol/primitives/gateways.md @@ -1,6 +1,6 @@ --- title: Gateways -sidebar_position: 4 +sidebar_position: 3 --- # Gateways diff --git a/docusaurus/docs/protocol/primitives/probabilistic_proofs.md b/docusaurus/docs/protocol/primitives/probabilistic_proofs.md index 5b7b8d169..4fe2f4767 100644 --- a/docusaurus/docs/protocol/primitives/probabilistic_proofs.md +++ b/docusaurus/docs/protocol/primitives/probabilistic_proofs.md @@ -1,23 +1,671 @@ --- -title: Probabilistic Proofs -sidebar_position: 3 +title: Probabilistic Proofs (Shannon) +sidebar_position: 5 --- -# Probabilistic Proofs +_tl;dr Probabilistic Proofs is a method to scale Pocket Network indefinitely._ -:::warning +## Abstract -TODO_DOCUMENT(@Olshansk): This is just a placeholder. Use the [probabilistic proofs](https://github.com/pokt-network/pocket-core/blob/staging/docs/proposals/probabilistic_proofs.md) design -document as a reference for writing this. +This document describes the mechanism of Probabilistic Proofs, which is what allows +Pocket Network to scale verifiable relay throughput to match an arbitrarily large demand. +Precisely, it allows an unlimited number of ["sessions"](./session.md) which pair (Applications and Suppliers for a given Service) by requiring the creation of a single on-chain Claim +for each such session, but only probabilistically requiring an on-chain proof if it's total reward amount is below a specific threshold. + +External stakeholders (i.e. DAO/Foundation) need to be involved in adjusting the +`ProofRequirementThreshold` by statistically analyzing onchain data, along with selecting +an appropriate `ProofRequestProbability` that balances scalability and security. In turn, these values +are used to derive on-chain reward and penalty amounts for honest and dishonest Suppliers, respectively. +The penalty amount is then used to derive `SupplierMinStake`. +Reasonably selected values can be chosen to easily scale the network by `100x` without compromising +security. + +The results show that choosing a value of `20 POKT` for `ProofRequirementThreshold`, +the `95th percentile` of all Claims, along with a `ProofRequestProbability` of `0.01`, +can enable `100x` scalability of the network if the `Slashing penalty` for invalid/missing +proofs is set to `2,000 POKT`. As long as the minimum required stake for Suppliers exceeds +this value, staked collateral will be available for slashing, if needed. + +In future work, we will look at a potential attack vector that still needs to be considered, +along with further research on the topic. + +## Table of Contents + +- [Relationship to Relay Mining](#relationship-to-relay-mining) +- [Problem Statement](#problem-statement) +- [Example Scenario](#example-scenario) +- [High Level Approach](#high-level-approach) +- [Key Question](#key-question) +- [Guarantees \& Expected Values](#guarantees--expected-values) +- [Modeling an Attack](#modeling-an-attack) + - [Defining a Single (Bernoulli) Trial](#defining-a-single-bernoulli-trial) + - [Conceptual Parameters: Onchain, Modeling, Governance, Etc](#conceptual-parameters-onchain-modeling-governance-etc) + - [Dishonest Supplier: Calculating the Expected Value](#dishonest-supplier-calculating-the-expected-value) + - [Modeling a Dishonest Supplier's Strategy using a Geometric PDF (Probability Distribution Function)](#modeling-a-dishonest-suppliers-strategy-using-a-geometric-pdf-probability-distribution-function) + - [Expected Number of False Claims (Failures) Before Getting Caught (Success)](#expected-number-of-false-claims-failures-before-getting-caught-success) + - [Modeling a Dishonest Supplier's Strategy using a Geometric CDF (Cumulative Distribution Function)](#modeling-a-dishonest-suppliers-strategy-using-a-geometric-cdf-cumulative-distribution-function) + - [Total Rewards: Expected Value Calculation for Dishonest Supplier Before Penalty](#total-rewards-expected-value-calculation-for-dishonest-supplier-before-penalty) + - [Expected Penalty: Slashing amount for Dishonest Supplier](#expected-penalty-slashing-amount-for-dishonest-supplier) + - [Total Profit: Expected Value Calculation for Dishonest Supplier AFTER Penalty](#total-profit-expected-value-calculation-for-dishonest-supplier-after-penalty) + - [Honest Supplier: Calculating the Expected Value](#honest-supplier-calculating-the-expected-value) + - [Setting Parameters to Deter Dishonest Behavior](#setting-parameters-to-deter-dishonest-behavior) + - [Solving for Penalty `S`](#solving-for-penalty-s) + - [Example Calculation](#example-calculation) + - [Generalizing the Penalty Formula](#generalizing-the-penalty-formula) + - [Considering false Claim Variance](#considering-false-claim-variance) +- [Crypto-economic Analysis \& Incentives](#crypto-economic-analysis--incentives) + - [Impact on Honest Suppliers](#impact-on-honest-suppliers) + - [Impact on Dishonest Suppliers](#impact-on-dishonest-suppliers) + - [Analogs between Model Parameters and onchain Governance Values](#analogs-between-model-parameters-and-onchain-governance-values) + - [Parameter Analog for Penalty (`S`)](#parameter-analog-for-penalty-s) + - [Parameter Analog for Reward (`R`)](#parameter-analog-for-reward-r) + - [TODO_IN_THIS_PR: Explain `p`](#todo_in_this_pr-explain-p) + - [Considerations during Parameter Adjustment](#considerations-during-parameter-adjustment) + - [Selecting Optimal `p` and `S`](#selecting-optimal-p-and-s) + - [Considerations for `Proof.ProofRequirementThreshold` an `ProofRequirementThreshold`](#considerations-for-proofproofrequirementthreshold-an-proofrequirementthreshold) + - [Normal Distribution](#normal-distribution) + - [Non-Normal Distribution](#non-normal-distribution) + - [Considerations for `ProofRequestProbability` (`p`)](#considerations-for-proofrequestprobability-p) + - [Maximizing `Pr(X<=k)` to ensure `k or less` failures (Supplier escapes without penalty)](#maximizing-prxk-to-ensure-k-or-less-failures-supplier-escapes-without-penalty) +- [Conclusions for Modeling](#conclusions-for-modeling) +- [Morse Based Value Selection](#morse-based-value-selection) + - [Selecting `ProofRequirementThreshold`](#selecting-proofrequirementthreshold) + - [Calculating `p`: `ProofRequestProbability`](#calculating-p-proofrequestprobability) + - [Calculating `S`: `ProofMissingPenalty`](#calculating-s-proofmissingpenalty) +- [TODO_IN_THIS_PR: Above Threshold Attack Possibility](#todo_in_this_pr-above-threshold-attack-possibility) +- [Future Work](#future-work) + +## Relationship to Relay Mining + +I think it may be worth noting that while probabilistic proofs reduce the number of on-chain proofs (block size), it will drive up supplier min stake amount as it's scaled. I think relaymining helps to mitigate this by taking the scaling pressure off of probabilistic proofs by reducing the size of each proof. Additionally, relaymining has the effect of minimizing the "max claim persistence footprint size": + +```mermaid +--- +title: Scaling Up Relay Throughput (w/ respect to block size) +--- +flowchart + +subgraph pp[Probabilistic Proofs] +prob[proof requirement probability: **decreases**] +thres["threshold (limited by target percentile): **increases**"] +pen[penalty: **increases**] +end + +prob <-."negative correlation yields constant security guarantees ⛓️".-> pen + + +thres --"**minmizes**"---> pn +pen --"**maximizes**"---> smin + +subgraph rm[RelayMining] +diff[mining difficulty: **increases**] +end + +%% Holding num relays constant: +pn[num on-chain proofs] +cn["num on-chain claims (pruned over time)"] +ps[size of on-chain proofs] + +smin[Supplier min stake] + +prob --"**minimizes**"--> pn +diff --"**minimizes**"--> cn +diff --"**minimizes**"--> ps +``` + +## Problem Statement + +_tl;dr Too many on-chain Proofs do not scale due to state bloat and excessive CPU usage._ + +The core limiting factor to Pocket Network's scalability is the number of required on-chain Proofs. +For details on how Proofs are generated and validated, see the [Claim & Proof lifecycle](./Claim_and_Proof_lifecycle.md) section. + +For every session (i.e. `(Application, Supplier, Service)` tuple), it is possible to construct a +Merkle Proof which proves the Claimed work done, which can be stored on-chain. + +These Proofs are large and costly to both store and verify. Too many Proofs result in: + +- **State Bloat**: Full Node disk space grows too quickly because blocks are large (i.e.,full of transactions containing large Proofs), increasing disk usage. +- **Verification Cost**: Block producers (i.e. Validators) MUST verify ALL Proofs (once), correlating average CPU usage with the average throughput of on-chain Proofs. + +:::note + +There is a lot of research around this type of problem, but our team is not actively +looking into `0`-knowledge as a solution at the time of writing (2024). + +TODO_IN_THIS_PR: Reference the papers from justin taylor, Alin Tomescu, and axelar (avalanche?). + +::: + +## Example Scenario + +Consider the hypothetical scenario below as an extremely rough approximation. + +TODO_IN_THIS_PR: Turn this into a table. + +Network parameters: + +- **Session duration**: `1` hour +- **Number of suppliers per session (per app)**: `20` +- **Number of services per session (per app)**: `1` + +Network state (conservative scenario): + +- **Number of (active) services**: `10,000` +- **Number of (active) applications**: `100,000` +- **Number of (active) suppliers**: `100,000` + +Assumptions for the purpose of an example: + +- **Median Proof Size**: `1,000` bytes +- **Total time**: `1` day (`24` sessions) + +Total disk growth per day: + +```bash +10,000 apps * 1 Proof/(service,supplier) * 20 suppliers/app * 1 services/session * 24 sessions * 1,000 bytes/Proof = 4.8 GB ≈ 5 GB +``` + +**CRITICAL**: A very simple (conservative) scenario would result in `5 GB` of disk growth per day, amounting to almost `2 TB` of disk growth in a year. + +This discounts CPU usage needed to verify the Proofs. + +## High Level Approach + +_tl;dr Require a Claim for every (App, Supplier, Service) tuple, but only require a Proof for a subset of these Claims and slash Suppliers that fail to provide a Proof when needed._ + +The diagram below makes reference to some of the on-chain [Governance Params](./../governance/params.md). + +```mermaid +flowchart TD + DR[Distribute Reward] + SC[Submit Claim] + PR[Proof Required] + NP[Proof NOT Required] + SLASH[Slash Supplier Stake] + + %% Is Claim Above Threshold + ISCAT{ Is
Claim.ComputeUnits >
Gov.ProofRequirementThreshold ? } + %% Is Probabilistic Proof Required + ISPPR{"Is P(Gov.ProofRequestProbability) == 1 ?
(omitting rand seed details)"} + %% Is Proof Available + ISPA{"Is Proof Available AND Valid?"} + + SC --> ISCAT + + ISCAT --> |No| ISPPR + ISCAT --> |Yes| PR + + ISPPR --> |No| NP + ISPPR --> |Yes| PR + + ISPA --> |"Yes"| DR + ISPA --> |No| SLASH + + PR --> ISPA + NP --> DR + + style DR fill:#c2f0c2,stroke:#27ae60,stroke-width:2px,color:#000 + style SLASH fill:#f2a3a3,stroke:#e74c3c,stroke-width:2px,color:#000 + style NP fill:#f0f0c2,stroke:#f39c12,stroke-width:2px,color:#000 + style PR fill:#c2d1f0,stroke:#2980b9,stroke-width:2px,color:#000 + + classDef decision fill:#B39CD0,stroke:#5D3FD3,color:#000; + class ISCAT,ISPPR,ISPA decision; +``` + +## Key Question + +**What onchain protocol governance parameters need to be selected or created to** +**deter a Supplier from submitting a false Claim? How can this be modeled?** + +## Guarantees & Expected Values + +Pocket Network's tokenomics do not provide a 100% guarantee against gaming the system. +Instead, there's a tradeoff between the network's security guarantees and factors +like scalability, cost, user experience, and acceptable gamability. + +Our goal is to: + +- Model the expected value (EV) of both honest and dishonest Suppliers. +- Adjust protocol parameters to ensure that the expected profit for dishonest behavior is less than that of honest behavior. + +A Supplier's balance can change in the following ways: + +1. ✅ **Earn rewards for valid Claims with Proofs** (Proof required). +2. ✅ **Earn rewards for valid Claims without Proofs** (Proof not required). +3. 🚨 **Earn rewards for invalid Claims without Proofs** (Proof not required). +4. ❌ **Get slashed for invalid Proofs** (Proof required but invalid). +5. ❌ **Get slashed for missing Proofs** (Proof required but not provided). + +The goal of Probabilistic Proofs is to minimize the profitability of scenario (3🚨) +by adjusting protocol parameters such that dishonest Suppliers have a negative expected +value compared to honest Suppliers. + +## Modeling an Attack + +### Defining a Single (Bernoulli) Trial + +We use a [Bernoulli distribution](https://en.wikipedia.org/wiki/Bernoulli_distribution) +to model the probability of a dishonest Supplier getting caught when submitting false Claims. + +- **Trial Definition**: Each attempt by a Supplier to submit a Claim without being required to provide a Proof. +- **Success**: + - A dishonest Supplier gets caught (i.e. is required to provide a Proof and fails, resulting in a penalty) + - Taken from the network's perspective +- **Failure**: + - A dishonest Supplier does not get caught (i.e. is not required to provide a Proof and receives rewards without providing actual service) + - An honest Supplier is rewarded + - All other outcomes + - Does not include _short-circuited_ (i.e. Claim.ComputeUnits > ProofRequirementThreshold) + +### Conceptual Parameters: Onchain, Modeling, Governance, Etc + +- **ProofRequestProbability (p)**: The probability that a Claim will require a Proof. +- **Penalty (S)**: The amount of stake slashed when a Supplier fails to provide a required Proof. +- **Reward per Claim (R)**: The reward received for a successful Claim without Proof. +- **Maximum Claims Before Penalty (k)**: The expected number of false Claims a Supplier can make before getting caught. + +:::note + +Note that `k` is not an on-chain governance parameter, but rather a modeling parameter used +to model out the attack. + +::: + +We note that `R` is variable and that `SupplierMinStake` is not taken into account in the definition of the problem. +As will be demonstrated by the end of this document: + +- Reward per Claim (`R`) will be equal to the `ProofRequirementThreshold` (POKT) +- Penalty (`S`) will be less than or equal to the `SupplierMinStake` (in POKT) + +### Dishonest Supplier: Calculating the Expected Value + +The dishonest Supplier's strategy: + +- Submit false Claims repeatedly, hoping not to be selected for Proof submission. +- Accept that eventually, they will be caught and penalized. + +#### Modeling a Dishonest Supplier's Strategy using a Geometric PDF (Probability Distribution Function) + +The number of successful false Claims before getting caught follows a [Geometric distribution](https://en.wikipedia.org/wiki/Geometric_distribution): + +**Probability of Not Getting Caught (q)**: +$$ q = 1 - p $$ + +**Probability of Getting Caught on the `(k+1)`th Claim**: +$$ P(X = k+1) = q^k \cdot p $$ + +#### Expected Number of False Claims (Failures) Before Getting Caught (Success) + +$$ E[K] = \frac{q}{p} $$ + +:::note +Recall: + +- **Success**: The network **does** catch a dishonest Supplier +- **Failure**: The network **does not** catch a dishonest Supplier + ::: + +#### Modeling a Dishonest Supplier's Strategy using a Geometric CDF (Cumulative Distribution Function) + +So far, we've considered the probability given by `Pr(X=k+1)`: the probability +of `k` "failures" (👆) until a single "success" (👆). This can be modeled using a Geometric PDF (Probability Distribution Function). + +In practice, we need to track the likelihood of `k or less` "failures" `Pr(X<=k)`, +until a single "success". This can be modeled using a Geometric CDF. + +TODO_IN_THIS_PR: Remove the paragraph below. From Bryan: `This paragraph confuses me a bit. The previous paragraph says that we need to use a CDF but then this paragraph seems to turn around and say that this actually don't? I feel like this and the above paragraph should be combined and rephrased a bit.` + +To simplify the math, we'll be using the Expected Value of a Geometric PDF +due to its [simpler proof formulation](https://en.wikipedia.org/wiki/Geometric_distribution#Proof_of_expected_value), guaranteeing the results be **AT LEAST** +as secure when compared to the Geometric CDF. + +Visual intuition of the two can be seen below: + +![Geometric CDF for Different p Values](./probabilistic_proofs/geometric_pdf_vs_cdf.png) + +:::tip + +You can generate the graph above with `make geometric_pdf_vs_cdf.py` + +::: + +#### Total Rewards: Expected Value Calculation for Dishonest Supplier Before Penalty + +$$ E[\text{Total Rewards}] = R \cdot E[K] = R \cdot \frac{q}{p} $$ + +This represents the Supplier's earnings before the penalty is applied. + +If the Supplier chooses to leave the network at this point in time, it will +have successfully gamed the system. + +#### Expected Penalty: Slashing amount for Dishonest Supplier + +The penalty is a fixed amount `S` when caught. + +#### Total Profit: Expected Value Calculation for Dishonest Supplier AFTER Penalty + +$$ E[\text{Total Profit}] = E[\text{Total Rewards}] - S = R \cdot \frac{q}{p} - S $$ + +### Honest Supplier: Calculating the Expected Value + +- **Expected Rewards per Claim**: $$ E[\text{Reward per Claim}] = R $$ +- **No Penalties**: Since the honest Supplier always provides valid Proofs when required, they avoid penalties. +- **Expected Profit for Honest Supplier (1 Claim)**: + + $$ E[\text{Total Profit}] = R $$ + +### Setting Parameters to Deter Dishonest Behavior + +To deter dishonest Suppliers, we need: + +$$ E[\text{Total Profit}_{\text{Dishonest}}] \leq E[\text{Total Profit}_{\text{Honest}}] $$ + +Substituting the expected values: + +$$ R \cdot \frac{q}{p} - S \leq R $$ + +Since `q = 1 -p`, we can simplify the inequality to: + +$$ R \left( \frac{1 - 2p}{p} \right) \leq S $$ + +#### Solving for Penalty `S` + +However, since `p` is between 0 and 1, `1 - 2p` can be negative if `p > 0.5`. +To ensure `S` is positive, we consider `p ≤ 0.5`. + +Alternatively, to make the penalty effective, we can set: + +$$ S = R \cdot \left( \frac{1 - p}{p} \right) $$ + +This ensures that the expected profit for dishonest Suppliers is `0` or negative: + +$$ E[\text{Total Profit}_{\text{Dishonest}}] = R \cdot \frac{q}{p} - S = R \cdot \frac{q}{p} - R \cdot \frac{q}{p} = 0 $$ + +### Example Calculation + +Assume: + +- Reward Per Claim: `R = 10` +- ProofRequestProbability: `p = 0.2` +- Probability No Proof Requested: `q = 0.8` + +Calculate the expected profit for a dishonest Supplier: + +1. **Expected Number of False Claims Before Getting Caught**: + + $$ E[K] = \frac{q}{p} = \frac{0.8}{0.2} = 4 $$ + +2. **Expected Total Rewards**: + + $$ E[\text{Total Rewards}] = R \cdot E[K] = 10 \cdot 4 = 40 $$ + +3. **Penalty**: + + $$ S = R \cdot \left( \frac{1 - p}{p} \right) = 10 \cdot \left( \frac{0.8}{0.2} \right) = 40 $$ + +4. **Expected Profit**: + + $$ E[\text{Total Profit}] = E[\text{Total Rewards}] - S = 40 - 40 = 0 $$ + +The dishonest Supplier has an expected profit of `0`, making dishonest behavior unattractive compared to honest behavior, which yields a profit of `R = 10` units per Claim without risk of penalty. + +### Generalizing the Penalty Formula + +To ensure that dishonest Suppliers have no incentive to cheat, set the penalty `S` such that: + +$$ S = R \cdot \frac{q}{p} = R \cdot \left( \frac{1 - p}{p} \right) $$ + +This makes the expected profit for dishonest behavior `0`: + +$$ E[\text{Total Profit}_{\text{Dishonest}}] = R \cdot \frac{q}{p} - S = 0 $$ + +TODO_IN_THIS_PR, incorporate feedback from ramiro: + +``` +This value will provide the attacker no expected return, but also no penalty. +In fact, the expected cost of sending an attack is 0 POKT. +An attacker can keep sending claims to the network because at the end of the day s/he will not lose money. This enables spam in the network. + +We can model this using the quantile function (or "percent point function"), the inverse of the CDF. +Sadly I found no closed form for the geometric function (because it is a step function), but we can calculate it easily (is a really small iterative process). + +For example, to be sure that in 95% of all the attacks the attacker is punished (or breaks even in a marginal number of samples), we should set the slash amount (S) approx 3x from what you use here (~6K POKT for the numbers in this example). +Doing this will penalize the attacker/spammer with an average of 4K POKT per attack try. + +If you want I can create small notebook with the procedure and simulation. + + +Some notes: + +The CDF of the E(Geom(p=0.01)) is 63%, meaning that 37% of all attacks result in net profit (some very large). +I use 95% in the example but this can be less, like 75%, resulting in lower S and hence lower min stakes while adding net loss to the attacker). Any value above 63% will result in net loss for the attacker. +``` + +Source: https://gist.github.com/RawthiL/9ed65065b896d13e96dc2a5910f6a7ab + +### Considering false Claim Variance + +While the expected profit is `0`, the variance in the number of successful false +Claims can make dishonest behavior risky. The Supplier might get caught earlier than expected, +leading to a net loss. + +TODO_IN_THIS_PR: Incorporate this from Ramiro: `Variance works both ways, hence my previous comment. This can be a justification for changing the calculation of S as I suggest. This is because the attacker might not be caught until much later and result in a net profit.` + +## Crypto-economic Analysis & Incentives + +### Impact on Honest Suppliers + +Honest Suppliers are not affected by penalties since they always provide valid Proofs when required. +Their expected profit remains: + +$$ E[\text{Total Profit}_{\text{Honest}}] = R $$ + +:::danger + +TODO_IN_THIS_PR: Honest faulty suppliers will also be affectd and peanlized, +which was not an issue before. + +What about non-malicious faults (e.g. network outage)? In this case, I would argue that there's definitely a potential for impact on honest suppliers. +Do you see it differently? +Is it worth mentioning that possibility here? + +::: + +### Impact on Dishonest Suppliers + +Dishonest suppliers must contend with substantial penalties that erase their +anticipated profits, coupled with a heightened risk of early detection and ensuing net losses. + +Furthermore, the inherently probabilistic nature of Proof requests introduces +additional uncertainty, making dishonest behavior both less predictable and more costly. + +### Analogs between Model Parameters and onchain Governance Values + +### Parameter Analog for Penalty (`S`) + +_tl;dr `S` = `Supplier.MinStake`_ + +The penalty `S` is some amount that the protocol should be able to retrieve from the Supplier. + +In practice, this is the `Supplier.MinStake` parameter, which is the amount a Supplier +always has in escrow. This amount can be slashed and/or taken from the Supplier for misbehavior. + +### Parameter Analog for Reward (`R`) + +_tl;dr `R` = `Proof.ProofRequirementThreshold`_ + +In practice, the reward for each onchain Claim is variable and a function of the amount +of work done. + +For the purposes of Probabilistic Proofs, we assume a constant reward of `R` per Claim +because any reward greater than `ProofRequirementThreshold` requires a proof and +short-circuits this entire document. + +Therefore, `R` can be assumed constant when determining the optimal `p` and `S`. + +### TODO_IN_THIS_PR: Explain `p` + +### Considerations during Parameter Adjustment + +TODO_IN_THIS_PR: Add a mermaid diagram for this. + +By tweaking `p` and `S`, the network can: + +- Increase the deterrent against dishonest behavior. +- Balance the overhead of Proof verification with security needs. + +**Considerations:** + +- **Lower `p`** reduces the number of Proofs required --> improves scalability --> requires higher penalties. +- **Higher `S`** increases the risk for dishonest Suppliers --> lead to social adversity from network participants. + +TODO_IN_THIS_PR: Explain how `How does a high slashing penalty increase the risk of dishonest suppliers?` + +#### Selecting Optimal `p` and `S` + +TODO_IN_THIS_PR: Add a mermaid diagram for this. + +To select appropriate values: + +1. **Determine Acceptable Proof Overhead (`p`)**: + + - Choose `p` based on the desired scalability. + - Example: `p = 0.1` for 10% Proof submissions + +2. **Calculate Required Penalty (`S`)**: + + - Ensure `S` is practical and enforceable. + - Use the formula: + $$ S = R \cdot \left( \frac{1 - p}{p} \right) $$ + +3. **Assess Economic Impact**: + + - Simulate scenarios to verify that dishonest Suppliers have a negative expected profit. + - Ensure honest Suppliers remain profitable. + +To illustrate the relationship between `p`, `S`, see the following chart: + +![Penalty vs. ProofRequestProbability](./probabilistic_proofs/Peanlty_vs_ProofRequestProbability.png) + +:::tip + +You can generate the graph above with `penalty_vs_proof_request_prob.py` + +::: + +#### Considerations for `Proof.ProofRequirementThreshold` an `ProofRequirementThreshold` + +- **Threshold Value**: Set the `ProofRequirementThreshold` low enough that most Claims are subject to probabilistic Proof requests, but high enough to prevent excessive Proof submissions. +- **Short-Circuiting**: Claims above the threshold always require Proofs, eliminating the risk of large false Claims slipping through. + +`ProofRequirementThreshold` should be as small as possible so that most such that +most Claims for into the probabilistic bucket, while also balancing out penalties +that may be too large for faulty honest Suppliers. + +##### Normal Distribution + +Assume Claim rewards are normally distributed with a mean `μ` and standard deviation `σ`. + +Ideally, we would choose `2σ` above the Claim `μ` such that `97.3%` fall of all Claims require a Proof. + +##### Non-Normal Distribution + +In practice, rewards are not normally distributed, so we can choose an arbitrary value (e.g. `p95`) +such that 95% of Claims fall into the category of requiring a proof. + +#### Considerations for `ProofRequestProbability` (`p`) + +:::note + +See [Pocket_Network_Morse_Probabilistic_Proofs.ipynb](./Pocket_Network_Morse_Probabilistic_Proofs.ipynb) for more details from Morse, supporting the fact that the majority of the block space is taken up by Proofs. ::: -- [Introduction](#introduction) -## Introduction +The number of on-chain relays (proofs) required by the network scales inversely to `ProofRequestProbability`. For example: + +- `ProofRequestProbability` = 0.5 -> 2x scale +- `ProofRequestProbability` = 0.25 -> 4x scale +- `ProofRequestProbability` = 0.1 -> 10x scale +- `ProofRequestProbability` = 0.01 -> 100x scale +- `ProofRequestProbability` = 0.001 -> 1000x scale + +##### Maximizing `Pr(X<=k)` to ensure `k or less` failures (Supplier escapes without penalty) + +When selecting a value for `p`, our goal is not to maximize `Pr(X=k)`, but rather +maximize `Pr(X<=k)` to ensure `k or less` failures (Supplier escapes without penalty). + +This does not affect the expected reward calculations above, but gives a different +perspective of what the probabilities of success and failure are. + +## Conclusions for Modeling + +By modeling the attack using a geometric distributions and calculating expected values, we can: + +- Determine `R = ProofRequirementThreshold` using statical onchain data. +- Manually adjust `p = ProofRequestProbability` to adjust scalability. +- Compute `S ≤ SupplierMinStake` to deter dishonest behavior. +- Determine the necessary penalty `S` to deter dishonest behavior. +- Ensure that honest Suppliers remain profitable while dishonest Suppliers face negative expected profits. + +This approach allows the network to scale by reducing the number of on-chain Proofs while maintaining economic (dis)incentives that deter dishonest behavior. + +## Morse Based Value Selection + +As of writing (October 2024), Shannon MainNet is not live; therefore, data from Morse must be used to approximate realistic values. + +### Selecting `ProofRequirementThreshold` + +Choose `R = 20` since it is greater than `p95` of all Claims collected in Morse. + +:::info +Units are in `POKT`. +::: + +See the original proposal from Morse available in [probabilistic_proofs_morse.md](./probabilistic_proofs_morse.md) +and [Pocket_Network_Morse_Probabilistic_Proofs.ipynb](./Pocket_Network_Morse_Probabilistic_Proofs.ipynb) for supporting data. + +$$ R = 20 $$ + +### Calculating `p`: `ProofRequestProbability` + +Choose `p = 0.01` to ensure high scalability. + +$$ E[K] = \frac{q}{p} = \frac{0.99}{0.01} = 99 $$ + +### Calculating `S`: `ProofMissingPenalty` + +$$ S = R \cdot E[K] = 20 \cdot 99 = 1980 ≈ 2,000 $$ + +## TODO_IN_THIS_PR: Above Threshold Attack Possibility + +above threshold attacks possibilities. + +We should investigate above threshold attacks possibilities. + +Supplier adds fake serviced relays to the SMT. +Submits the claim. +If the closest proof corresponds to a: +a. Fake relay -> Do not submit the proof and face slashing. +b. Legit relay -> Submit the proof and be rewarded for fake relays. + +This is interesting, you talk about inflating the tree with fake relays. I think that the effect will be a reduction of the catch probability that is proportional to the fake relays ratio. +Supose that you inflate your tree by a X%, then you have a a chance of being requested a proof given by ProofRequestProbability and a X/100 chance that the requested proof is a fake relay. +I think that in practice this can be modeled as a reduced ProofRequestProbability, so we can add a security factor there. + +## Future Work + +1. **Attack Vector**: Account for the fact that a Supplier could be in multiple sessions at the same, so either: + + - The number of sessions a supplier is in will need to be limited + - The minimum stake amount will need to be significantly higher than the penalty to enable slashing across multiple sessions at once + - It could be a multiple of its provided services count. -Probabilistic Proofs is the solution to solving for the long tail of low relay -sessions that can cause on-chain bloat. +2. **Optimal Reward Value**: Evaluating onchain Shannon data to determine the optimal value for `R` +3. **Closed Feedback Loop**: Having `p` dynamically adjust onchain as a function of onchain data without intervention from the DAO / PNF. +4. Reviewing, comparing & contributing to **external literature** such as: -This complements the design of [Relay Mining](./relay_mining.md) -to solve for all scenarios. + - https://research.facebook.com/publications/distributed-auditing-proofs-of-liabilities/ + - https://eprint.iacr.org/2020/1568.pdf diff --git a/docusaurus/docs/protocol/primitives/probabilistic_proofs/Peanlty_vs_ProofRequestProbability.png b/docusaurus/docs/protocol/primitives/probabilistic_proofs/Peanlty_vs_ProofRequestProbability.png new file mode 100644 index 000000000..827a02cf8 Binary files /dev/null and b/docusaurus/docs/protocol/primitives/probabilistic_proofs/Peanlty_vs_ProofRequestProbability.png differ diff --git a/docusaurus/docs/protocol/primitives/probabilistic_proofs/Pocket_Network_Morse_Probabilistic_Proofs.ipynb b/docusaurus/docs/protocol/primitives/probabilistic_proofs/Pocket_Network_Morse_Probabilistic_Proofs.ipynb new file mode 100644 index 000000000..8e89e3877 --- /dev/null +++ b/docusaurus/docs/protocol/primitives/probabilistic_proofs/Pocket_Network_Morse_Probabilistic_Proofs.ipynb @@ -0,0 +1,828 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import pandas as pd\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "import seaborn as sns\n", + "import datetime\n", + "from copy import deepcopy\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Data used in this notebook can be found [here](https://drive.google.com/file/d/1Kjd2UMhcNbRB2YfVvXM6i3rJ4kvS0-WK/view?usp=share_link)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Load Data\n", + "output_path = './'\n", + "\n", + "claims_df = pd.read_csv(os.path.join(output_path, 'claims_from_85901_to_86301.csv'))\n", + "proofs_df = pd.read_csv(os.path.join(output_path, 'proofs_from_85901_to_86301.csv'))\n", + "txs_by_block_df = pd.read_csv(os.path.join(output_path, 'txs_by_block_from_85901_to_86301.csv'))\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Proof / Claim Distribution\n", + "\n", + "In this first seccion we calculate the metrics related to the distribution of POKT in Claims and Proofs." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Get successful and failed claims\n", + "failed_claims_df = claims_df.loc[claims_df['result_code'] != 0].copy()\n", + "successfull_claims_df = claims_df.loc[claims_df['result_code'] == 0].copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Percentage of failed claims: 0.43%\n" + ] + } + ], + "source": [ + "print('Percentage of failed claims: %0.2f%%' % ((len(failed_claims_df)/(len(successfull_claims_df)+len(failed_claims_df))) * 100.))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Get total_pokt up to different coverages\n", + "all_cases = len(claims_df) # Total number of claims\n", + "emp_cdf = list() # Here we will store the empirical CDF\n", + "support = np.linspace(0,50,100) # Granularity in POKT\n", + "for limit_pokt in support:\n", + " # Get all proofs that meet this criteria (POKT lower than limit_pokt)\n", + " cases_here = len(claims_df.loc[claims_df['total_pokt'] <= limit_pokt])\n", + " # Add the fraction of the total proofs that met the criteria\n", + " emp_cdf.append(cases_here/all_cases)\n", + "# Convert to numpy\n", + "emp_cdf = np.array(emp_cdf)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PercentageLimit
025.01.010101
150.03.030303
275.05.555556
390.015.656566
495.018.181818
\n", + "
" + ], + "text/plain": [ + " Percentage Limit\n", + "0 25.0 1.010101\n", + "1 50.0 3.030303\n", + "2 75.0 5.555556\n", + "3 90.0 15.656566\n", + "4 95.0 18.181818" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "table_values = [.25, .5, .75, .90, .95] # Percentiles we want to calculate\n", + "colores = ['grey', 'green', 'yellow', 'orange', 'red'] # For later plot\n", + "# Calculate the limits for each percentile\n", + "limit_rows = list()\n", + "for value in table_values:\n", + " arg_here = np.argmin((emp_cdf-value)**2) # Find closest point in the empirical CDF\n", + " limit_rows.append([value*100., support[arg_here]]) # Convert to percentage and save\n", + "\n", + "table_df = pd.DataFrame(limit_rows, columns=['Percentage', 'Limit']) # Create result dataframe\n", + "table_df # Display" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plots" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the CDF\n", + "\n", + "plt.figure(dpi=150)\n", + "plt.title('CDF and Thresholds for % of samples below given value')\n", + "lengend_names = list()\n", + "plt.plot(support, emp_cdf)\n", + "lengend_names.append('CDF')\n", + "\n", + "for row, c in zip(limit_rows, colores):\n", + " plt.vlines(row[1], ymin=0, ymax = 1.0, linestyles='-.', colors=c, lw=0.75)\n", + " lengend_names.append('limit %d%% (%0.2f POKT) '%(row[0], row[1]))\n", + "\n", + "\n", + "plt.ylabel('P (total_pokt < X)')\n", + "plt.xlabel('total_pokt')\n", + "plt.legend(lengend_names)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the PDF \n", + "\n", + "plt.figure(dpi = 150)\n", + "lengend_names = list()\n", + "plt.title('PDF and Thresholds for % of samples below given value')\n", + "\n", + "sns.histplot(data=claims_df, x=\"total_pokt\", bins = 128, stat=\"density\", element=\"step\")\n", + "lengend_names.append('PDF')\n", + "for row, c in zip(limit_rows, colores):\n", + " plt.vlines(row[1], ymin=0, ymax = 0.3, linestyles='-.', colors=c, lw=0.75)\n", + " lengend_names.append('limit %d%% (%0.2f POKT) '%(row[0], row[1]))\n", + "plt.legend(lengend_names)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot a descriptive distribution of the proof for the largest blockchains\n", + "\n", + "data_use = claims_df.loc[claims_df['chain'].isin(['0021', '0009', '0027', '03DF', '0004'])]\n", + "\n", + "plt.figure(dpi = 150)\n", + "sns.histplot(data=data_use, x=\"total_pokt\", hue=\"chain\", bins = 128, stat=\"density\", element=\"step\")\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Block Size Composition in Bytes\n", + "\n", + "Here we analyze the impact of proofs in a block. \n", + "Block size and proof size is obtained from [here](https://docs.google.com/document/d/1QcsPfhj636zBazw2jAay8H6gdBKXcIMmohY0o321hhQ/edit#).\n", + "The data extracted from this document is:\n", + "1. A proof of $1\\times 10^6 $ relays weights `1884 bytes`\n", + "2. The largest possible claims weights `401 bytes`\n", + "3. The block contains:\n", + " 1. Header `653 bytes`\n", + " 1. Amino Overhead `11 bytes`\n", + " 1. Validator size: `num_validators * 223 bytes`\n", + " 1. Evidence size: `NumOfEvidence * 484 bytes` (we dont know the `NumOfEvidence`, we will use 1000)\n", + "\n", + "\n", + "Also @Olshansk noted that the proof size grows following $\\mathcal{O}(\\log{}n)$, where $n$ is the number of relays in a claim.\n", + "\n", + "Finally we know that the raw block size is `800 KB` lower than reported size (json structures if I recall correctly).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "proof_1M_r = 1884\n", + "largest_claim = 401\n", + "num_proof = 1000 # Made-up number, replace with real value if we find it...\n", + "proof_size = 484\n", + "num_validators = 1000\n", + "validator_size = 223\n", + "header_size = 653\n", + "amino_overhead = 11\n", + "\n", + "# Given the previous iformation we can create the following function\n", + "def relays_to_proof_size(relays, proof_1M_r = 1884):\n", + " '''\n", + " Numeber of relays to proof size approximation\n", + "\n", + " We expect the size of the proof to scale in O(long(r)) whith respect to the\n", + " number of relays (r). \n", + " If we know the size of the proof for 1e6 relays (proof_1M_r), we can scale \n", + " down/up from there. \n", + " '''\n", + " \n", + " return (np.log(relays)/np.log(1e6))*proof_1M_r" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Unnamed: 0heighttotal_proofnum_proofsmean_proof_relaysblock_sizenum_sendnum_claimnum_stake_validatornum_unjail_validatornum_dao_tranfernum_begin_unstake_validatormean_proof_sizeworst_case_claim_sizetxs_block_size
008590110384.293090131710384.293090290587811113550.00.00.00.01.660924e+065433552447958
118590210772.454001133710772.454001294769314913330.01.00.00.01.692838e+065345332489773
22859039957.29816513089957.298165289308520513270.02.00.00.01.642085e+065321272435165
338590410390.594052134510390.594052298896414313720.02.00.00.01.696348e+065501722531044
448590510925.201945133710925.201945294874613813130.00.00.00.01.695405e+065265132490826
................................................
395395862969803.14561713469803.145617301664420813930.00.00.00.01.686927e+065585932558724
396396862979202.84609713459202.846097297548527113000.00.00.00.01.674083e+065213002517565
397397862989708.81919613449708.819196296602325512820.00.00.00.01.682648e+065140822508103
398398862999672.45134713369672.451347298685228213510.00.00.00.01.671949e+065417512528932
399399863009500.22099013539500.220990300863128713270.00.00.00.01.689908e+065321272550711
\n", + "

400 rows × 15 columns

\n", + "
" + ], + "text/plain": [ + " Unnamed: 0 height total_proof num_proofs mean_proof_relays \\\n", + "0 0 85901 10384.293090 1317 10384.293090 \n", + "1 1 85902 10772.454001 1337 10772.454001 \n", + "2 2 85903 9957.298165 1308 9957.298165 \n", + "3 3 85904 10390.594052 1345 10390.594052 \n", + "4 4 85905 10925.201945 1337 10925.201945 \n", + ".. ... ... ... ... ... \n", + "395 395 86296 9803.145617 1346 9803.145617 \n", + "396 396 86297 9202.846097 1345 9202.846097 \n", + "397 397 86298 9708.819196 1344 9708.819196 \n", + "398 398 86299 9672.451347 1336 9672.451347 \n", + "399 399 86300 9500.220990 1353 9500.220990 \n", + "\n", + " block_size num_send num_claim num_stake_validator \\\n", + "0 2905878 111 1355 0.0 \n", + "1 2947693 149 1333 0.0 \n", + "2 2893085 205 1327 0.0 \n", + "3 2988964 143 1372 0.0 \n", + "4 2948746 138 1313 0.0 \n", + ".. ... ... ... ... \n", + "395 3016644 208 1393 0.0 \n", + "396 2975485 271 1300 0.0 \n", + "397 2966023 255 1282 0.0 \n", + "398 2986852 282 1351 0.0 \n", + "399 3008631 287 1327 0.0 \n", + "\n", + " num_unjail_validator num_dao_tranfer num_begin_unstake_validator \\\n", + "0 0.0 0.0 0.0 \n", + "1 1.0 0.0 0.0 \n", + "2 2.0 0.0 0.0 \n", + "3 2.0 0.0 0.0 \n", + "4 0.0 0.0 0.0 \n", + ".. ... ... ... \n", + "395 0.0 0.0 0.0 \n", + "396 0.0 0.0 0.0 \n", + "397 0.0 0.0 0.0 \n", + "398 0.0 0.0 0.0 \n", + "399 0.0 0.0 0.0 \n", + "\n", + " mean_proof_size worst_case_claim_size txs_block_size \n", + "0 1.660924e+06 543355 2447958 \n", + "1 1.692838e+06 534533 2489773 \n", + "2 1.642085e+06 532127 2435165 \n", + "3 1.696348e+06 550172 2531044 \n", + "4 1.695405e+06 526513 2490826 \n", + ".. ... ... ... \n", + "395 1.686927e+06 558593 2558724 \n", + "396 1.674083e+06 521300 2517565 \n", + "397 1.682648e+06 514082 2508103 \n", + "398 1.671949e+06 541751 2528932 \n", + "399 1.689908e+06 532127 2550711 \n", + "\n", + "[400 rows x 15 columns]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Get estimation of block size and components for each block\n", + "\n", + "# Convert the mean number of proof relays to bytes and multiply by totoal number of proof in each block\n", + "txs_by_block_df['mean_proof_size'] = relays_to_proof_size(txs_by_block_df['mean_proof_relays'])*txs_by_block_df['num_proofs']\n", + "# Get the worst-case size used by claims by multipliying the observed claims by the largest proof size, for each block\n", + "txs_by_block_df['worst_case_claim_size'] = largest_claim*txs_by_block_df['num_claim']\n", + "# Get the raw block size\n", + "txs_by_block_df['block_size'] = txs_by_block_df['block_size'] - (800 * 1024) # Raw block size, this is the one that matters\n", + "# Get the size that was used for txs only\n", + "txs_by_block_df['txs_block_size'] = txs_by_block_df['block_size'] - header_size - amino_overhead - (num_validators * validator_size) - (proof_size * proof_size)\n", + "\n", + "\n", + "txs_by_block_df # display" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The block TXs portion is composed of:\n", + "\tProofs : 67.06 %\n", + "\tClaims : 21.64 %\n" + ] + } + ], + "source": [ + "avg_txs_size = txs_by_block_df['txs_block_size'].mean()\n", + "avg_proof_size = txs_by_block_df['mean_proof_size'].mean()\n", + "avg_claim_size = txs_by_block_df['worst_case_claim_size'].mean()\n", + "\n", + "\n", + "avg_proof_consumption = (avg_proof_size/avg_txs_size)*100.\n", + "avg_claim_consumption = (avg_claim_size/avg_txs_size)*100.\n", + "\n", + "print('The block TXs portion is composed of:\\n\\tProofs : %0.2f %%\\n\\tClaims : %0.2f %%'%(avg_proof_consumption, avg_claim_consumption))\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plots" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_df = pd.melt(txs_by_block_df, id_vars=['height'], \n", + " value_vars=[\"block_size\", \"txs_block_size\", \"mean_proof_size\", 'worst_case_claim_size'])\n", + "plot_df['Size [bytes]'] = plot_df['value']\n", + "plot_df['Component'] = plot_df['variable']\n", + "sns.displot(data=plot_df, x=\"Size [bytes]\", hue=\"Component\", kind=\"kde\", height=6, aspect=1.5)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Show number of txs types by block\n", + "plt.figure(dpi=150)\n", + "ax = plt.gca()\n", + "\n", + "txs_by_block_df.plot(x='height', y='num_proofs', ax=ax)\n", + "txs_by_block_df.plot(x='height', y='num_claim', ax=ax)\n", + "txs_by_block_df.plot(x='height', y='num_send', ax=ax)\n", + "plt.ylabel('Amount')\n", + "plt.title('Types of TXs by block')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(dpi=150)\n", + "ax = plt.gca()\n", + "\n", + "txs_by_block_df.plot(x='height', y='block_size', ax=ax)\n", + "txs_by_block_df.plot(x='height', y='txs_block_size', ax=ax)\n", + "\n", + "txs_by_block_df.plot(x='height', y='mean_proof_size', ax=ax)\n", + "txs_by_block_df.plot(x='height', y='worst_case_claim_size', ax=ax)\n", + "\n", + "plt.ylabel('Size [bytes]')\n", + "plt.title('Block size composition by block')\n", + "plt.show()\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docusaurus/docs/protocol/primitives/probabilistic_proofs/Probabilistic_proofs_coverage.ipynb b/docusaurus/docs/protocol/primitives/probabilistic_proofs/Probabilistic_proofs_coverage.ipynb new file mode 100644 index 000000000..7e8b9e252 --- /dev/null +++ b/docusaurus/docs/protocol/primitives/probabilistic_proofs/Probabilistic_proofs_coverage.ipynb @@ -0,0 +1,448 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import pandas as pd\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "import seaborn as sns\n", + "import datetime\n", + "from copy import deepcopy\n", + "\n", + "from scipy import stats\n" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "# Minimum stake = Penalty\n", + "SupplierMinStake = 2e3 # POKT\n", + "# Total POKT that can be claimed without requiering mandatory proof\n", + "ProofRequirementThreshold = 20 # POKT\n", + "# Probability that a claim below the threshold will requiere proof\n", + "ProofRequestProbability = 0.001" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Expected claims passed before begin requiederd a proof: 999.0 (same with scypi: 999.0)\n" + ] + } + ], + "source": [ + "# This is the expected number of claims before being requested for a proof\n", + "# According to https://en.wikipedia.org/wiki/Geometric_distribution (mode 0)\n", + "E_false_claims_before_proof = (1-ProofRequestProbability) / ProofRequestProbability\n", + "\n", + "# For ease calculations we will use the scipy implementation \n", + "# https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.geom.html\n", + "\n", + "# Here we show that both achieve the same mean, more testing in the appendix\n", + "print(f\"Expected claims passed before begin requiederd a proof: {E_false_claims_before_proof} (same with scypi: {stats.geom.mean(ProofRequestProbability, loc=-1)})\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The integral of the PMF is de CDF wich tells us the proportion of the total draws that we expect to see below a given threshold in the support of the PDF.\n", + "\n", + "The CDF has domain on the same as the PDF and codomain is the total sample proportion below that domain point.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The expected number claims passed before begin requiederd a proof represents a coverage of 63.23%\n", + "This means that 36.77% of the trials will pass MORE claims before being requieres a proof\n" + ] + } + ], + "source": [ + "coverage_of_mean = stats.geom.cdf(E_false_claims_before_proof, ProofRequestProbability, loc=-1)\n", + "print(f\"The expected number claims passed before begin requiederd a proof represents a coverage of {coverage_of_mean*100:.2f}%\")\n", + "print(f\"This means that {(1-coverage_of_mean)*100:.2f}% of the trials will pass MORE claims before being requieres a proof\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So we want to go the other way arround, we want to know the value in the domain of the CDF that give us an specific value in the codomain.\n", + "\n", + "More simply, we want to answer: To have X% of samples included, wich is the value that I must select?\n", + "\n", + "and specific to our problem: In 95% of all trials, which is the number of claims we expect to pass before a proof is enforced?\n", + "\n", + "The answer to this is the [quantile function](https://en.wikipedia.org/wiki/Quantile_function) or the percent point function, provided in scypi as `ppf`:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "In the 95.00% of the trials, the number of claims that pass before requiering a proof is lower than 2994\n", + "(Just to check, these two should be simmilar: 0.95 , 0.95)\n" + ] + } + ], + "source": [ + "COVERAGE = 0.95\n", + "E_false_claims_before_proof_COVERAGE = int(stats.geom.ppf(0.95, ProofRequestProbability, loc=-1))\n", + "\n", + "print(f\"In the {COVERAGE*100:0.2f}% of the trials, the number of claims that pass before requiering a proof is lower than {E_false_claims_before_proof_COVERAGE}\")\n", + "\n", + "print(f\"(Just to check, these two should be simmilar: {stats.geom.cdf(E_false_claims_before_proof_COVERAGE, ProofRequestProbability, loc=-1):0.2f} , {COVERAGE:0.2f})\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now lets test what happens when we use either the expected valu or the selected number of trials for a given coverage (through using the PPF)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The slashing for:\n", + "\tExpected trials:\t\t 19980\n", + "\t95.00% coverage of trials:\t 59880\n" + ] + } + ], + "source": [ + "# Slashing according to the selected coverage\n", + "Slash_COVERAGE = int(E_false_claims_before_proof_COVERAGE*ProofRequirementThreshold)\n", + "Slash_E = int(E_false_claims_before_proof*ProofRequirementThreshold)\n", + "\n", + "print(f\"The slashing for:\\n\\tExpected trials:\\t\\t {Slash_E}\\n\\t{COVERAGE*100:0.2f}% coverage of trials:\\t {Slash_COVERAGE}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The number of trials for 95.00% is 2994\n" + ] + } + ], + "source": [ + "# We can can also calcualte the PPF using a simple loop:\n", + "def cdf_theo(x,p):\n", + " # theoretical CFG\n", + " return 1.0-((1.0-p)**(np.floor(x)+1.0))\n", + "current_coverage = 0\n", + "current_trials = 0\n", + "while current_coverage < COVERAGE:\n", + " current_trials += 1.0 # This can be much coarse if we want\n", + " current_coverage = cdf_theo(current_trials, ProofRequestProbability)\n", + "\n", + "print(f\"The number of trials for {100*current_coverage:0.2f}% is {int(current_trials)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Numerical Simulation\n", + "\n", + "But lets not belive and test is the hard way... through sampling..." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# This is the number of times that the attacker will engage in sending fake claims\n", + "samples = 1e8" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# So we run this though the geometrical distribution, sampling from it directly.\n", + "# It will return the number of fake claims that passed before the attacker was requested a proof.\n", + "attackers_sample = stats.geom.rvs(ProofRequestProbability, loc=-1, size=int(samples), random_state=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The total proffit/cost of the attacker will be:\n", + "\tExpected trials coverage 358130120.0\n", + "\t95.00% coverage of trials:-3989641869880.0\n", + "We can see that the attacker actually made proffit!\n" + ] + } + ], + "source": [ + "# Now we calculate the proffit of the attacker, that will be equal to the number\n", + "# of samples passed before the requested proof, multiplied by the maximum reward\n", + "# that can be claimed without mandatory proof and minus the slashing of the \n", + "# missing proof\n", + "attacker_proffit_E = np.sum(ProofRequirementThreshold*attackers_sample)-samples*Slash_E\n", + "attacker_proffit_COVERAGE = np.sum(ProofRequirementThreshold*attackers_sample)-samples*Slash_COVERAGE\n", + "\n", + "print(f\"The total proffit/cost of the attacker will be:\\n\\tExpected trials coverage {attacker_proffit_E}\\n\\t{COVERAGE*100:0.2f}% coverage of trials:{attacker_proffit_COVERAGE}\")\n", + "print(\"We can see that the attacker actually made proffit!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "This is an average proffit/cost per trial of:\n", + "\tExpected trials coverage 3.5813012\n", + "\t95.00% coverage of trials:-39896.4186988\n" + ] + } + ], + "source": [ + "# While I cheatead a little by setting the seed to a case where this happens, it \n", + "# is only to highlight that using the expected number of trials is bad coverage.\n", + "# Why? because the expected proffit is zero, but the variance is high\n", + "\n", + "# This is the average cost (per trial) for the attacker is very near zero\n", + "attacker_average_per_attack_proffit_E = attacker_proffit_E/samples\n", + "attacker_average_per_attack_proffit_COVERAGE = attacker_proffit_COVERAGE/samples\n", + "\n", + "print(f\"This is an average proffit/cost per trial of:\\n\\tExpected trials coverage {attacker_average_per_attack_proffit_E}\\n\\t{COVERAGE*100:0.2f}% coverage of trials:{attacker_average_per_attack_proffit_COVERAGE}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Standard deviation of the number of claims before proof requiered: 999.81 (or mathematically: 999.50)\n" + ] + } + ], + "source": [ + "# We can suspect this by looking at the standard deviation\n", + "print(f\"Standard deviation of the number of claims before proof requiered: {np.std(attackers_sample, ddof=1):0.2f} (or mathematically: {np.sqrt((1-ProofRequestProbability)/(ProofRequestProbability**2)):0.2f})\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since we know that the distribution domain is only positive integers, having a standard deviation larger than the expected value gives us the intuition that the odds for a profitable attack are not in our favor. In other words, it is possible (not probable) to claim a VERY large number of claims before being requiered a proof, but is not possible to be requiered a proof with less than 1 fake claim.\n", + "\n", + "By using a larger coverage we set the per-trial proffit negative (by a given margin) and hence the variations expected from this non-normal distribtion cannot ever offset this negativity, resulting in a negative proffit for all but the extreme cases.\n", + "\n", + "Finally we can see this in the shape of the distribution that is packed near zero but there is a long tail of trials with very high rewards for the atacker." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(dpi=100)\n", + "b = plt.hist(attackers_sample, bins=256, density=True)\n", + "plt.vlines([E_false_claims_before_proof], ymax=np.max(b[0]), ymin=0, colors=[\"black\"])\n", + "plt.vlines([E_false_claims_before_proof_COVERAGE], ymax=np.max(b[0]), ymin=0, colors=[\"red\"])\n", + "plt.xlabel(\"Number of fake claims before a proof requiered.\")\n", + "plt.ylabel(\"Density (higher means more probable)\")\n", + "plt.legend([\"Expected value\", f\"{COVERAGE*100:0.2f} coverage\", \"Histogam bins\"])\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Appendix\n", + "\n", + "Just to show that scipy is the same as used math in the PR" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p_values = [0.1, 0.25, 0.5, 0.75] # Modify as needed\n", + "k_values = np.arange(0, 21) # Range of k values starting from 0\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))\n", + "# Plot Geometric PDF for different p values\n", + "for p in p_values:\n", + " q = 1 - p\n", + " pdf_values = p * (1 - p) ** k_values\n", + " ax1.plot(k_values, pdf_values, marker=\"o\", linestyle=\"-\", label=f\"p = {p}\")\n", + "\n", + " pdf_geom = stats.geom.pmf(k_values, p, loc=-1)\n", + " ax1.plot(k_values, pdf_geom, marker=\"o\", linestyle=\"-.\", color=\"black\")\n", + " # pdf_nbin = stats.nbinom.pmf(k_values, 1, p)\n", + " # ax1.plot(k_values, pdf_nbin, marker=\"o\", linestyle=\"-.\", color=\"black\")\n", + "\n", + "ax1.set_title(\"Geometric PDF: Exactly k Failures Until 1st Success\")\n", + "ax1.set_xlabel(\"Number of Failures before First Success (k)\")\n", + "ax1.set_ylabel(\"Probability Pr(X = k)\")\n", + "ax1.set_xticks(k_values)\n", + "ax1.grid(True)\n", + "ax1.legend()\n", + "\n", + "# Plot Geometric CDF for different p values\n", + "for p in p_values:\n", + " q = 1 - p\n", + " cdf_values = 1 - (1 - p) ** (k_values + 1)\n", + " ax2.plot(k_values, cdf_values, marker=\"o\", linestyle=\"-\", label=f\"p = {p}\")\n", + "\n", + " cdf_geom = stats.geom.cdf(k_values, p, loc=-1)\n", + " ax2.plot(k_values, cdf_geom, marker=\"o\", linestyle=\"-.\", color=\"black\")\n", + "\n", + "ax2.set_title(\"Geometric CDF: ≤ k Failures Until 1st Success\")\n", + "ax2.set_xlabel(\"Number of Failures before First Success (k)\")\n", + "ax2.set_ylabel(\"Cumulative Probability P(X ≤ k)\")\n", + "ax2.set_xticks(k_values)\n", + "ax2.grid(True)\n", + "ax2.legend()\n", + "\n", + "# Adjust layout and display the plots\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p_values = np.linspace(0.01, 0.5, 100)\n", + "R_values = [10, 100, 1000, 10000]\n", + "\n", + "for R in R_values:\n", + " # S_values = R * ((1 - p_values) / p_values)\n", + " S_values = R * stats.geom.mean(p_values,loc=-1)\n", + " plt.plot(p_values, S_values, label=f\"R = {R} POKT\")\n", + "\n", + "plt.xlabel(\"ProofRequestProbability (p)\")\n", + "plt.ylabel(\"Required Penalty (S POKT)\")\n", + "plt.title(\"Penalty vs. ProofRequestProbability for Different Reward Values\")\n", + "plt.legend()\n", + "plt.yscale(\"log\") # Use logarithmic scale for y-axis (optional)\n", + "plt.grid(True, which=\"both\", ls=\"--\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.15" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docusaurus/docs/protocol/primitives/probabilistic_proofs/geometric_pdf_vs_cdf.png b/docusaurus/docs/protocol/primitives/probabilistic_proofs/geometric_pdf_vs_cdf.png new file mode 100644 index 000000000..fcc765b16 Binary files /dev/null and b/docusaurus/docs/protocol/primitives/probabilistic_proofs/geometric_pdf_vs_cdf.png differ diff --git a/docusaurus/docs/protocol/primitives/probabilistic_proofs/geometric_pdf_vs_cdf.py b/docusaurus/docs/protocol/primitives/probabilistic_proofs/geometric_pdf_vs_cdf.py new file mode 100644 index 000000000..ca5cac5d2 --- /dev/null +++ b/docusaurus/docs/protocol/primitives/probabilistic_proofs/geometric_pdf_vs_cdf.py @@ -0,0 +1,39 @@ +import matplotlib.pyplot as plt +import numpy as np + +# Define different ProofRequestProbability values +p_values = [0.1, 0.25, 0.5, 0.75] # Modify as needed +k_values = np.arange(0, 21) # Range of k values starting from 0 + +# Create subplots side by side +fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6)) + +# Plot Geometric PDF for different p values +for p in p_values: + q = 1 - p + pdf_values = p * (1 - p) ** k_values + ax1.plot(k_values, pdf_values, marker="o", linestyle="-", label=f"p = {p}") + +ax1.set_title("Geometric PDF: Exactly k Failures Until 1st Success") +ax1.set_xlabel("Number of Failures before First Success (k)") +ax1.set_ylabel("Probability Pr(X = k)") +ax1.set_xticks(k_values) +ax1.grid(True) +ax1.legend() + +# Plot Geometric CDF for different p values +for p in p_values: + q = 1 - p + cdf_values = 1 - (1 - p) ** (k_values + 1) + ax2.plot(k_values, cdf_values, marker="o", linestyle="-", label=f"p = {p}") + +ax2.set_title("Geometric CDF: ≤ k Failures Until 1st Success") +ax2.set_xlabel("Number of Failures before First Success (k)") +ax2.set_ylabel("Cumulative Probability P(X ≤ k)") +ax2.set_xticks(k_values) +ax2.grid(True) +ax2.legend() + +# Adjust layout and display the plots +plt.tight_layout() +plt.show() diff --git a/docusaurus/docs/protocol/primitives/probabilistic_proofs/penalty_vs_proof_request_prob.py b/docusaurus/docs/protocol/primitives/probabilistic_proofs/penalty_vs_proof_request_prob.py new file mode 100644 index 000000000..8a5f7f8d5 --- /dev/null +++ b/docusaurus/docs/protocol/primitives/probabilistic_proofs/penalty_vs_proof_request_prob.py @@ -0,0 +1,17 @@ +import matplotlib.pyplot as plt +import numpy as np + +p_values = np.linspace(0.01, 0.5, 100) +R_values = [10, 100, 1000, 10000] + +for R in R_values: + S_values = R * ((1 - p_values) / p_values) + plt.plot(p_values, S_values, label=f"R = {R} POKT") + +plt.xlabel("ProofRequestProbability (p)") +plt.ylabel("Required Penalty (S POKT)") +plt.title("Penalty vs. ProofRequestProbability for Different Reward Values") +plt.legend() +plt.yscale("log") # Use logarithmic scale for y-axis (optional) +plt.grid(True, which="both", ls="--") +plt.show() diff --git a/docusaurus/docs/protocol/primitives/probabilistic_proofs_morse.md b/docusaurus/docs/protocol/primitives/probabilistic_proofs_morse.md new file mode 100644 index 000000000..f373da097 --- /dev/null +++ b/docusaurus/docs/protocol/primitives/probabilistic_proofs_morse.md @@ -0,0 +1,336 @@ +--- +title: Probabilistic Proofs (Morse) +sidebar_position: 6 +--- + +:::warning + +This document was copied over from the [pocket-core](https://github.com/pokt-network/pocket-core) +repo for reference until Probabilistic Proofs are in production. Please see [Probabilisti Proofs (Shannon)](./probabilistic_proofs.md) as the primary source of truth. + +::: + +This is a specification & proposal that will be submitted to [forum.pokt.network](https://forum.pokt.network) after peer-review. + +**tl;dr Values Selected** + +- `Pr(X<=k)` = `0.99`; selected manually to maintain 2 nine protocol safety +- `k` (num failures) = `16`; computed using a cumulative geometric probability distribution +- `ProofRequestProbability` = `0.25`; selected manually to scale the network by 4x +- `ProofRequirementThreshold` = `20 POKT`; selected to a value that is above p95 of all POKT claims +- `ProofMissingPenalty` = `320 POKT`; calculated via `ProofRequirementThreshold * k` to deter malicious behaviour + +**The question being answered by the distribution**: What is the probability of the protocol trusting (i.e. failing) `k` Claims or less (i.e. handling a normal claim or not catching an attacker) until a single penalty enforcement (i.e. successfully catching an attacker). + +**Answer**: Selecting `k = 16` and `ProofRequirementThreshold = 20 POKT` implies that if an attacker continues submitting claims for `19.99 POKT` or less, they will get caught `99%` of the time, and will be penalized for `320 POKT`. + +## Table of Contents + +- [Summary](#summary) +- [Specification](#specification) + - [Governance Parameters](#governance-parameters) + - [Parameter Usage](#parameter-usage) + - [Flow](#flow) + - [Scaling Benefits](#scaling-benefits) + - [Block Data Verification](#block-data-verification) +- [Attack Modeling](#attack-modeling) + - [Approach](#approach) + - [Definitions](#definitions) + - [Example](#example) + - [Model](#model) + - [Geometric PDF](#geometric-pdf) + - [Geometric CDF](#geometric-cdf) + - [Selecting Values](#selecting-values) + - [Calculation](#calculation) +- [Dissenting Opinions](#dissenting-opinions) + - [Malicious Attackers Bloating State](#malicious-attackers-bloating-state) + - [Honest Servicers Getting Burnt](#honest-servicers-getting-burnt) +- [Appendix](#appendix) + - [Claim Data](#claim-data) + - [Python Code](#python-code) + - [Python Code - Geometric PDF](#python-code---geometric-pdf) + - [Python Code - Geometric CDF](#python-code---geometric-cdf) + +## Summary + +The number of relays in Pocket Network (V0) is limited by the amount of block space utilized by Claim Proofs. The estimations done [here](https://docs.google.com/document/d/1QcsPfhj636zBazw2jAay8H6gdBKXcIMmohY0o321hhQ/edit) approximated it to be ~3B/day. + +Several solutions were proposed [in this document](https://docs.google.com/document/d/1uBomaVieGAjsyHeqSlwmqOyPOln1CemVlWXZjQXUMRY/edit). This proposal outlines an alternate solution: **Probabilistic Proofs**. + +In order for Servicers to be rewarded for their work, a fraction of the Claims submitted on-chain will require a Proof to also be submitted-on chain probabilistically under the random Oracle model. + +This document assumes the reader has an understanding of the [reward protocol](https://github.com/pokt-network/pocket-core/blob/staging/doc/specs/reward_protocol.md). + +## Specification + +### Governance Parameters + +Three new governance parameters will need to be added: + +- `ProofRequestProbability`: Probability that a Claim will require a Proof to be rewarded; x ∈ ℝ ∣ 0 < x ≤ 1 +- `ProofRequirementThreshold`: Claim amount (in uPOKT) above which a Proof will always be required; x ∈ ℝ ∣ x > 0 +- `ProofMissingPenalty`: Burn (in uPOKT) that the Servicer faces if it does not provide a proof within `pocketcore/ClaimExpiration` for a Claim it previously submitted; x ∈ ℝ ∣ x > 0 + +### Parameter Usage + +$$ +Probably(ProofRequired) = + \begin{cases} + ProbabilityOfProofRequest &\text{if } Claim < ProofRequiredThreshold \\ + 1 &\text{if } Claim >= ProofRequiredThreshold. + \end{cases} +$$ + +### Flow + +The high-level flow is captured in the following diagram: + +```mermaid +--- +title: Probabilistic Proofs Flow +--- +stateDiagram-v2 + state claim_threshold <> + state random_selection <> + + SC: Submit Claim + NP: Proof NOT Required + PR: Proof Required + DR: Distribute Reward + B: Penalty / Burn
ProofMissingPenalty + + [*] --> SC + SC --> claim_threshold + + claim_threshold --> PR : Claim >= ProofRequirementThreshold + claim_threshold --> random_selection: Claim < ProofRequirementThreshold + + random_selection --> NP: P(1-ProofRequestProbability) + random_selection --> PR: P(ProofRequestProbability) + + PR --> DR: Proof Available + PR --> B: Proof NOT Available
(honest or malicious) + + NP --> DR +``` + +### Scaling Benefits + +Assuming the majority of the block space is taken up by Proofs, The number of relays in the network scales inversely to `ProofRequestProbability`. Example: + +- `ProofRequestProbability` = 0.5 -> 2x scale (~6B relays) +- `ProofRequestProbability` = 0.25 -> 4x scale (~12B relays) +- `ProofRequestProbability` = 0.1 -> 10x scale (~30B relays) + +**Side benefit**: It has been shown that the majority of block verification time is spent validating the Proofs, so there would also be an upside on resource consumption. Showing backing data for this is outside the scope of this document. + +#### Block Data Verification + +The [notebook here](./Pocket_Network_Statistical_Proofs.ipynb) originally authored by @RawthiL in [this gist](https://gist.github.com/RawthiL/05fbfaf76ddc199eda4a303559bff0b3) captures the that the Block Size composition is approximately: + +- Proofs : 67.06 % +- Claims : 21.64 % + +This goes to show that reducing the number of Proofs & Claims submitted on-chain would increase the capacity of the network. + +![img2](https://user-images.githubusercontent.com/1892194/236548602-bb6cbc2a-aa2a-4b92-ae75-d40eda80685f.png) +![img1](https://user-images.githubusercontent.com/1892194/236548608-be569088-a19a-4759-8d7b-2c4f8c5e7ae8.png) + +## Attack Modeling + +In order to select the values for the three parameters, the attacker's likelihood of adversarial reward & penalty must be modeled. + +### Approach + +An _attack by example_ approach is used determining the appropriate values for `ProofRequestProbability`, `ProofRequirementThreshold` and `ProofMissingPenalty`. This will demonstrate the optimal malicious behaviour an attacker should follow and tend to that case. + +### Definitions + +A Bernoulli probability distribution will be used whereby each `Claim` & `Proof` pair can be treated as an independent Bernoulli Trial. When the `Claim` exceeds `ProofRequirementThreshold`, the model is _"short-circuited"_ and is therefore outside the sample space for this definition. + +The definition for success is taken from the Network's point of view. + +- **Success**: Servicer submits a false claim and gets caught +- **Failure** (the remainder of the sample space excluding Success): + - Servicer submits a true claim and is required prove it + - Servicer a true claim and have no requirement to prove it + - Servicer submits a false claim and gets away with it + - Servicer submits a true claim, but fails to prove it + +### Example + +Let `ProofRequirementThreshold = 100 POKT` + +If the `Claim` is greater than or equal to `100 POKT`, a proof is mandatory and the model is _"short-circuited"_. Therefore, the attacker can _freeload_ by submitting claims for `99.99 POKT` and hope they never get caught. If they do get caught (i.e. `Success`), the burn (i.e. `ProofMissingPenalty`) should exceed the total reward accumulated. + +Since each claim is independent, an attacker would never submit a `Claim` exceeding `ProofRequirementThreshold`, and therefore have a `ProofRequestProbability` likelihood of being required to submit a proof. + +### Model + +A [Geometric PDF](https://en.wikipedia.org/wiki/Geometric_distribution) was selected to identify the probability of `k` failures (sample space containing an attacker getting away) until a single success (an attacker is caught). + +However, as pointed out by @RawthiL, what we're actually interested in is the likelihood of `k` **or less** failures until a single success. + +### Geometric PDF + +$$ p = ProofRequestProbability $$ + +$$ q = 1 - p $$ + +$$ Pr(X=k) = (1-p)^{k-1}p $$ + +$$ k = \frac{ln(\frac{Pr(X=k)}{p})}{ln(1-p)} + 1 $$ + +![Geometric PDF](https://user-images.githubusercontent.com/1892194/221076333-f6578bc2-0567-4e9d-ae7f-8a483a86cc2d.png) + +### Geometric CDF + +$$ x ∈ ℝ ∣ 0 ≤ x < 1 $$ + +$$ p = ProofRequestProbability $$ + +$$ P(X<=k) = 1 - (1 - p)^{k} $$ + +$$ k = \frac{log(1 - P(X<=k))}{log(1 - p)} $$ + +![Geometric CDF](https://user-images.githubusercontent.com/1892194/221086054-df25a888-558a-497e-9c13-87c6e07cbe6d.png) + +### Selecting Values + +#### Calculation + +`ProofRequirementThreshold` should be as small as possible so that most such that most Claims for into the probabilistic bucket, while also balancing out penalties that may be too large for faulty honest Servicers. Ideally, it should be selected to be `2σ` above the Claim `μ` such that `97.3%` fall into the `ProofRequestProbability` part of the piecewise function. However, as seen in the Appendix, the POKT Claim distribution does not follow a normal distribution. Instead, 20 POKT was selected since it is greater than `p95` of POKT claim using the data collected. + +`ProofRequestProbability (p)` is selected as `0.25` to enable scaling the network by `4x`. + +`BurnForFailedClaimSubmission` - Should be set to `k * ProofRequirementThreshold` to deter `k` failures or less. + +`Pr(X<=k)` must be as high as possible while keeping `k` reasonably low since it'll impact the penalty for honest but faulty servicers that fail to submit a Claim within the expiration window. We are selecting `Pr(X<=k) = 0.99` + +$$ k = \frac{log(1 - P(X<=k))}{log(1 - p)} $$ + +$$ k = \frac{log(1 - 0.99)}{log(1 - 0.25)} $$ + +$$ k ≈ 16 $$ + +Selecting `k = 16` implies that `99%` of the time, an attacker will get a penalty of `BurnForFailedClaimSubmission`, making it not worthwhile to take the risk. + +## Dissenting Opinions + +### Malicious Attackers Bloating State + +**Q**: Adversarial actors may continue submitting Proofs in excess of what's required to bloat the state of the chain. + +**A**: In the Random Oracle model, only pseudo-randomly selected Claims seeded by on-chain data (e.g. LastBlockHash, hash(claim), ServicerPubKey, etc...) will be included by block proposers. + +### Honest Servicers Getting Burnt + +**Q**: An honest Servicer that submitted a Claim, but failed to submit a Proof within `pocketcore/ClaimExpiration` will be burnt. In today's model, they will only lose the rewards for the unproven Claim. + +**A**: The onus is on the Servicer to upkeep their infrastructure. This is a tradeoff that must be considered as a risk/reward in exchange for the network's growth. + +## Appendix + +### Claim Data + +The claim data below was collected by @RawthiL [here](https://github.com/pokt-network/pocket-core/issues/1523#issuecomment-1441924408). + +| Percentage | Limit | +| ---------- | --------- | +| 25.0 | 1.010101 | +| 50.0 | 2.525253 | +| 75.0 | 5.555556 | +| 90.0 | 16.161616 | +| 95.0 | 18.181818 | + +![imagen](https://user-images.githubusercontent.com/141699/220939267-83504646-7aef-4f02-b365-3eafe85274bd.png) +![imagen](https://user-images.githubusercontent.com/141699/220940745-96875a19-2e6c-4bf8-b9fd-5eeed2e1c950.png) +![imagen](https://user-images.githubusercontent.com/141699/220940864-b54f2577-30db-4f76-9968-dc12e7db74df.png) + +### Python Code + +#### Python Code - Geometric PDF + +```python +import numpy as np +import matplotlib.pyplot as plt +from matplotlib import cm + +def pdf(x, p): + return np.log(x/p) / np.log(1-p) + +# Line Graph +x = np.linspace(0.01, 1, 200) + +# Points +xp = np.linspace(0.01, 1, 20) + +# Plot the actual functions +ps = [0.25, 0.5, 0.75, 0.9] +colors = cm.get_cmap('hsv', len(ps)+1) +for i, p in enumerate(ps): + color = colors(i) + y = pdf(x, p) + yp = pdf(xp, p) + plt.plot(x, y, label=f'p = {p}', color=color) + # Select only the points where y > 0 and plot them as dots + x_pos = xp[np.where(yp > 0)] + y_pos = yp[np.where(yp > 0)] + plt.plot(x_pos, y_pos, 'o', color=color) + + +# Add a horizontal line at y = 0 +plt.axhline(y=0, color='gray', linestyle='--') + +# Add legend, axis labels, and title +plt.legend() +plt.xlabel('Probability(X=k)') +plt.ylabel('k (num failures)') +plt.title('Number of failures until a single success') + +# Display the plot +plt.show() +``` + +#### Python Code - Geometric CDF + +```python +import numpy as np +import matplotlib.pyplot as plt +from matplotlib import cm + +def cdf(x, p): + return np.log(1-x)/np.log(1-p) + +# Line Graph +x = np.linspace(0.01, 1, 200) + +# Points +xp = np.linspace(0.01, 1, 20) + +# Plot the actual functions +ps = [0.25, 0.5, 0.75, 0.9] +colors = cm.get_cmap('hsv', len(ps)+1) +for i, p in enumerate(ps): + color = colors(i) + y = cdf(x, p) + yp = cdf(xp, p) + plt.plot(x, y, label=f'p = {p}', color=color) + # Select only the points where y > 0 and plot them as dots + x_pos = xp[np.where(yp > 0)] + y_pos = yp[np.where(yp > 0)] + plt.plot(x_pos, y_pos, 'o', color=color) + + +# Add a horizontal line at y = 0 +plt.axhline(y=0, color='gray', linestyle='--') + +# Add legend, axis labels, and title +plt.legend() +plt.xlabel('Probability(X<=k)') +plt.ylabel('k (num failures)') +plt.title('CDF - k failures or less until a single success') + +# Display the plot +plt.show() +``` diff --git a/docusaurus/docs/protocol/primitives/relay_mining.md b/docusaurus/docs/protocol/primitives/relay_mining.md index e15edf50a..95248c245 100644 --- a/docusaurus/docs/protocol/primitives/relay_mining.md +++ b/docusaurus/docs/protocol/primitives/relay_mining.md @@ -1,6 +1,6 @@ --- title: Relay Mining -sidebar_position: 3 +sidebar_position: 4 --- # Relay Mining diff --git a/docusaurus/docusaurus.config.js b/docusaurus/docusaurus.config.js index 288e013b8..a494ce291 100644 --- a/docusaurus/docusaurus.config.js +++ b/docusaurus/docusaurus.config.js @@ -67,6 +67,8 @@ const config = { routeBasePath: "/", sidebarPath: "./sidebars.js", sidebarCollapsible: false, + remarkPlugins: [require("remark-math")], + rehypePlugins: [require("rehype-katex")], }, theme: { customCss: [ diff --git a/docusaurus/package-lock.json b/docusaurus/package-lock.json index d061a1ca4..769b8733f 100644 --- a/docusaurus/package-lock.json +++ b/docusaurus/package-lock.json @@ -15,10 +15,13 @@ "@easyops-cn/docusaurus-search-local": "^0.40.1", "@mdx-js/react": "^3.0.0", "clsx": "^2.0.0", + "katex": "^0.16.17", "prism-react-renderer": "^2.4.0", "react": "^18.0.0", "react-dom": "^18.0.0", - "react-player": "^2.16.0" + "react-player": "^2.16.0", + "rehype-katex": "^7.0.1", + "remark-math": "^6.0.0" }, "devDependencies": { "@docusaurus/module-type-aliases": "^3.2.1", @@ -4034,6 +4037,12 @@ "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==", "license": "MIT" }, + "node_modules/@types/katex": { + "version": "0.16.7", + "resolved": "https://registry.npmjs.org/@types/katex/-/katex-0.16.7.tgz", + "integrity": "sha512-HMwFiRujE5PjrgwHQ25+bsLJgowjGjm5Z8FVSf0N6PwgJrwxH0QxzHYDcKsTfV3wva0vzrpqMTJS2jXPr5BMEQ==", + "license": "MIT" + }, "node_modules/@types/mdast": { "version": "4.0.3", "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-4.0.3.tgz", @@ -8299,6 +8308,72 @@ "node": ">= 0.4" } }, + "node_modules/hast-util-from-dom": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/hast-util-from-dom/-/hast-util-from-dom-5.0.1.tgz", + "integrity": "sha512-N+LqofjR2zuzTjCPzyDUdSshy4Ma6li7p/c3pA78uTwzFgENbgbUrm2ugwsOdcjI1muO+o6Dgzp9p8WHtn/39Q==", + "license": "ISC", + "dependencies": { + "@types/hast": "^3.0.0", + "hastscript": "^9.0.0", + "web-namespaces": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-from-dom/node_modules/hastscript": { + "version": "9.0.0", + "resolved": "https://registry.npmjs.org/hastscript/-/hastscript-9.0.0.tgz", + "integrity": "sha512-jzaLBGavEDKHrc5EfFImKN7nZKKBdSLIdGvCwDZ9TfzbF2ffXiov8CKE445L2Z1Ek2t/m4SKQ2j6Ipv7NyUolw==", + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "comma-separated-tokens": "^2.0.0", + "hast-util-parse-selector": "^4.0.0", + "property-information": "^6.0.0", + "space-separated-tokens": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-from-html": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/hast-util-from-html/-/hast-util-from-html-2.0.3.tgz", + "integrity": "sha512-CUSRHXyKjzHov8yKsQjGOElXy/3EKpyX56ELnkHH34vDVw1N1XSQ1ZcAvTyAPtGqLTuKP/uxM+aLkSPqF/EtMw==", + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "devlop": "^1.1.0", + "hast-util-from-parse5": "^8.0.0", + "parse5": "^7.0.0", + "vfile": "^6.0.0", + "vfile-message": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-from-html-isomorphic": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/hast-util-from-html-isomorphic/-/hast-util-from-html-isomorphic-2.0.0.tgz", + "integrity": "sha512-zJfpXq44yff2hmE0XmwEOzdWin5xwH+QIhMLOScpX91e/NSGPsAzNCvLQDIEPyO2TXi+lBmU6hjLIhV8MwP2kw==", + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "hast-util-from-dom": "^5.0.0", + "hast-util-from-html": "^2.0.0", + "unist-util-remove-position": "^5.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, "node_modules/hast-util-from-parse5": { "version": "8.0.1", "resolved": "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-8.0.1.tgz", @@ -8318,6 +8393,19 @@ "url": "https://opencollective.com/unified" } }, + "node_modules/hast-util-is-element": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/hast-util-is-element/-/hast-util-is-element-3.0.0.tgz", + "integrity": "sha512-Val9mnv2IWpLbNPqc/pUem+a7Ipj2aHacCwgNfTiK0vJKl0LF+4Ba4+v1oPHFpf3bLYmreq0/l3Gud9S5OH42g==", + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, "node_modules/hast-util-parse-selector": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-4.0.0.tgz", @@ -8438,6 +8526,22 @@ "url": "https://opencollective.com/unified" } }, + "node_modules/hast-util-to-text": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/hast-util-to-text/-/hast-util-to-text-4.0.2.tgz", + "integrity": "sha512-KK6y/BN8lbaq654j7JgBydev7wuNMcID54lkRav1P0CaE1e47P72AWWPiGKXTJU271ooYzcvTAn/Zt0REnvc7A==", + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "@types/unist": "^3.0.0", + "hast-util-is-element": "^3.0.0", + "unist-util-find-after": "^5.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, "node_modules/hast-util-whitespace": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz", @@ -9419,6 +9523,31 @@ "graceful-fs": "^4.1.6" } }, + "node_modules/katex": { + "version": "0.16.17", + "resolved": "https://registry.npmjs.org/katex/-/katex-0.16.17.tgz", + "integrity": "sha512-OyzSrXBllz+Jdc9Auiw0kt21gbZ4hkz8Q5srVAb2U9INcYIfGKbxe+bvNvEz1bQ/NrDeRRho5eLCyk/L03maAw==", + "funding": [ + "https://opencollective.com/katex", + "https://github.com/sponsors/katex" + ], + "license": "MIT", + "dependencies": { + "commander": "^8.3.0" + }, + "bin": { + "katex": "cli.js" + } + }, + "node_modules/katex/node_modules/commander": { + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-8.3.0.tgz", + "integrity": "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==", + "license": "MIT", + "engines": { + "node": ">= 12" + } + }, "node_modules/keyv": { "version": "4.5.4", "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", @@ -9913,6 +10042,25 @@ "url": "https://opencollective.com/unified" } }, + "node_modules/mdast-util-math": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/mdast-util-math/-/mdast-util-math-3.0.0.tgz", + "integrity": "sha512-Tl9GBNeG/AhJnQM221bJR2HPvLOSnLE/T9cJI9tlc6zwQk2nPk/4f0cHkOdEixQPC/j8UtKDdITswvLAy1OZ1w==", + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "@types/mdast": "^4.0.0", + "devlop": "^1.0.0", + "longest-streak": "^3.0.0", + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-to-markdown": "^2.1.0", + "unist-util-remove-position": "^5.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, "node_modules/mdast-util-mdx": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/mdast-util-mdx/-/mdast-util-mdx-3.0.0.tgz", @@ -11166,6 +11314,81 @@ } ] }, + "node_modules/micromark-extension-math": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/micromark-extension-math/-/micromark-extension-math-3.1.0.tgz", + "integrity": "sha512-lvEqd+fHjATVs+2v/8kg9i5Q0AP2k85H0WUOwpIVvUML8BapsMvh1XAogmQjOCsLpoKRCVQqEkQBB3NhVBcsOg==", + "license": "MIT", + "dependencies": { + "@types/katex": "^0.16.0", + "devlop": "^1.0.0", + "katex": "^0.16.0", + "micromark-factory-space": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-math/node_modules/micromark-factory-space": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz", + "integrity": "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-extension-math/node_modules/micromark-util-character": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz", + "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-extension-math/node_modules/micromark-util-symbol": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz", + "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, "node_modules/micromark-extension-mdx-expression": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/micromark-extension-mdx-expression/-/micromark-extension-mdx-expression-3.0.0.tgz", @@ -14384,6 +14607,25 @@ "jsesc": "bin/jsesc" } }, + "node_modules/rehype-katex": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/rehype-katex/-/rehype-katex-7.0.1.tgz", + "integrity": "sha512-OiM2wrZ/wuhKkigASodFoo8wimG3H12LWQaH8qSPVJn9apWKFSH3YOCtbKpBorTVw/eI7cuT21XBbvwEswbIOA==", + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "@types/katex": "^0.16.0", + "hast-util-from-html-isomorphic": "^2.0.0", + "hast-util-to-text": "^4.0.0", + "katex": "^0.16.0", + "unist-util-visit-parents": "^6.0.0", + "vfile": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, "node_modules/rehype-raw": { "version": "7.0.0", "resolved": "https://registry.npmjs.org/rehype-raw/-/rehype-raw-7.0.0.tgz", @@ -14469,6 +14711,22 @@ "url": "https://opencollective.com/unified" } }, + "node_modules/remark-math": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/remark-math/-/remark-math-6.0.0.tgz", + "integrity": "sha512-MMqgnP74Igy+S3WwnhQ7kqGlEerTETXMvJhrUzDikVZ2/uogJCb+WHUg97hK9/jcfc0dkD73s3LN8zU49cTEtA==", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "mdast-util-math": "^3.0.0", + "micromark-extension-math": "^3.0.0", + "unified": "^11.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, "node_modules/remark-mdx": { "version": "3.0.1", "resolved": "https://registry.npmjs.org/remark-mdx/-/remark-mdx-3.0.1.tgz", @@ -16100,6 +16358,20 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/unist-util-find-after": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/unist-util-find-after/-/unist-util-find-after-5.0.0.tgz", + "integrity": "sha512-amQa0Ep2m6hE2g72AugUItjbuM8X8cGQnFoHk0pGfrFeT9GZhzN5SW8nRsiGKK7Aif4CrACPENkA6P/Lw6fHGQ==", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "unist-util-is": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, "node_modules/unist-util-is": { "version": "6.0.0", "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.0.tgz", diff --git a/docusaurus/package.json b/docusaurus/package.json index 9d603bb4d..72c7129db 100644 --- a/docusaurus/package.json +++ b/docusaurus/package.json @@ -21,10 +21,13 @@ "@easyops-cn/docusaurus-search-local": "^0.40.1", "@mdx-js/react": "^3.0.0", "clsx": "^2.0.0", + "katex": "^0.16.17", "prism-react-renderer": "^2.4.0", "react": "^18.0.0", "react-dom": "^18.0.0", - "react-player": "^2.16.0" + "react-player": "^2.16.0", + "rehype-katex": "^7.0.1", + "remark-math": "^6.0.0" }, "devDependencies": { "@docusaurus/module-type-aliases": "^3.2.1", diff --git a/docusaurus/src/css/custom.css b/docusaurus/src/css/custom.css index b1fcd84b7..0e25b9956 100644 --- a/docusaurus/src/css/custom.css +++ b/docusaurus/src/css/custom.css @@ -4,6 +4,8 @@ * work well for content-centric websites. */ +@import "katex/dist/katex.min.css"; + :root { --ifm-color-primary: #1f2327; --ifm-color-primary-dark: #1c2023; @@ -41,9 +43,10 @@ --ifm-navbar-height: 81px; /* Font Family */ - --ifm-font-family-base: "Inter", system-ui, -apple-system, Segoe UI, Roboto, Ubuntu, - Cantarell, Noto Sans, sans-serif, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, - sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol"; + --ifm-font-family-base: "Inter", system-ui, -apple-system, Segoe UI, Roboto, + Ubuntu, Cantarell, Noto Sans, sans-serif, BlinkMacSystemFont, "Segoe UI", + Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", + "Segoe UI Symbol"; /* Search highlight color */ --search-local-highlight-color: var(--mantine-primary-color-filled); @@ -187,7 +190,8 @@ nav.menu li > .menu__list-item-collapsible .menu__link { /* docs accordion */ .docs-wrapper .mantine-Accordion-item { - border-left: calc(0.0625rem * var(--mantine-scale)) solid var(--_item-border-color); + border-left: calc(0.0625rem * var(--mantine-scale)) solid + var(--_item-border-color); border-bottom: none; } diff --git a/docusaurus/yarn.lock b/docusaurus/yarn.lock index b40707ca6..24e6873aa 100644 --- a/docusaurus/yarn.lock +++ b/docusaurus/yarn.lock @@ -2197,6 +2197,11 @@ resolved "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz" integrity sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA== +"@types/katex@^0.16.0": + version "0.16.7" + resolved "https://registry.npmjs.org/@types/katex/-/katex-0.16.7.tgz" + integrity sha512-HMwFiRujE5PjrgwHQ25+bsLJgowjGjm5Z8FVSf0N6PwgJrwxH0QxzHYDcKsTfV3wva0vzrpqMTJS2jXPr5BMEQ== + "@types/mdast@^3.0.0": version "3.0.15" resolved "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.15.tgz" @@ -4832,6 +4837,37 @@ hasown@^2.0.0: dependencies: function-bind "^1.1.2" +hast-util-from-dom@^5.0.0: + version "5.0.1" + resolved "https://registry.npmjs.org/hast-util-from-dom/-/hast-util-from-dom-5.0.1.tgz" + integrity sha512-N+LqofjR2zuzTjCPzyDUdSshy4Ma6li7p/c3pA78uTwzFgENbgbUrm2ugwsOdcjI1muO+o6Dgzp9p8WHtn/39Q== + dependencies: + "@types/hast" "^3.0.0" + hastscript "^9.0.0" + web-namespaces "^2.0.0" + +hast-util-from-html-isomorphic@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/hast-util-from-html-isomorphic/-/hast-util-from-html-isomorphic-2.0.0.tgz" + integrity sha512-zJfpXq44yff2hmE0XmwEOzdWin5xwH+QIhMLOScpX91e/NSGPsAzNCvLQDIEPyO2TXi+lBmU6hjLIhV8MwP2kw== + dependencies: + "@types/hast" "^3.0.0" + hast-util-from-dom "^5.0.0" + hast-util-from-html "^2.0.0" + unist-util-remove-position "^5.0.0" + +hast-util-from-html@^2.0.0: + version "2.0.3" + resolved "https://registry.npmjs.org/hast-util-from-html/-/hast-util-from-html-2.0.3.tgz" + integrity sha512-CUSRHXyKjzHov8yKsQjGOElXy/3EKpyX56ELnkHH34vDVw1N1XSQ1ZcAvTyAPtGqLTuKP/uxM+aLkSPqF/EtMw== + dependencies: + "@types/hast" "^3.0.0" + devlop "^1.1.0" + hast-util-from-parse5 "^8.0.0" + parse5 "^7.0.0" + vfile "^6.0.0" + vfile-message "^4.0.0" + hast-util-from-parse5@^8.0.0: version "8.0.1" resolved "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-8.0.1.tgz" @@ -4846,6 +4882,13 @@ hast-util-from-parse5@^8.0.0: vfile-location "^5.0.0" web-namespaces "^2.0.0" +hast-util-is-element@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/hast-util-is-element/-/hast-util-is-element-3.0.0.tgz" + integrity sha512-Val9mnv2IWpLbNPqc/pUem+a7Ipj2aHacCwgNfTiK0vJKl0LF+4Ba4+v1oPHFpf3bLYmreq0/l3Gud9S5OH42g== + dependencies: + "@types/hast" "^3.0.0" + hast-util-parse-selector@^4.0.0: version "4.0.0" resolved "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-4.0.0.tgz" @@ -4928,6 +4971,16 @@ hast-util-to-parse5@^8.0.0: web-namespaces "^2.0.0" zwitch "^2.0.0" +hast-util-to-text@^4.0.0: + version "4.0.2" + resolved "https://registry.npmjs.org/hast-util-to-text/-/hast-util-to-text-4.0.2.tgz" + integrity sha512-KK6y/BN8lbaq654j7JgBydev7wuNMcID54lkRav1P0CaE1e47P72AWWPiGKXTJU271ooYzcvTAn/Zt0REnvc7A== + dependencies: + "@types/hast" "^3.0.0" + "@types/unist" "^3.0.0" + hast-util-is-element "^3.0.0" + unist-util-find-after "^5.0.0" + hast-util-whitespace@^3.0.0: version "3.0.0" resolved "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz" @@ -4946,6 +4999,17 @@ hastscript@^8.0.0: property-information "^6.0.0" space-separated-tokens "^2.0.0" +hastscript@^9.0.0: + version "9.0.0" + resolved "https://registry.npmjs.org/hastscript/-/hastscript-9.0.0.tgz" + integrity sha512-jzaLBGavEDKHrc5EfFImKN7nZKKBdSLIdGvCwDZ9TfzbF2ffXiov8CKE445L2Z1Ek2t/m4SKQ2j6Ipv7NyUolw== + dependencies: + "@types/hast" "^3.0.0" + comma-separated-tokens "^2.0.0" + hast-util-parse-selector "^4.0.0" + property-information "^6.0.0" + space-separated-tokens "^2.0.0" + he@^1.2.0: version "1.2.0" resolved "https://registry.npmjs.org/he/-/he-1.2.0.tgz" @@ -5576,6 +5640,13 @@ jsonfile@^6.0.1: optionalDependencies: graceful-fs "^4.1.6" +katex@^0.16.0, katex@^0.16.17: + version "0.16.17" + resolved "https://registry.npmjs.org/katex/-/katex-0.16.17.tgz" + integrity sha512-OyzSrXBllz+Jdc9Auiw0kt21gbZ4hkz8Q5srVAb2U9INcYIfGKbxe+bvNvEz1bQ/NrDeRRho5eLCyk/L03maAw== + dependencies: + commander "^8.3.0" + keyv@^4.5.3: version "4.5.4" resolved "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz" @@ -5921,6 +5992,19 @@ mdast-util-gfm@^3.0.0: mdast-util-gfm-task-list-item "^2.0.0" mdast-util-to-markdown "^2.0.0" +mdast-util-math@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/mdast-util-math/-/mdast-util-math-3.0.0.tgz" + integrity sha512-Tl9GBNeG/AhJnQM221bJR2HPvLOSnLE/T9cJI9tlc6zwQk2nPk/4f0cHkOdEixQPC/j8UtKDdITswvLAy1OZ1w== + dependencies: + "@types/hast" "^3.0.0" + "@types/mdast" "^4.0.0" + devlop "^1.0.0" + longest-streak "^3.0.0" + mdast-util-from-markdown "^2.0.0" + mdast-util-to-markdown "^2.1.0" + unist-util-remove-position "^5.0.0" + mdast-util-mdx-expression@^2.0.0: version "2.0.0" resolved "https://registry.npmjs.org/mdast-util-mdx-expression/-/mdast-util-mdx-expression-2.0.0.tgz" @@ -5998,7 +6082,7 @@ mdast-util-to-hast@^13.0.0: unist-util-visit "^5.0.0" vfile "^6.0.0" -mdast-util-to-markdown@^2.0.0: +mdast-util-to-markdown@^2.0.0, mdast-util-to-markdown@^2.1.0: version "2.1.0" resolved "https://registry.npmjs.org/mdast-util-to-markdown/-/mdast-util-to-markdown-2.1.0.tgz" integrity sha512-SR2VnIEdVNCJbP6y7kVTJgPLifdr8WEU440fQec7qHoHOUz/oJ2jmNRqdDQ3rbiStOXb2mCDGTuwsK5OPUgYlQ== @@ -6240,6 +6324,19 @@ micromark-extension-gfm@^3.0.0: micromark-util-combine-extensions "^2.0.0" micromark-util-types "^2.0.0" +micromark-extension-math@^3.0.0: + version "3.1.0" + resolved "https://registry.npmjs.org/micromark-extension-math/-/micromark-extension-math-3.1.0.tgz" + integrity sha512-lvEqd+fHjATVs+2v/8kg9i5Q0AP2k85H0WUOwpIVvUML8BapsMvh1XAogmQjOCsLpoKRCVQqEkQBB3NhVBcsOg== + dependencies: + "@types/katex" "^0.16.0" + devlop "^1.0.0" + katex "^0.16.0" + micromark-factory-space "^2.0.0" + micromark-util-character "^2.0.0" + micromark-util-symbol "^2.0.0" + micromark-util-types "^2.0.0" + micromark-extension-mdx-expression@^3.0.0: version "3.0.0" resolved "https://registry.npmjs.org/micromark-extension-mdx-expression/-/micromark-extension-mdx-expression-3.0.0.tgz" @@ -7890,6 +7987,19 @@ regjsparser@^0.9.1: dependencies: jsesc "~0.5.0" +rehype-katex@^7.0.1: + version "7.0.1" + resolved "https://registry.npmjs.org/rehype-katex/-/rehype-katex-7.0.1.tgz" + integrity sha512-OiM2wrZ/wuhKkigASodFoo8wimG3H12LWQaH8qSPVJn9apWKFSH3YOCtbKpBorTVw/eI7cuT21XBbvwEswbIOA== + dependencies: + "@types/hast" "^3.0.0" + "@types/katex" "^0.16.0" + hast-util-from-html-isomorphic "^2.0.0" + hast-util-to-text "^4.0.0" + katex "^0.16.0" + unist-util-visit-parents "^6.0.0" + vfile "^6.0.0" + rehype-raw@^7.0.0: version "7.0.0" resolved "https://registry.npmjs.org/rehype-raw/-/rehype-raw-7.0.0.tgz" @@ -7947,6 +8057,16 @@ remark-gfm@^4.0.0: remark-stringify "^11.0.0" unified "^11.0.0" +remark-math@^6.0.0: + version "6.0.0" + resolved "https://registry.npmjs.org/remark-math/-/remark-math-6.0.0.tgz" + integrity sha512-MMqgnP74Igy+S3WwnhQ7kqGlEerTETXMvJhrUzDikVZ2/uogJCb+WHUg97hK9/jcfc0dkD73s3LN8zU49cTEtA== + dependencies: + "@types/mdast" "^4.0.0" + mdast-util-math "^3.0.0" + micromark-extension-math "^3.0.0" + unified "^11.0.0" + remark-mdx@^3.0.0: version "3.0.1" resolved "https://registry.npmjs.org/remark-mdx/-/remark-mdx-3.0.1.tgz" @@ -8842,6 +8962,14 @@ unique-string@^3.0.0: dependencies: crypto-random-string "^4.0.0" +unist-util-find-after@^5.0.0: + version "5.0.0" + resolved "https://registry.npmjs.org/unist-util-find-after/-/unist-util-find-after-5.0.0.tgz" + integrity sha512-amQa0Ep2m6hE2g72AugUItjbuM8X8cGQnFoHk0pGfrFeT9GZhzN5SW8nRsiGKK7Aif4CrACPENkA6P/Lw6fHGQ== + dependencies: + "@types/unist" "^3.0.0" + unist-util-is "^6.0.0" + unist-util-is@^6.0.0: version "6.0.0" resolved "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.0.tgz"