Skip to content

x402agent/SolanaOS / skills/qedgen

qedgen

Flagged

Formally verify programs by writing Lean 4 proofs. Trigger this skill whenever the user wants to formally verify code, generate Lean 4 proofs, prove properties about algorithms or smart contracts, verify invariants, convert program logic into formal specifications, or anything involving Lean 4 and formal verification. Also trigger when the user mentions "qedgen", "lean proof", "formal proof", "verify my code", "prove correctness", "formal verification", or wants mathematical guarantees about their implementation.

FileKindSize
Cargo.lockmanifest38.2 KB
Cargo.tomlmanifest347 B
LICENSEother1.0 KB
README.mdmarkdown4.1 KB
SKILL.mdskill md21.0 KB
claude.mdmarkdown9.7 KB
crates/qedgen/Cargo.tomlmanifest544 B
crates/qedgen/src/api.rsscript38.9 KB
crates/qedgen/src/asm2lean.rsscript26.2 KB
crates/qedgen/src/consolidate.rsscript6.2 KB
crates/qedgen/src/main.rsscript4.7 KB
crates/qedgen/src/project.rsscript3.0 KB
crates/qedgen/src/spec.rsscript19.4 KB
crates/qedgen/src/validate.rsscript5.6 KB
crates/qedgen/templates/Main.leanother154 B
crates/qedgen/templates/PROMPT_TEMPLATE.mdmarkdown3.2 KB
crates/qedgen/templates/README.lean.mdmarkdown1.6 KB
crates/qedgen/templates/lakefile.leanother292 B
crates/qedgen/templates/lean-toolchainother25 B
docs/CNAMEother10 B
docs/index.htmlother11.6 KB
docs/llms-full.txtmarkdown8.7 KB
docs/llms.txtmarkdown2.1 KB
docs/logo-dark.svgother648 B
docs/logo-light.svgother648 B
docs/qgn_demo.htmlother69.3 KB
docs/style.cssother8.1 KB
examples/rust/escrow/Anchor.tomlconfig353 B
examples/rust/escrow/Cargo.lockmanifest72.8 KB
examples/rust/escrow/Cargo.tomlmanifest215 B
examples/rust/escrow/migrations/deploy.tsscript428 B
examples/rust/escrow/package.jsonmanifest528 B
examples/rust/escrow/programs/escrow/Cargo.tomlmanifest376 B
examples/rust/escrow/programs/escrow/Xargo.tomlconfig62 B
examples/rust/escrow/programs/escrow/src/lib.rsscript6.7 KB
examples/rust/escrow/tests/escrow.tsscript8.6 KB
examples/rust/escrow/tsconfig.jsonconfig205 B
examples/rust/percolator/Cargo.lockmanifest8.5 KB
examples/rust/percolator/Cargo.tomlmanifest639 B
examples/rust/percolator/LICENSEother11.1 KB
examples/rust/percolator/README.mdmarkdown4.9 KB
examples/rust/percolator/examples/offsets.rsscript1.3 KB
examples/rust/percolator/scripts/audit-proof-strength.mdmarkdown6.4 KB
examples/rust/percolator/scripts/proof-strength-audit-results.mdmarkdown89.2 KB
examples/rust/percolator/scripts/run_kani_full_audit.shexecutablescript1.2 KB
examples/rust/percolator/spec.mdmarkdown108.4 KB
examples/rust/percolator/src/i128.rsscript20.4 KB
examples/rust/percolator/src/percolator.rsscript139.3 KB
examples/rust/percolator/src/wide_math.rsscript59.8 KB
examples/rust/percolator/tests/amm_tests.rsscript7.4 KB
examples/rust/percolator/tests/common/mod.rsscript4.7 KB
examples/rust/percolator/tests/fuzzing.proptest-regressionsother4.7 KB
examples/rust/percolator/tests/fuzzing.rsscript43.1 KB
examples/rust/percolator/tests/proofs_arithmetic.rsscript17.1 KB
examples/rust/percolator/tests/proofs_audit.rsscript35.0 KB
examples/rust/percolator/tests/proofs_instructions.rsscript64.8 KB
examples/rust/percolator/tests/proofs_invariants.rsscript21.0 KB
examples/rust/percolator/tests/proofs_lazy_ak.rsscript22.4 KB
examples/rust/percolator/tests/proofs_liveness.rsscript17.1 KB
examples/rust/percolator/tests/proofs_safety.rsscript104.2 KB
examples/rust/percolator/tests/proofs_v1131.rsscript25.4 KB
examples/rust/percolator/tests/unit_tests.rsscript93.8 KB
examples/sbpf/counter/src/counter.sother22.9 KB
examples/sbpf/slippage/src/asm-slippage/asm-slippage.sother698 B
examples/sbpf/transfer/src/transfer.sother2.4 KB
examples/sbpf/tree/src/tree.sother61.1 KB
install.shexecutablescript5.5 KB
lean_solana/QEDGen.leanother165 B
lean_solana/QEDGen/Solana.leanother165 B
lean_solana/QEDGen/Solana/Account.leanother4.0 KB
lean_solana/QEDGen/Solana/Authority.leanother285 B
lean_solana/QEDGen/Solana/Cpi.leanother9.0 KB
lean_solana/QEDGen/Solana/SBPF.leanother130 B
lean_solana/QEDGen/Solana/SBPF/Execute.leanother12.2 KB
lean_solana/QEDGen/Solana/SBPF/ISA.leanother5.1 KB
lean_solana/QEDGen/Solana/SBPF/Memory.leanother6.1 KB
lean_solana/QEDGen/Solana/SBPF/Tactic.leanother2.3 KB
lean_solana/QEDGen/Solana/State.leanother1.9 KB
lean_solana/QEDGen/Solana/Valid.leanother2.0 KB
lean_solana/README.mdmarkdown2.5 KB
lean_solana/lake-manifest.jsonconfig119 B
lean_solana/lakefile.leanother112 B
lean_solana/lean-toolchainother25 B
lean_solana/test_lemmas.leanother2.3 KB
package.jsonmanifest762 B
tools/qedgenexecutablescript357 B

examples/rust/percolator/tests/proofs_lazy_ak.rs

View on GitHub
//! Section 4 — A/K refinement, events, settlement
//!
//! One-event A/K semantics, composition, epoch settlement, non-compounding.

#![cfg(kani)]

mod common;
use common::*;

// ############################################################################
// T1: ONE-EVENT A/K SEMANTICS
// ############################################################################

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn t1_7_adl_quantity_only_lazy_conservative() {
    let q_base: u8 = kani::any();
    kani::assume(q_base > 0 && q_base <= 15);
    let oi: u8 = kani::any();
    kani::assume(oi > 0 && oi <= 15);
    let q_close: u8 = kani::any();
    kani::assume(q_close > 0 && q_close <= oi);
    let oi_post = oi - q_close;

    let a_old = S_ADL_ONE;
    let basis_q = (q_base as u16) * S_POS_SCALE;

    let eager_q = ((q_base as u16) * (oi_post as u16)) / (oi as u16);

    let a_new = a_after_adl(a_old, oi_post as u16, oi as u16);
    let lazy_q = lazy_eff_q(basis_q, a_new, a_old);
    let lazy_q_base = lazy_q / S_POS_SCALE;

    assert!(lazy_q_base <= eager_q, "ADL lazy must not exceed eager quantity");
    assert!(eager_q - lazy_q_base <= 1, "ADL lazy error must be bounded by 1 base unit");
}

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn t1_8_adl_deficit_only_lazy_equals_eager() {
    let q_base: u8 = kani::any();
    kani::assume(q_base > 0 && q_base <= 15);
    let oi: u8 = kani::any();
    kani::assume(oi > 0 && oi <= 15);
    let d: u8 = kani::any();
    kani::assume(d > 0 && d <= 15);

    let a_side = S_ADL_ONE;
    let k_init: i32 = 0;
    let basis_q = (q_base as u16) * S_POS_SCALE;

    let eager_loss = ((q_base as i32) * (d as i32)) / (oi as i32);

    let delta_k_abs = ((d as u32) * (a_side as u32) + (oi as u32) - 1) / (oi as u32);
    let delta_k = -(delta_k_abs as i32);
    let k_after = k_init + delta_k;
    let k_diff = k_after - k_init;

    let lazy_loss_raw = lazy_pnl(basis_q, k_diff, a_side);

    let lazy_loss = -lazy_loss_raw;
    assert!(lazy_loss >= eager_loss, "ADL deficit lazy must be at least as large as eager");
    assert!(lazy_loss <= eager_loss + (q_base as i32),
        "ADL deficit lazy overshoot must be bounded by q_base");
}

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn t1_9_adl_quantity_plus_deficit_lazy_conservative() {
    let q_base: u8 = kani::any();
    kani::assume(q_base > 0 && q_base <= 15);
    let oi: u8 = kani::any();
    kani::assume(oi > 0 && oi >= q_base && oi <= 15);
    let q_close: u8 = kani::any();
    kani::assume(q_close > 0 && q_close <= oi);
    let d: u8 = kani::any();
    kani::assume(d > 0 && d <= 15);

    let oi_post = oi - q_close;
    let a_old = S_ADL_ONE;
    let basis_q = (q_base as u16) * S_POS_SCALE;

    let eager_q = ((q_base as u16) * (oi_post as u16)) / (oi as u16);

    let a_new = a_after_adl(a_old, oi_post as u16, oi as u16);
    let lazy_q = lazy_eff_q(basis_q, a_new, a_old) / S_POS_SCALE;

    assert!(lazy_q <= eager_q, "lazy must not exceed eager quantity");
    assert!(eager_q - lazy_q <= 1, "lazy error bounded by 1 base unit");

    let delta_k_abs = ((d as u32) * (a_old as u32) + (oi as u32) - 1) / (oi as u32);
    let delta_k = -(delta_k_abs as i32);
    let lazy_loss = -lazy_pnl(basis_q, delta_k, a_old);
    let eager_loss = ((q_base as i32) * (d as i32)) / (oi as i32);

    assert!(lazy_loss >= eager_loss, "ADL PnL: lazy loss must be >= eager loss (conservative)");
    assert!(lazy_loss <= eager_loss + (q_base as i32),
        "ADL PnL: lazy overshoot must be bounded by q_base");
}

// ============================================================================
// T1.8b: symbolic a_basis generalization
// ============================================================================

#[kani::proof]
#[kani::unwind(1)]
#[kani::solver(cadical)]
fn t1_8b_adl_deficit_lazy_conservative_symbolic_a_basis() {
    let q_base: u8 = kani::any();
    kani::assume(q_base > 0 && q_base <= 15);
    let oi: u8 = kani::any();
    kani::assume(oi > 0 && oi <= 15);
    let d: u8 = kani::any();
    kani::assume(d > 0 && d <= 15);

    let a_basis: u16 = kani::any();
    kani::assume(a_basis > 0 && a_basis <= S_ADL_ONE);

    let k_init: i32 = 0;
    let basis_q = (q_base as u16) * S_POS_SCALE;

    let eager_loss = ((q_base as i32) * (d as i32)) / (oi as i32);

    let delta_k_abs = ((d as u32) * (a_basis as u32) + (oi as u32) - 1) / (oi as u32);
    let delta_k = -(delta_k_abs as i32);
    let lazy_loss_raw = lazy_pnl(basis_q, delta_k, a_basis);

    let lazy_loss = -lazy_loss_raw;
    assert!(lazy_loss >= eager_loss,
        "ADL deficit lazy must be at least as large as eager for symbolic a_basis");
}

// ############################################################################
// T2: COMPOSITION PROOFS
// ############################################################################

#[kani::proof]
#[kani::unwind(1)]
#[kani::solver(cadical)]
fn t2_12_floor_shift_lemma() {
    let n: i8 = kani::any();
    let m: i8 = kani::any();
    let d: u8 = kani::any();
    kani::assume(d > 0);

    let d32 = d as i32;
    let n32 = n as i32;
    let m32 = m as i32;
    let shifted = n32 + m32 * d32;

    let floor_n = if n32 >= 0 { n32 / d32 } else { -((-n32 + d32 - 1) / d32) };
    let floor_shifted = if shifted >= 0 { shifted / d32 } else { -((-shifted + d32 - 1) / d32) };

    assert!(floor_shifted == floor_n + m32,
        "floor(n + m*d, d) must equal floor(n, d) + m");
}

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn t2_12_fold_step_case() {
    let q_base: u8 = kani::any();
    kani::assume(q_base > 0);
    let dp: i8 = kani::any();
    let a = S_ADL_ONE;
    let den = (a as i32) * (S_POS_SCALE as i32);
    let basis_q = (q_base as u16) * S_POS_SCALE;

    let exact = (basis_q as i32) * (a as i32);
    assert!(exact % den == 0, "basis_q * A must be divisible by den");
    assert!(exact / den == q_base as i32, "quotient must equal q_base");

    let k_prefix: i8 = kani::any();
    let k_new = (k_prefix as i32) + (a as i32) * (dp as i32);
    let eager_step = (q_base as i32) * (dp as i32);
    let lazy_total = lazy_pnl(basis_q, k_new, a);
    let lazy_prefix = lazy_pnl(basis_q, k_prefix as i32, a);
    let lazy_step = lazy_total - lazy_prefix;

    assert!(lazy_step == eager_step, "fold step: lazy increment must equal eager step");
}

// ############################################################################
// T2.14: COMPOSITION ACROSS A-CHANGING EVENT (mark → ADL → mark)
// ############################################################################
//
// Spec §5.1 says events compose: A_new = A_old * α, K_new = K_old + A_old * β.
// This test verifies the algebraic identity when A is modified by an ADL event
// between two mark events. None of the existing t2_1x proofs change A.

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn t2_14_compose_mark_adl_mark() {
    // Symbolic inputs — small-model scale
    let q_base: u8 = kani::any();
    kani::assume(q_base > 0 && q_base <= 10);
    let dp1: i8 = kani::any();
    kani::assume(dp1 >= -10 && dp1 <= 10);
    let dp2: i8 = kani::any();
    kani::assume(dp2 >= -10 && dp2 <= 10);

    // ADL parameters: remove q_adl from OI, shrinking A
    let oi: u8 = kani::any();
    kani::assume(oi >= 2 && oi <= 15);
    let q_adl: u8 = kani::any();
    kani::assume(q_adl > 0 && q_adl < oi);
    let oi_post = oi - q_adl;

    let a0 = S_ADL_ONE;
    let basis_q = (q_base as u16) * S_POS_SCALE;

    // Eager sequence: mark1 → ADL → mark2
    // Mark 1: PnL = q_base * dp1
    let eager_mark1 = (q_base as i32) * (dp1 as i32);

    // ADL: A changes from a0 to a_new = floor(a0 * oi_post / oi)
    let a_new = a_after_adl(a0, oi_post as u16, oi as u16);
    kani::assume(a_new > 0);

    // After ADL, effective q shrinks: q_eff_new = floor(basis_q * a_new / a0)
    let q_eff_new = lazy_eff_q(basis_q, a_new, a0);
    kani::assume(q_eff_new > 0);

    // Mark 2: idealized eager PnL = floor(q_base * a_new * dp2 / a0)
    // No intermediate position rounding — matches how K accumulates in the lazy model
    let mark2_num = (q_base as i32) * (a_new as i32) * (dp2 as i32);
    let mark2_den = a0 as i32;
    let eager_mark2 = if mark2_num >= 0 {
        mark2_num / mark2_den
    } else {
        let abs_num = -mark2_num;
        -((abs_num + mark2_den - 1) / mark2_den)
    };
    let eager_total = eager_mark1 + eager_mark2;

    // Lazy sequence: K accumulates both marks, but the ADL changes A mid-stream
    let k0: i32 = 0;
    // K after first mark (at A = a0)
    let k1 = k_after_mark_long(k0, a0, dp1 as i32);
    // K after ADL: K doesn't change from ADL quantity socialization with D=0
    let k_after_adl = k1;
    // K after second mark (at A = a_new, post-ADL)
    let k2 = k_after_mark_long(k_after_adl, a_new, dp2 as i32);

    // Lazy PnL: evaluate at original basis with k_diff = k2 - k0
    let k_diff = k2 - k0;
    let lazy_total = lazy_pnl(basis_q, k_diff, a0);

    assert!(eager_total == lazy_total,
        "composition across A-changing ADL event: eager != lazy");
}

// ############################################################################
// T3: EPOCH SETTLEMENT (subset)
// ############################################################################

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn t3_14_epoch_mismatch_forces_terminal_close() {
    let mut engine = RiskEngine::new(zero_fee_params());
    let idx = engine.add_user(0).unwrap();
    engine.deposit(idx, 1_000_000, 100, 0).unwrap();

    let pos_mul: u8 = kani::any();
    kani::assume(pos_mul > 0);
    let pos = (POS_SCALE * (pos_mul as u128)) as i128;
    engine.accounts[idx as usize].position_basis_q = pos;
    engine.accounts[idx as usize].adl_a_basis = ADL_ONE;
    let k_snap_val: i8 = kani::any();
    let k_snap = k_snap_val as i128;
    engine.accounts[idx as usize].adl_k_snap = k_snap;
    engine.accounts[idx as usize].adl_epoch_snap = 0;
    engine.stored_pos_count_long = 1;

    // Use a DIFFERENT k_epoch_start so k_diff is non-trivial (not always 0)
    let k_start_val: i8 = kani::any();
    let k_epoch_start = k_start_val as i128;

    engine.adl_epoch_long = 1;
    engine.adl_epoch_start_k_long = k_epoch_start;
    engine.side_mode_long = SideMode::ResetPending;
    engine.stale_account_count_long = 1;

    let pnl_before = engine.accounts[idx as usize].pnl;

    let result = engine.settle_side_effects(idx as usize);
    assert!(result.is_ok());

    assert!(engine.accounts[idx as usize].position_basis_q == 0);
    assert!(engine.stale_account_count_long == 0);
    assert!(engine.accounts[idx as usize].adl_epoch_snap == 1);

    // PnL assertion: the settlement must credit the correct amount
    let abs_basis = pos as u128;
    let den = ADL_ONE * POS_SCALE;
    let expected_pnl_delta = wide_signed_mul_div_floor_from_k_pair(abs_basis, k_epoch_start, k_snap, den);
    assert!(engine.accounts[idx as usize].pnl == pnl_before + expected_pnl_delta,
        "epoch mismatch PnL must match wide_signed_mul_div_floor_from_k_pair");
}

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn t3_14b_epoch_mismatch_with_nonzero_k_diff() {
    let mut engine = RiskEngine::new(zero_fee_params());
    let idx = engine.add_user(0).unwrap();
    engine.deposit(idx, 10_000_000, 100, 0).unwrap();

    let pos = POS_SCALE as i128;
    engine.accounts[idx as usize].position_basis_q = pos;
    engine.accounts[idx as usize].adl_a_basis = ADL_ONE;
    engine.accounts[idx as usize].adl_epoch_snap = 0;
    engine.stored_pos_count_long = 1;

    let k_snap_val: i8 = kani::any();
    let k_snap = k_snap_val as i128;
    engine.accounts[idx as usize].adl_k_snap = k_snap;

    let k_diff_val: i8 = kani::any();
    kani::assume(k_diff_val != 0);
    let k_epoch_start_val = (k_snap_val as i16) + (k_diff_val as i16);
    kani::assume(k_epoch_start_val >= -120 && k_epoch_start_val <= 120);
    let k_epoch_start = k_epoch_start_val as i128;

    engine.adl_coeff_long = 0i128;
    engine.adl_epoch_long = 1;
    engine.adl_epoch_start_k_long = k_epoch_start;
    engine.side_mode_long = SideMode::ResetPending;
    engine.stale_account_count_long = 1;

    let pnl_before = engine.accounts[idx as usize].pnl;

    let result = engine.settle_side_effects(idx as usize);
    assert!(result.is_ok());

    assert!(engine.accounts[idx as usize].position_basis_q == 0);
    assert!(engine.stale_account_count_long == 0);
    assert!(engine.accounts[idx as usize].adl_epoch_snap == 1);

    // PnL assertion: the settlement must credit the correct amount
    let abs_basis = pos as u128;
    let den = ADL_ONE * POS_SCALE;
    let expected_pnl_delta = wide_signed_mul_div_floor_from_k_pair(abs_basis, k_epoch_start, k_snap, den);
    assert!(engine.accounts[idx as usize].pnl == pnl_before + expected_pnl_delta,
        "epoch mismatch PnL must match wide_signed_mul_div_floor_from_k_pair");
}

// ############################################################################
// T7: NON-COMPOUNDING BASIS PROOFS
// ############################################################################

#[kani::proof]
#[kani::unwind(1)]
#[kani::solver(cadical)]
fn t7_28a_noncompounding_floor_inequality_correct_direction() {
    let basis: u8 = kani::any();
    kani::assume(basis > 0);
    let a_basis: u8 = kani::any();
    kani::assume(a_basis > 0);

    let k1: i8 = kani::any();
    let k2_delta: i8 = kani::any();
    let k2_val = (k1 as i16) + (k2_delta as i16);
    kani::assume(k2_val >= -120 && k2_val <= 120);

    const S_POS_SCALE_LOCAL: i32 = 4;
    let den = (a_basis as i32) * S_POS_SCALE_LOCAL;
    kani::assume(den > 0);

    let floor_div = |num: i32, d: i32| -> i32 {
        if num >= 0 { num / d } else { (num - d + 1) / d }
    };

    let pnl_1 = floor_div((basis as i32) * (k1 as i32), den);
    let pnl_2 = floor_div((basis as i32) * (k2_delta as i32), den);
    let total_two_touch = pnl_1 + pnl_2;

    let pnl_single = floor_div((basis as i32) * (k2_val as i32), den);

    assert!(total_two_touch <= pnl_single,
        "two-touch sum must be <= single-touch (floor splits lose fractional parts)");
    assert!(pnl_single <= total_two_touch + 1,
        "single-touch must be at most 1 unit above two-touch sum");
}

#[kani::proof]
#[kani::unwind(1)]
#[kani::solver(cadical)]
fn t7_28b_noncompounding_exact_additivity_divisible_increments() {
    let basis: u8 = kani::any();
    kani::assume(basis > 0);
    // In the real engine, position_basis_q is always POS_SCALE-aligned
    kani::assume(basis % 4 == 0);
    let a_basis: u8 = kani::any();
    kani::assume(a_basis > 0);

    let dp1: i8 = kani::any();
    let dp2: i8 = kani::any();
    let dp_total = (dp1 as i16) + (dp2 as i16);
    kani::assume(dp_total >= -120 && dp_total <= 120);

    const S_POS_SCALE_LOCAL: i32 = 4;
    let den = (a_basis as i32) * S_POS_SCALE_LOCAL;
    kani::assume(den > 0);

    let k1 = (a_basis as i32) * (dp1 as i32);
    let k2_delta = (a_basis as i32) * (dp2 as i32);
    let k_total = (a_basis as i32) * (dp_total as i32);

    let floor_div = |num: i32, d: i32| -> i32 {
        if num >= 0 { num / d } else { (num - d + 1) / d }
    };

    let pnl_1 = floor_div((basis as i32) * k1, den);
    let pnl_2 = floor_div((basis as i32) * k2_delta, den);
    let total_two_touch = pnl_1 + pnl_2;

    let pnl_single = floor_div((basis as i32) * k_total, den);

    assert!(total_two_touch == pnl_single,
        "exact additivity when K increments are multiples of a_basis");
}

// ############################################################################
// T6: FOCUSED SCENARIO PROOFS (REGRESSIONS)
// ############################################################################

#[kani::proof]
#[kani::unwind(1)]
#[kani::solver(cadical)]
fn t6_24_worked_example_regression() {
    let a_init = S_ADL_ONE;
    let pos_scale = S_POS_SCALE;

    let q_l1: u16 = 8;
    let basis_l1 = q_l1 * pos_scale;
    let a_basis_l1 = a_init;
    let k_snap_l1: i32 = 0;

    let oi: u16 = 8;
    let mut k_long: i32 = 0;
    let a_long = a_init;

    let dp = 10i32;
    k_long = k_after_mark_long(k_long, a_long, dp);

    let l1_pnl_pre = lazy_pnl(basis_l1, k_long - k_snap_l1, a_basis_l1);
    assert!(l1_pnl_pre == 80, "L1 pre-ADL PnL should be 80");

    let q_close: u16 = 5;
    let d: u16 = 2;
    let oi_post = oi - q_close;
    assert!(oi_post > 0);

    let delta_k_abs = ((d as u32) * (a_long as u32) + (oi as u32) - 1) / (oi as u32);
    assert!(delta_k_abs == 64);
    let delta_k = -(delta_k_abs as i32);
    k_long = k_long + delta_k;

    let a_long_new = a_after_adl(a_long, oi_post, oi);
    assert!(a_long_new == 96);

    let k_diff = k_long - k_snap_l1;
    let q_eff = lazy_eff_q(basis_l1, a_long_new, a_basis_l1);
    assert!(q_eff == 12, "L1 effective quantity after ADL");
    let l1_pnl_post = lazy_pnl(basis_l1, k_diff, a_basis_l1);
    assert!(l1_pnl_post == 78, "L1 post-ADL PnL includes deficit");

    assert!(l1_pnl_post < l1_pnl_pre, "deficit must reduce PnL");
    assert!(l1_pnl_post > 0, "PnL still positive from mark gain");
}

#[kani::proof]
#[kani::unwind(1)]
#[kani::solver(cadical)]
fn t6_25_pure_pnl_bankruptcy_regression() {
    let oi: u8 = kani::any();
    kani::assume(oi > 0);
    let d: u8 = kani::any();
    kani::assume(d > 0);
    let q_base: u8 = kani::any();
    kani::assume(q_base > 0 && q_base <= oi);

    let a_opp = S_ADL_ONE;
    let basis_q = (q_base as u16) * S_POS_SCALE;

    let delta_k_abs = ((d as u32) * (a_opp as u32) + (oi as u32) - 1) / (oi as u32);
    assert!(delta_k_abs > 0);

    let delta_k = -(delta_k_abs as i32);
    assert!(delta_k < 0);

    let pnl = lazy_pnl(basis_q, delta_k, a_opp);
    assert!(pnl <= 0);

    let eager_loss = ((q_base as i32) * (d as i32)) / (oi as i32);
    assert!(-pnl >= eager_loss, "lazy loss must be >= eager floor loss (conservative)");
}

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn t6_26_full_drain_reset_regression() {
    let mut engine = RiskEngine::new(zero_fee_params());

    let idx = engine.add_user(0).unwrap();
    engine.deposit(idx, 1_000_000, 100, 0).unwrap();

    let k_snap_val: i8 = kani::any();
    let k_snap = k_snap_val as i128;
    let pos_mul: u8 = kani::any();
    kani::assume(pos_mul > 0);

    // Use a different k_epoch_start so settlement PnL is nonzero
    let k_start_val: i8 = kani::any();
    kani::assume(k_start_val != k_snap_val);
    let k_epoch_start = k_start_val as i128;

    engine.accounts[idx as usize].position_basis_q = (POS_SCALE * (pos_mul as u128)) as i128;
    engine.accounts[idx as usize].adl_a_basis = ADL_ONE;
    engine.accounts[idx as usize].adl_k_snap = k_snap;
    engine.accounts[idx as usize].adl_epoch_snap = 0;
    engine.stored_pos_count_long = 1;

    // Set adl_coeff_long to k_epoch_start so begin_full_drain_reset captures it
    engine.adl_coeff_long = k_epoch_start;

    engine.oi_eff_long_q = 0u128;
    engine.begin_full_drain_reset(Side::Long);

    assert!(engine.side_mode_long == SideMode::ResetPending);
    assert!(engine.adl_epoch_long == 1);
    assert!(engine.stale_account_count_long == 1);
    assert!(engine.adl_epoch_start_k_long == k_epoch_start);

    let pnl_before = engine.accounts[idx as usize].pnl;

    let result = engine.settle_side_effects(idx as usize);
    assert!(result.is_ok());

    assert!(engine.accounts[idx as usize].position_basis_q == 0);
    assert!(engine.stale_account_count_long == 0);

    // PnL assertion: settlement must credit the correct amount
    let abs_basis = (POS_SCALE * (pos_mul as u128)) as u128;
    let den = ADL_ONE * POS_SCALE;
    let expected_pnl_delta = wide_signed_mul_div_floor_from_k_pair(abs_basis, k_epoch_start, k_snap, den);
    assert!(engine.accounts[idx as usize].pnl == pnl_before + expected_pnl_delta,
        "full drain reset PnL must match wide_signed_mul_div_floor_from_k_pair");

    assert!(engine.stored_pos_count_long == 0);
    let finalize = engine.finalize_side_reset(Side::Long);
    assert!(finalize.is_ok());
    assert!(engine.side_mode_long == SideMode::Normal);
}

// ############################################################################
// SPEC §12 PROPERTY #43: K-pair chronology correctness
// ############################################################################

#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_property_43_k_pair_chronology_correctness() {
    // Same-epoch settlement must pass (k_side, k_snap) in chronological order
    // such that a known loss is not settled as a gain.
    // We set up: k_snap < k_side (K has increased), and a long position.
    // For a long, k_side > k_snap means positive PnL (price went up).
    // If arguments were swapped, PnL would flip sign.
    let mut engine = RiskEngine::new(zero_fee_params());
    let idx = engine.add_user(0).unwrap();
    engine.deposit(idx, 1_000_000, DEFAULT_ORACLE, DEFAULT_SLOT).unwrap();

    // Set up a long position with k_snap = 100
    let pos = 10 * POS_SCALE as i128;
    engine.accounts[idx as usize].position_basis_q = pos;
    engine.accounts[idx as usize].adl_a_basis = ADL_ONE;
    engine.accounts[idx as usize].adl_k_snap = 100;
    engine.accounts[idx as usize].adl_epoch_snap = 0;
    engine.stored_pos_count_long = 1;
    engine.oi_eff_long_q = 10 * POS_SCALE;
    engine.oi_eff_short_q = 10 * POS_SCALE;

    // Set k_side > k_snap (price moved up => long should profit)
    engine.adl_coeff_long = 500;

    let pnl_before = engine.accounts[idx as usize].pnl;

    // settle_side_effects uses the real engine ordering
    let result = engine.settle_side_effects(idx as usize);
    assert!(result.is_ok());

    let pnl_after = engine.accounts[idx as usize].pnl;
    let pnl_delta = pnl_after - pnl_before;

    // With k_side=500, k_snap=100, the correct chronological call is
    // wide_signed_mul_div_floor_from_k_pair(abs_basis, k_side=500, k_snap=100, den)
    // = floor(10*POS_SCALE * (500 - 100) / (ADL_ONE * POS_SCALE))
    // = floor(10_000_000 * 400 / 1_000_000_000_000) = floor(4_000_000_000 / 1_000_000_000_000) = 0
    // Actually with these small numbers... let me use larger K values.
    // The key assertion: the PnL delta must match the reference computation
    let abs_basis = pos as u128;
    let den = ADL_ONE * POS_SCALE;
    let expected = wide_signed_mul_div_floor_from_k_pair(abs_basis, 500i128, 100i128, den);
    assert!(pnl_delta == expected,
        "settle PnL must match chronological k_pair computation");

    // The WRONG order would give the negation:
    let wrong = wide_signed_mul_div_floor_from_k_pair(abs_basis, 100i128, 500i128, den);
    // If expected != 0, wrong must have opposite sign
    if expected != 0 {
        assert!(wrong == -expected || (expected > 0 && wrong < 0) || (expected < 0 && wrong > 0),
            "swapped arguments must produce opposite-sign PnL");
    }
}
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall